diff --git a/research/p104-receiver-ingress-repair/PROOF.md b/research/p104-receiver-ingress-repair/PROOF.md new file mode 100644 index 0000000000..af5185f0ed --- /dev/null +++ b/research/p104-receiver-ingress-repair/PROOF.md @@ -0,0 +1,56 @@ +# The sharp chart-3 ingress threshold at chart 278 + +## Communication model + +Use the pinned #7786 word on 1,289 independent rational inputs. Remove its two-slot route $278\to288\to127$. The proposed collapse sends from 278 directly to 127. Chart 278 originally receives six scalars from chart 3, two from 11 and two from 58. It has no original public inputs or terminals. It emits nine surviving scalars besides its old slot 95914. Permit simultaneous rational-linear recoding of every one of these ten incoming and nine outgoing payloads on its original route. The 387 terminals outside 127 must retain their original values on all inputs. The 901 surviving deposits at 127 may change, and 127 may recode its outputs using its entire stock. All operations beyond these specified edits retain their original rules. The source word has no egress from 127. + +To count the core ingress capacity, allow additional rational-linear sends from the three existing ingress donors to 278, and additional direct sends from 278 to 127. The nine surviving egress routes remain charged at their original grades. Each core slot carries one rational scalar obtained by a fixed linear operation. The following result allows arbitrary many additional sends from charts 11 and 58 and from 278 to 127. An instance with seven core slots actually needs only the two original sends from each edge donor and a single direct send. [Original word and attribution](https://github.com/CrocSwap/integer-mult-bounds/tree/89a67c404226d51028e135de2b9169e9020d57af/research/p104-iterated-returns/continuation) · [Six paired edits considered in #7795](https://github.com/CrocSwap/integer-mult-bounds/blob/0893abefcc894991b67b2315f7e85e0dc4d58c5e/research/p104-paid88-stock-cones/STOCK.md) · [Previous cooperative frozen-cut result](https://github.com/apoursh/integer-mult-bounds/blob/c44a0313cb1aee8b94803691529d1c109779f2f2/research/p104-receiver-relay/PROOF.md) + +## Six exterior demands saturate all six core channels + +Work in the dual space of the public input coordinates. Write $E$ for the span of the two edge senders' frozen stock. They have two local public scalars and four original incoming scalars each. These incoming values have all arrived before the first surviving egress from 278. The core donor 3 has only its initial public coordinates. Thus the edge stocks used by any legal edit lie in $E$, even if we grant all twelve atoms at the start. + +Write $h_1,\ldots,h_6$ for the six original core messages in chronological order, at slots 94953, 95493, 95884, 95982, 96109, 100334. Expanding their exact public forms and the twelve edge atoms gives rank 18. Hence modulo $E$ all six core forms are independent. Let $H=\operatorname{span}(h_1,\ldots,h_6)$ and write $H'$ for the span of the new core messages in a proposed repair. + +Treat the nine surviving egress values as boundary variables, in their original slots. With those variables prescribed, the rest of the exterior is a fixed linear circuit. The ten ingress changes can reach an exterior observation only through these nine egresses. The removed slot 95914 had only one reader, 88, and the receiver has no egress. If $P$ is the matrix of exterior responses to the nine boundary variables and $y,y'$ are the nine old and new forms, equality of the exterior implies $P y'=P y$. The common contribution from public inputs outside the boundary cancels identically. The exact matrix on the 387 exterior terminals has rank eight. Its sole invisible direction increases slot 95887 and decreases slot 100336 by the same amount. In particular, preserving the exterior allows the individual egress values and some retained receiver deposits to change. + +Now consider just six rows of $P y$, listed below in the core basis **after quotienting by $E$**. The native nine boundary forms are computed at chart 278, so this quotient is well defined. All omitted contributions are edge-sender forms. [Exact row reconstruction and pulse check](check_exterior.py) + +| Exterior terminal | $h_1$ | $h_2$ | $h_3$ | $h_4$ | $h_5$ | $h_6$ | +|---|---:|---:|---:|---:|---:|---:| +| 154880 | 0 | −1 | 0 | 0 | 0 | 0 | +| 154881 | 0 | −1 | 1 | 0 | 1 | 0 | +| 154887 | −1/4 | 0 | 0 | 0 | 0 | 0 | +| 154895 | 0 | 0 | −1 | 0 | −1 | −1 | +| 154950 | 0 | −1 | −1/4 | 0 | 0 | 0 | +| 154959 | −1/4 | 1 | 0 | 1 | 0 | 0 | + +This matrix is nonsingular. Every new egress form belongs to $E+H'$, so the six equalities force $H\subset E+H'$. If there are at most six core sends, the image of $H'$ modulo $E$ has dimension at most six. It contains all of the six-dimensional image of $H$, hence it equals that image. It follows that **all new chart-278 stock and emissions lie in the fixed 18-dimensional space $E+H$**, regardless of the legal local re-encodings. This finite-capacity conclusion is the part that would fail with a seventh core slot. + +## A separating public input + +Set all unlisted coordinates to zero and use the following rational input. + +| Coordinate | 663 | 770 | 780 | 825 | 1055 | 1225 | 1238 | 1239 | 1288 | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| Value | −2 | −2 | −1 | −1 | 218/1395 | 17/2 | 1888/333 | 64/27 | −1/845660160 | + +The input annihilates the twelve edge atoms and six original core forms, all nine old egresses, and all 901 old surviving receiver arrivals. The original terminal 155442 equals $x_{674}-x_{780}=1$. Under any proposed repair with at most six core sends every new scalar leaving 278 vanishes on the same input. Each old egress also vanished, so the unmodified exterior still supplies its *original* values at all 901 surviving deposits on this input, even though these deposits were allowed to change as operators. Every new direct send from 278 vanishes as well. Receiver 127 has no primary coordinates and sees the same data here as on zero. It cannot recover the required value on both inputs, even with a deterministic nonlinear readout. A second checker independently reconstructs these nine values by backward substitution through the native word. On the displayed support the annihilating equations have rank eight, so the input is uniquely determined there by the normalization $y_1=1$. [Full forward evaluation](check_input.py) · [Independent reverse reconstruction](check_separator.py) + +## A matching seven-slot construction + +Keep all ten original ingresses to 278 and all nine surviving egresses. Write $d$ for the original deposit 94217. Its form at chart 11 is $d=x_{674}-v_{90590}-v_{90592}$, where $v_{90590}$ and $v_{90592}$ were originally transmitted from chart 3 to 11. Both are rational forms of chart 3's public coordinates. At the old time of 95914 transmit +$$ +s=x_{780}-v_{90590}-v_{90592} +$$ +from 3 to 278. At the old time of 88, chart 278 sends the single direct scalar $z=d-s=x_{674}-x_{780}$ to 127. + +Return $z$ for old terminal $y_1=155442$. Both affected native terminals $y_1,y_2=155490$ used 88 with coefficient one. Their original difference $y_2-y_1$ therefore uses only retained receiving terms. For the second terminal return that local difference plus $z$. The verifier builds the literal chronological word, checks all dependencies and owners, expands both changed terminals in all 1,289 independent coordinates, and checks that the other 1,287 terminals have no changed reader. It also detects a sign error in the direct packet. This construction is feasible even with all 901 old surviving deposits preserved exactly. [Constructive operator replay](check_repair.py) + +These checks prove the exact capacity threshold of seven core ingresses. If the original ten incoming and nine surviving outgoing ports stay funded, a required direct replacement costs at least the grade-two extra ingress and the grade-seven direct send. The construction attains this paid-port bill. At the enrolled $p(r)=r^{1-0.00387981257853}$, relative to the two removed transfers of grades two and five, the excess over 48 rational calls obeys +$$ +94.966797106425725799489376 < 48[p(7)-p(5)] < 94.966797106425725799489377. +$$ +The new ingress, written directly on native public coordinates, has 299 nonzero terms. Its largest numerator and denominator have bit lengths 30 and 7. This accounts for paid scalar ports in the stated rational model. A full caller would additionally need a legal local arithmetic schedule, coefficient and conversion budgets, and all other accounting required by the construction. + +The result leaves other donor routes, edits beyond these nineteen local rules, and retirement of funded ports open. Prepared by apoursh with substantial OpenAI Codex assistance. diff --git a/research/p104-receiver-ingress-repair/README.md b/research/p104-receiver-ingress-repair/README.md new file mode 100644 index 0000000000..429309b2dc --- /dev/null +++ b/research/p104-receiver-ingress-repair/README.md @@ -0,0 +1,23 @@ +# Seven core ingresses are necessary and sufficient for the P104 chart-278 collapse + +On the rational word of #7786, replacing the route $278\to288\to127$ by a direct send from 278 to 127 requires **seven incoming scalars from chart 3**. The original chart has six. This remains true when all ten old ingress payloads and all nine other egress payloads at 278 may be jointly recoded and all 901 surviving receiving deposits may change. The lower bound even grants arbitrary many extra messages from the other two original donors, 11 and 58. A seventh core ingress attains exact recovery on all 1,289 rational input coordinates. [Proof and precise communication model](PROOF.md) + +Six exterior observations force the full six-dimensional image of the original core traffic modulo the two other donors' stock. This confines all possible six-channel recodings to a fixed 18-dimensional space. A nine-coordinate input kills that space and all old receiver deposits, while the required receiver output is one. The seven-channel realization preserves all original surviving deposits and requires a 299-term rational ingress. With the original ports kept funded, its exact paid-port surcharge is **94.9667971064257…** signed units across 48 rational calls. The selected multiplication bound is unchanged. [Exterior rank certificate](check_exterior.py) · [Separating input](check_input.py) · [Independent adjoint reconstruction](check_separator.py) · [Seven-slot recovery and price](check_repair.py) + +The previous direct and cooperative routing results fixed the other paid observations. Here the nineteen local paid rules and the consequent receiver deposits may change. The earlier six-pair study considered specific pairs of paid payloads and protected the receiving arrivals. [#7795 paid-pair analysis](https://github.com/CrocSwap/integer-mult-bounds/pull/7795) · [#7807 direct-send result](https://github.com/CrocSwap/integer-mult-bounds/pull/7807) · [#7808 cooperative routing](https://github.com/CrocSwap/integer-mult-bounds/pull/7808) · [Coordination claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19756126) + +## Reproduce + +From the repository root run the registered package with CPython 3.12. The checks use the Python standard library and authenticate the retained source word. All scalar, rank and tariff certificates use rational arithmetic. + +~~~sh +python3.12 -B scripts/research_package.py --package research/p104-receiver-ingress-repair +~~~ + +## Open next questions + +Can a change at a distinct donor or a retired funded port move useful information to chart 278 at a lower cost? Start with the nine-coordinate input in the proof and identify a chart supplying a scalar outside the certified 18-dimensional space. Check the full rank of the affected exterior pulse columns, protected terminal recoverability, and the complete signed bill. The current construction gives a concrete comparison against the best existing core-only augmentation. + +## Attribution + +Clear1nsight supplied the rational word, its four-return continuation and the paid-pair handoff, following the signed P104 framework of Ali Romman and the contributors in the retained notices. apoursh's direct and cooperative repair results supplied the frozen cut, the source reader, and the receiving-terminal recoding used in the construction. The present variable-stock threshold, exterior rank argument, separator and seventh-port realization were prepared by apoursh with substantial OpenAI Codex assistance under Apache-2.0. [Retained source pins](SOURCE-PINS.json) · [Original notice](retained/PR7786-NOTICE) · [Predecessor notice](retained/PR7795-NOTICE) · [License](retained/LICENSE) diff --git a/research/p104-receiver-ingress-repair/SOURCE-PINS.json b/research/p104-receiver-ingress-repair/SOURCE-PINS.json new file mode 100644 index 0000000000..5a66e4f51c --- /dev/null +++ b/research/p104-receiver-ingress-repair/SOURCE-PINS.json @@ -0,0 +1,58 @@ +{ + "artifacts": [ + { + "local": "retained/WORD.json.gz", + "source": 7786, + "head": "89a67c404226d51028e135de2b9169e9020d57af", + "original_path": "research/p104-iterated-returns/continuation/WORD.json.gz", + "bytes": 614180, + "git_blob": "337a9d4f8b36f3bd4acc5651810e4e846e287435", + "sha256": "fde0f7eaa3749d0934a9fc0d6320074f021cd722ed6753f3a59a62fb5b221949", + "uncompressed_sha256": "c447b6d5ba956fbe40834fe3c1bc69af2f225736f1b97ecd84b57bab9dd283cb" + }, + { + "local": "retained/PR7795-NOTICE", + "source": 7795, + "head": "0893abefcc894991b67b2315f7e85e0dc4d58c5e", + "original_path": "research/p104-paid88-stock-cones/NOTICE", + "bytes": 1432, + "git_blob": "6cbfdc843fd7cd3227c7bd7925c891499d93098d", + "sha256": "8df09db925c14a4ec17e578455dd68b72714e15990cee40936212ce7408132cc" + }, + { + "local": "word.py", + "source": 7807, + "head": "864d15105ceb2f7a5cdbc6bedc72a9bc273d5e8e", + "original_path": "research/p104-receiver-single-send/word.py", + "bytes": 1769, + "git_blob": "c42aa2db122c612f08e7f559ff02cc5b6d4f0844", + "sha256": "6d0af9a2699a34d6df36b20cd24d441b1c6cc0645483bbc0affec8aacc6b0e28" + }, + { + "local": "retained/PR7786-NOTICE", + "source": 7807, + "head": "864d15105ceb2f7a5cdbc6bedc72a9bc273d5e8e", + "original_path": "research/p104-receiver-single-send/retained/PR7786-NOTICE", + "bytes": 1048, + "git_blob": "3b083891bf59f449b49df024ab7df3feaf6054b8", + "sha256": "4f7d16a4dcaae02de7e7583f7fbb14d5edd19dc4c10b4f47571c145204505844" + }, + { + "local": "retained/LICENSE", + "source": 7807, + "head": "864d15105ceb2f7a5cdbc6bedc72a9bc273d5e8e", + "original_path": "research/p104-receiver-single-send/retained/LICENSE", + "bytes": 11357, + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ], + "tariff": { + "pr": 7795, + "head": "0893abefcc894991b67b2315f7e85e0dc4d58c5e", + "path": "research/p104-paid88-stock-cones/cones/SOURCE.json", + "git_blob": "c0da8ca07dc256f47a980e5ad1a969f7616ab08a", + "sha256": "f5087c4d8aa394049eb0ab08adace0d295009306900f29e9db1a07706a10fba2", + "use": "Tariff and incumbent price context. The replay computes its own rational intervals." + } +} diff --git a/research/p104-receiver-ingress-repair/SOURCES.json b/research/p104-receiver-ingress-repair/SOURCES.json new file mode 100644 index 0000000000..14b64b1f86 --- /dev/null +++ b/research/p104-receiver-ingress-repair/SOURCES.json @@ -0,0 +1,62 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ], + "cited_research": [ + { + "pr": 7776, + "head": "4f7c67ae387cc91580f469aeda4d508b372b9ec1", + "author": "aliromman", + "title": "Conditional κ ≥ 0.00385896148992 (+0.00000827274837 over #7774)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7776" + }, + { + "pr": 7786, + "head": "89a67c404226d51028e135de2b9169e9020d57af", + "author": "Clear1nsight", + "title": "Conditional κ ≥ 0.00387944011068 from four additional rational returns", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7786" + }, + { + "pr": 7795, + "head": "0893abefcc894991b67b2315f7e85e0dc4d58c5e", + "author": "Clear1nsight", + "title": "Bound six paid-slot repairs and 73 linked chart cones on #7786", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7795" + }, + { + "pr": 7804, + "head": "51e63c4ee7b3bdb05601b453cc1d6838e43bd001", + "author": "Clear1nsight", + "title": "Exclude 126 fixed-port two-ingress repairs at P104 adjoint chart 3", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7804" + }, + { + "pr": 7807, + "head": "864d15105ceb2f7a5cdbc6bedc72a9bc273d5e8e", + "author": "apoursh", + "title": "Prove the exact all-chart direct replacement cost of P104 paid slot 88", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7807" + }, + { + "pr": 7808, + "head": "c44a0313cb1aee8b94803691529d1c109779f2f2", + "author": "apoursh", + "title": "Classify all ten minimum-grade cooperative repairs of P104 receiver 127", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7808" + } + ] +} diff --git a/research/p104-receiver-ingress-repair/TASK.json b/research/p104-receiver-ingress-repair/TASK.json new file mode 100644 index 0000000000..282068929e --- /dev/null +++ b/research/p104-receiver-ingress-repair/TASK.json @@ -0,0 +1,127 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selection_nonce": "548f22031d970c15161004e382f4aedb", + "scope_key": "de10dd0ec51d85515c05", + "scope_status": "refined", + "actual_scope": "Determine how many ingress messages from chart 3 are required to replace the old two-hop chart-127 route by a direct send from chart 278 when its other local messages and receiver terminals may be recoded.", + "scope_change_reason": "The arbitrary cooperative routing classification in #7808 freezes every surviving paid observation. This tests simultaneous changes to all ten chart-278 ingresses and its nine surviving egresses, with only the exterior terminal operators protected.", + "bottleneck_link": "Identifies a sharp capacity obstruction that survives changing the local stocks and prices a constructive repair on the exact rational word.", + "stop_rule": "Verify a forced exterior rank at the original ingress budget, separate the missing receiver observation by an exact input, and exhibit a chronological matching construction with one additional ingress.", + "outcome": "completed", + "evidence": "The package README, proof and registered verification commands describe the exact scope and controls.", + "author": "apoursh", + "ai_assistance": "Substantial OpenAI Codex assistance with mathematical derivation, verification and review.", + "open_questions": [ + { + "question": "Can an exterior route or a different stock owner pay for the extra required message into chart 278?", + "why_it_matters": "The seven-ingress construction is sufficient but increases the enrolled paid tariff.", + "first_step": "Identify a protected reader whose route can change and carry an independent observation to the chart at lower net cost.", + "blocked_by": "All other terminal operators and productive entries must be restored in the complete invoice." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19756126", + "overlap": "Read #1163, recent #1166 handoffs, active #7111 work and recent PRs; checked relevant all-state PR searches. The local overlap cache and sparse inventory have limited coverage. Checked #7804 and the #7786 continuations for a distinct boundary.", + "upstream_refresh": { + "date_utc": "2026-11-19", + "canonical_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selected_orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected": "The selected result is #7000. The revision-8 catalogue refers to the earlier #5599.", + "before_submission": "Fetched canonical main again and checked the current work against the live PR queue." + } +} diff --git a/research/p104-receiver-ingress-repair/VERIFY.json b/research/p104-receiver-ingress-repair/VERIFY.json new file mode 100644 index 0000000000..822b890dbb --- /dev/null +++ b/research/p104-receiver-ingress-repair/VERIFY.json @@ -0,0 +1,117 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_exterior.py" + ], + "timeout_seconds": 120, + "checks": "Exterior response on nine messages, six independent protected demands and the full local stock" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_exterior.py" + ], + "timeout_seconds": 120, + "checks": "Exterior response on nine messages, six independent protected demands and the full local stock under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_input.py" + ], + "timeout_seconds": 120, + "checks": "Public sparse separator and all permitted stock observations on the original word" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_input.py" + ], + "timeout_seconds": 120, + "checks": "Public sparse separator and all permitted stock observations on the original word under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_repair.py" + ], + "timeout_seconds": 120, + "checks": "Chronological seven-message construction, full terminal comparison, and signed tariff" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_repair.py" + ], + "timeout_seconds": 120, + "checks": "Chronological seven-message construction, full terminal comparison, and signed tariff under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_separator.py" + ], + "timeout_seconds": 120, + "checks": "Independent backward reconstruction of the normalized nine-coordinate separator" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_separator.py" + ], + "timeout_seconds": 120, + "checks": "Independent backward reconstruction of the normalized nine-coordinate separator under optimized Python" + } + ] +} diff --git a/research/p104-receiver-ingress-repair/check_exterior.py b/research/p104-receiver-ingress-repair/check_exterior.py new file mode 100644 index 0000000000..16cd3a5065 --- /dev/null +++ b/research/p104-receiver-ingress-repair/check_exterior.py @@ -0,0 +1,108 @@ +"""Pull the exterior pulse equations back to the six core inputs at chart 278.""" +from fractions import Fraction +from functools import cache +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from word import read_word, check_causality, require + + +def add(row, source, scalar): + for i, a in source.items(): + q = row.get(i, 0) + scalar*a + if q: + row[i] = q + else: + row.pop(i, None) + + +def rank(rows): + pivots = {} + for source in rows: + row = dict(source) + while row: + col = min(row) + if col not in pivots: + pivots[col] = {k: Fraction(a)/row[col] for k, a in row.items()} + break + add(row, pivots[col], -row[col]) + return len(pivots) + + +def main(): + w, forms, moves, terminals = read_word() + check_causality(w, forms, moves, terminals) + schedule = w['schedule'] + ins = [k for k in schedule if k in moves and moves[k][1] == 278] + outs = [k for k in schedule if k in moves and moves[k][0] == 278 and k != 95914] + core = [k for k in ins if moves[k][0] == 3] + require(core == [94953, 95493, 95884, 95982, 96109, 100334] + and len(ins) == 10 and len(outs) == 9, 'full chart port counts') + require(278 not in w['initial'] and 278 not in terminals.values(), 'chart 278 local boundary') + require(127 not in w['initial'] and all(a != 127 for a,b in moves.values()), + 'receiver has no primary stock or paid outputs') + require({a for a,b in moves.values() if b == 278} == {3, 11, 58}, 'three original senders') + require(all(b != 3 for a,b in moves.values()), 'core sender has only public stock') + edges = {k for k,(a,b) in moves.items() if b in (11, 58)} + require(max(schedule.index(k) for k in edges) < min(schedule.index(k) for k in outs), + 'all edge-sender inputs arrive before first surviving outgoing move') + require(max(schedule.index(k) for k in ins) < min(schedule.index(k) for k in outs), + 'all original ingress precedes the surviving egress') + require(all(set(forms[k]) <= set(ins) for k in outs), 'native egress has only chart ingress') + require({k for k,row in forms.items() if 95914 in row} == {88} and + {k for k,row in forms.items() if 88 in row} == {155442,155490}, + 'deleted route has no exterior readers') + + @cache + def expand(k): + if k < 0: + return {~k: 1} + row = {} + for source, q in forms[k].items(): + add(row, expand(source), q) + return row + + edge_stock = sorted(edges) + [~j for j,c in enumerate(w['initial']) if c in (11,58)] + require(len(edge_stock) == 12 and rank([expand(k) for k in edge_stock + core]) == 18, + 'edge stock and old core messages are jointly independent') + require(set().union(*(expand(k).keys() for k in core)) <= + {j for j,c in enumerate(w['initial']) if c == 3}, 'public core coordinates') + + # Give the nine outgoing values independent tags. Outside chart 278 all + # surviving operations are fixed. A tag at a paid egress overwrites its + # original definition, so each column is the response to a change there. + response = {} + for k in schedule: + row = {} + if k in outs: + row[k] = 1 + elif k not in (88,95914): + for j, q in forms[k].items(): + add(row, response.get(j, {}), q) + response[k] = row + exterior = [k for k,c in terminals.items() if c != 127] + require(len(exterior) == 387 and rank([response[k] for k in exterior]) == 8, + 'rank of all exterior observations on nine egresses') + require(all(response[k].get(95887,0) == response[k].get(100336,0) for k in exterior), + 'unique unobserved opposite egress shifts') + test = (154880,154881,154887,154895,154950,154959) + expected = [ + [0,-1,0,0,0,0], [0,-1,1,0,1,0], [Fraction(-1,4),0,0,0,0,0], + [0,0,-1,0,-1,-1], [0,-1,Fraction(-1,4),0,0,0], [Fraction(-1,4),1,0,1,0,0], + ] + projected = [] + for t, values in zip(test, expected, strict=True): + require(t in exterior, 'all six witnesses are exterior') + row = {} + for k, coefficient in response[t].items(): + add(row, forms[k], coefficient) + require([row.get(c,0) for c in core] == values, 'wrong projected row') + projected.append({i: row[i] for i in core if i in row}) + require(rank(projected) == 6, 'six independent requirements modulo the two edge senders') + print('PASS 387 exterior outputs, full pulse rank 8/9, unique opposite-shift kernel.') + print('PASS six explicit exterior terminals force rank six modulo the 12-dimensional edge stock.') + + +if __name__ == '__main__': + main() diff --git a/research/p104-receiver-ingress-repair/check_input.py b/research/p104-receiver-ingress-repair/check_input.py new file mode 100644 index 0000000000..60b28e7e20 --- /dev/null +++ b/research/p104-receiver-ingress-repair/check_input.py @@ -0,0 +1,40 @@ +"""Evaluate a nine-coordinate separator on the literal original paid word.""" +from fractions import Fraction +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from word import read_word, require + + +POINT = {770: -2, 663: -2, 825: -1, 780: -1, 1288: -Fraction(1,845660160), + 1055: Fraction(218,1395), 1225: Fraction(17,2), 1238: Fraction(1888,333), + 1239: Fraction(64,27)} + + +def evaluate(w, forms, point): + values = {~j: point.get(j,0) for j in range(len(w['initial']))} + for k in w['schedule']: + values[k] = sum(q*values[j] for j,q in forms[k].items()) + return values + + +def main(): + w, forms, moves, terminals = read_word() + values = evaluate(w, forms, POINT) + local = {~j for j,c in enumerate(w['initial']) if c in (11,58)} + local.update(k for k,(a,b) in moves.items() if b in (11,58) or (a,b) == (3,278)) + receiver = {k for k,(a,b) in moves.items() if b == 127 and k != 88} + outgoing = {k for k,(a,b) in moves.items() if a == 278 and k != 95914} + require((len(local),len(receiver),len(outgoing)) == (18,901,9), 'full local and receiving stocks') + require(not any(values[k] for k in local | receiver | outgoing), 'annihilator') + require(values[155442] == 1 and terminals[155442] == 127, 'required output separates zero') + require(evaluate(w, forms, {})[155442] == 0, 'zero control') + mutated = evaluate(w, forms, {j:q for j,q in POINT.items() if j != 1288}) + require(any(mutated[k] for k in local | receiver), 'omitting the large-denominator atom') + print('PASS nine-coordinate input kills all 18 possible stock directions,') + print('all 901 old receiver arrivals and all nine old egresses. Required output is one.') + + +if __name__ == '__main__': + main() diff --git a/research/p104-receiver-ingress-repair/check_repair.py b/research/p104-receiver-ingress-repair/check_repair.py new file mode 100644 index 0000000000..fa43bfad02 --- /dev/null +++ b/research/p104-receiver-ingress-repair/check_repair.py @@ -0,0 +1,106 @@ +"""Build the seventh-ingress realization and check its exact operators and grade bill.""" +from fractions import Fraction as F +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from word import check_causality, read_word, require + + +def add(row, other, factor): + for k, v in other.items(): + x = row.get(k, 0) + v*factor + if x: + row[k] = x + else: + row.pop(k, None) + + +def pullback(schedule, forms, key): + row = {key: 1} + for k in reversed(schedule): + coeff = row.pop(k, 0) + if coeff: + add(row, forms[k], coeff) + require(all(k < 0 for k in row), 'adjoint expands to public coordinates') + return row + + +def main(): + w, old, routes, terminals = read_word() + schedule = w['schedule'] + ing, direct, late = 95914, 88, 94217 + y1, y2 = 155442,155490 + target = {~674: 1, ~780: -1} + require(pullback(schedule,old,y1) == target, 'original difference terminal') + require(old[late] == {~674:1, 90590:-1, 90592:-1}, 'public edge input plus core offset') + require(all(routes[k] == (3,11) for k in (90590,90592)) and w['initial'][780] == 3, + 'new core packet is causal at its sender') + + packet = pullback(schedule,old,late) + add(packet, target, -1) + require(len(packet) == 299 and all(w['initial'][~j] == 3 for j in packet), + 'core-only seventh arrival') + require(max(q.numerator.bit_length() for q in packet.values()) == 30 and + max(q.denominator.bit_length() for q in packet.values()) == 7, + 'literal coefficient sizes for handoff') + + new = old.copy() + new_routes = routes | {ing:(3,278), direct:(278,127)} + new[ing] = packet + new[direct] = {late:1, ing:-1} + new[y1] = {direct:1} + new[y2] = old[y2].copy() + add(new[y2], old[y1], -1) + add(new[y2], new[y1], 1) + check_causality(w,new,new_routes,terminals) + affected = {ing,direct,y1,y2} + for k in schedule: + if affected.intersection(old[k]) or affected.intersection(new[k]): + affected.add(k) + require(affected == {ing,direct,y1,y2}, 'complete joint dependency cone') + require(pullback(schedule,new,direct) == target and + all(pullback(schedule,new,k) == pullback(schedule,old,k) for k in (y1,y2)), + 'two restored operators on all 1,289 independent inputs') + broken = new | {direct: {late:1, ing:1}} + require(pullback(schedule,broken,y1) != target, 'sign error changes a terminal') + require(sum(pair == (3,278) for pair in new_routes.values()) == 7, 'seven core ingresses') + require([len(w['frames'][j]) for j in (3,278,288,127)] == [0,2,4,9], 'old and new grades') + print('PASS full causal reconstruction, all 1,289 terminal rows, seventh core packet has 299 terms.') + check_tariff() + + +# Rational log and exponential tail bounds adapted from the #7808 price checker. +def price(d): + def logarithm(x): + z = (x-1)/(x+1) + u, total = z, F(0) + for j in range(45): + total += 2*u/(2*j+1) + u *= z*z + return total,total + 2*u/(91*(1-z*z)) + + def exponential(x): + require(0 <= x <= F(1,50), 'alternating exponential') + u = total = F(1) + for j in range(1,14): + u *= -x/j + total += u + return total,total-u*x/14 + + k = d.bit_length()-1 + base, remainder = logarithm(F(2)),logarithm(F(d,1<