diff --git a/research/p104-private-route-recoding/PROOF.md b/research/p104-private-route-recoding/PROOF.md new file mode 100644 index 0000000000..ff53fd29ce --- /dev/null +++ b/research/p104-private-route-recoding/PROOF.md @@ -0,0 +1,54 @@ +# Routing two independent demands through a shared private route + +## Released word and model + +Work over the rationals with the literal #7786 word on 1,289 independent public coordinates and 1,103 original chart labels. Its chronological schedule contains 5,709 paid sends and 1,289 terminal forms. Start from either sum merger of #7818. At rank-two chart 278 let $A=95887$, $B=100336$, $C=95914$, and let $E=88$ denote the private relay's outgoing send. Retire either $A$ or $B$, and put the sum of their original payloads (ingress 100334) into the surviving slot. **Release $C$ and $E$ as well**, deleting the three slots and their reader references. This exposes the complete private route $278\to288\to127$ and leaves 5,706 native paid functions. All exterior terminal operators are preserved by the merger, and only $E$ read $C$. Receiver 127 is the sole consumer of $E$. [Pinned source and notices](SOURCE-PINS.json) · [Pulse calculation on the original word](https://github.com/apoursh/integer-mult-bounds/blob/bf3c8a8fde5a111954c76518818431f3999dc276/research/p104-exterior-route-recoding/PROOF.md) + +Every original chart receives its local public atoms and all its surviving post-release native deposits as fixed functions, even if they arrive late in the actual word. A replacement may buy any finite fixed schedule of rational-linear scalar messages joining comparable original binary spans. A send costs $p(g)=g^{1-0.00387981257853}$ for absolute rank difference $g$, with free sharing between equal spans. Intermediate messages may mix arbitrary copies, frozen local observations and earlier replacements; receiver readout may be any deterministic function. The lower bound uses this enlarged observation model. The matching construction restores chronological access and all native terminal operators. Native functions outside the merger and the two released private slots stay frozen. The productive ledger and local arithmetic cost are outside the paid-route price. [Reader and merger](model.py) + +Let $L\ge 1$ copies have independent public inputs. The choice of retired exterior slot may differ per copy. We show that the exact replacement tariff across them is +$$ +L\,[p(7)+p(2)+p(5)]. +$$ +This permits jointly recoding both old private hops, changing their endpoints, and buying additional branches or feedback. The lower bound needs the finite-dimensional scalar communication assumption. An unrestricted nonlinear scalar encoder on rational inputs could encode multiple independent rationals in one rational. + +## Two spatial tests + +Restrict the inputs of one copy to the coordinate plane $x_{674}=a$, $x_{722}=b$, zero elsewhere. In the three-slot release each basis vector produces only one nonzero surviving paid arrival: 94217 on the first vector and 94218 on the second. Both arrive at 278. Including public atoms, the only charts that can see the plane are 11, 58 and 278, of respective ranks 1, 1 and 2. The two demanded operators 155442 and 155490 at rank-nine receiver 127 restrict to $a,b$. Run the same test independently on each copy. The first cut argument must transmit $2L$ scalar dimensions. + +For a second restriction scale $(x_{674},x_{722},x_{1288})=(1,1,-1/845660160)$ independently in each copy. Its live set $D$ for each merger contains 26 chart labels after closing under equal spans, and excludes the receiver. Within the closed span interval from 278 to 127, $D$ consists exactly of rank-four chart 288. Both required receiver outputs equal the scale. The two mergers have the same live set on this test: both retired payloads and their sum vanish there, as the replay verifies. This witness is from Clear1nsight's #7795 through #7808. Both tests here are replayed after all three removals on the complete original word. [Public stock test](check_witnesses.py) · [Earlier use on a single-route cut](https://github.com/apoursh/integer-mult-bounds/blob/c44a0313cb1aee8b94803691529d1c109779f2f2/research/p104-receiver-relay/PROOF.md) + +## A simultaneous charge for two kinds of information + +Contract the free equal-span classes. Represent each paid message by a unit-capacity directed edge, including parallel edges, and attach a super-source to 11, 58 and 278 with arbitrarily large capacity. On the plane the destination side of any separating cut has zero frozen observation. Under the fixed linear message rules, every observation on the destination side is a linear function of that restriction. Induction over time bounds its row space by the span of the incoming cut packets. Reverse messages and internal operations cannot enlarge this span. If its rank is below $2L$, two plane inputs give identical observations and different required outputs, which defeats even a nonlinear final readout. Exact deterministic recovery therefore forces cut capacity at least $2L$. By integral max-flow/min-cut the static graph contains $2L$ edge-disjoint directed paths from the three source charts to receiver 127. Discard cycles. Ignoring the times only enlarges this set of paths. Independently the second restriction forces at least $L$ messages to exit $D$: outside it the frozen observations vanish and the receiver recovers all $L$ scales. + +Define $\delta=p(2)+p(5)-p(7)>0$. On a source path $P$, write $g$ for total grade and $n_D$ for the number of exits from $D$. We claim +$$ +\operatorname{cost}(P)\ \ge\ p(7)+n_D\delta. +$$ + +* Since rank starts at most two and ends at nine, $g\ge7$. If $g=7$, the path starts at 278 and strictly ascends within the original span interval. When the path avoids 288 it has no exit from $D$, and monotone concavity bounds its price below by $p(7)$. If it passes through 288 it exits exactly once. Its portions before and after 288 have grades two and five. Concavity bounds their combined price below by $p(2)+p(5)$. +* If $g\ge8$, put $c=p(9)/9$. Every positive edge of grade $d\le9$ costs at least $cd$. There are at most $g$ edges, hence $n_D\le g$. The directed price check gives $8(c-\delta)>p(7)$. Thus this path's price exceeds $p(7)+n_D\delta$. +* Each edge unused by the extracted paths costs at least $p(1)>\delta$, and can pay for its own exit from $D$. + +Adding over the paths and the unused edges gives $2Lp(7)+L\delta$ as required. Strict concavity and the strict price inequalities classify equality. Each path avoiding 288 must be one direct grade-seven jump. Every path through 288 must consist of exactly the two original private legs. There must be exactly $L$ such paths and every paid edge must lie on one extracted path. The unique optimal positive-edge multiset up to equal-span sharing consists of $L$ copies of each of $278\to127$, $278\to288$ and $288\to127$. This classifies topologies and leaves freedom in the codewords, basis and times. [Directed enclosures](check_prices.py) + +## Attainment and private payload recoding + +Let $h$ be minus the original $A$ payload if $A$ was retired, or the original $B$ payload if $B$ was retired. Relative to the original outgoing functions at 278 the merger shifts $A$ by $h$ and $B$ by $-h$, interpreting a retired value as zero. With the old private path restored unchanged, the resulting shifts are $h/2$ and $-h/2$ at the two receiver outputs in the order 155442, 155490. These are the only changed terminal functions. Send $h$ on $278\to127$ and subtract the shifts at the two readers. All three replacement sends use local stock in time. + +For *every* rational $t$, the private ingress may instead carry $v_C+t h$. Keep the original side information $s=v_E-v_C$ at 288. Its outgoing packet then carries $v_E+t h$. Subtract $(t+1/2)h$ and $(t-1/2)h$ at the respective terminal readers. At $t=\pm1/2$ one affected reader needs no correction from the direct edge. The two independent plane coordinates still force the same bill. Across independent copies choose any rational $L\times L$ matrix $T$ in place of the scalar $t$, vectorizing $h,v_C,v_E$. Recover with corrections $Th\pm h/2$ after delivery of the $L$ direct packets. The word proof uses only the scalar template repeated on separate native calls; joint mixing assumes the model's stated access to all copies at a common chart. Headroom in a particular correlated caller would require another argument. + +This construction extends to **any** ordered pair of strictly increasing chart chains from 278 to 127 with 288 on the designated private chain. At the retired exterior position forward $h$ along the other chain. At the old $C$ position forward $v_C+t h$ along the private chain to 288. At the old $E$ position add the side form and forward to 127. These insertion positions have the same available local inputs as in the original word. Fresh slots can relay consecutively since intermediate payloads are identical copies. Both affected terminals are later, and all earlier native reads retain their correct values. The verifier builds eight chronological programs spanning both mergers, $t=0,\pm1/2,11/7$, representative maximal detours and the direct optimum. It checks every terminal on common formal unchanged wires and independently pulls the two sensitive terminal rows back to all public coordinates. [Operator construction and negative controls](check_reconstruction.py) + +## Counting all minimum-grade networks + +For one copy total grade is at least fourteen by the two disjoint paths. At fourteen both paths increase from 278 to 127, and use every positive edge. The side test forces at least one path through 288. Conversely every such pair of paths admits the construction above. The 56-chart interval gives 933 ascending chains; ten of these pass through 288. Taking unions with multiplicities and sorting the edges removes duplicates due to path exchanges at intermediate vertices. This gives 9,275 feasible multigraphs with 43 grade multisets. The classification counts a multigraph once if some causal ordering realizes it. A prescribed arbitrary ordering may be infeasible. + +| Paid messages | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | +|---|---:|---:|---:|---:|---:|---:|---:|---:|---:| +| Feasible multisets | 1 | 59 | 498 | 1,668 | 2,741 | 2,510 | 1,346 | 404 | 48 | + +The unique runner-up routes the private packet via 561 before 288, with grades $(1,1,5,7)$. All other feasible grade-fourteen profiles are strictly dearer by directed rational comparison. Networks of grade at least fifteen cost at least $15c>2p(1)+p(5)+p(7)$, so the runner-up is global. Its cost exceeds the optimum by $48[2p(1)-p(2)]=0.257824154185337662623932\ldots$ across 48 separately instantiated calls. [Exact enumeration](check_topologies.py) + +The original 5,709 paid sends have grade histogram $(3842,792,487,230,314,40,3,1)$ in grades one through eight. Credit the retired private grades two and five as well as the retired exterior grade $d$. After the optimal restoration the only net change is moving one count from $d$ to seven. For $d=1$ the 48-call increase is $285.472830172972358520270568\ldots$; for $d=5$ it is $94.966797106425725799489376\ldots$. Each printed lower endpoint has a strict upper endpoint $10^{-24}$ above it. This compares separately charged calls at the enrolled #7795 tariff. The joint-coding theorem assumes independent copies; the numerical invoice for a repeated literal implementation uses its actual number of calls. diff --git a/research/p104-private-route-recoding/README.md b/research/p104-private-route-recoding/README.md new file mode 100644 index 0000000000..3e04b3515e --- /dev/null +++ b/research/p104-private-route-recoding/README.md @@ -0,0 +1,34 @@ +# Joint rerouting after a P104 exterior port retirement + +Retire either exterior port in the chart-278 sum merger and release **both** transfers of the original private route through chart 288. The exact price of any replacement with rational-linear scalar messages across $L$ independent copies is +$$ +L[p(7)+p(2)+p(5)]. +$$ +The unique cheapest topology buys $L$ direct grade-seven sends from 278 to 127 and $L$ copies of the grade-two and grade-five legs through 288. Each new message can use all local native stock and earlier new messages, from any copy. The receiver may use arbitrary deterministic readout. The result covers all finite fixed routes on the 1,103 original chart labels with equal-span sharing, while the other native paid operators remain fixed. [Model and proof](PROOF.md) + +| Retired exterior slot | Original grade | Best net change in the 48-call paid invoice | +|---|---:|---:| +| 95887 | 1 | +285.472830172972… | +| 100336 | 5 | +94.966797106425… | + +Two independent public inputs require two scalar dimensions per copy at receiver 127. A separate three-coordinate input forces a pickup of independent information outside the source. The two cut constraints together establish the exact tariff even when replacement routes branch, use feedback or mix different calls. For a single copy exactly **9,275 distinct positive-edge multisets** attain the minimum total grade of fourteen, and only one attains the best tariff. Every one of these topologies admits a chronological rational-linear reconstruction. [Input witnesses](check_witnesses.py) · [Topology census](check_topologies.py) · [Price inequalities](check_prices.py) + +The prior result in #7818 fixed both private transfers while paying for additional repairs. The present joint optimum releases and credits those transfers. The sum merger's best net charged price still increases. All slopes $t$ in the proposed private-payload edit $v_C+t h$ attain the same least supplemental tariff, with one readout correction vanishing at $t=\pm1/2$. This local result leaves the selected conditional exponent at 0.00363005817. [Previous merger](https://github.com/apoursh/integer-mult-bounds/blob/bf3c8a8fde5a111954c76518818431f3999dc276/research/p104-exterior-route-recoding/PROOF.md) · [Public coordination](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19756932) + +## Reproduce + +Run from the repository root with CPython 3.12 and its standard library. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-private-route-recoding +``` + +The four checks replay the two witness spaces, construct eight complete causal words, compare all 1,289 terminal operators, count minimum-grade networks and enclose all tariff gaps by rational arithmetic. An independent backward expansion checks the two affected outputs on all public coefficients. The bundled word reader checks compressed and uncompressed digests. [Operator construction](check_reconstruction.py) · [Verification manifest](VERIFY.json) + +## Open next questions + +Which modification to a surviving chart-278 ingress or an exterior reader can make a second independent plane coordinate available beyond rank two without incurring the grade-seven surcharge? A candidate must account for its impact on all 387 exterior outputs. Replacing a third native route can also change the set of charts that observe the side input, giving a concrete second cut to test before building a whole word. + +## Attribution + +Clear1nsight supplied the #7786 word, the #7795 receiver-cut evidence and the three-coordinate input. Ali Romman supplied the underlying #7776 P104 caller. The earlier #7808 and #7818 studies by apoursh supplied scalar route and merger calculations. This contribution's two-dimensional restriction, joint flow and side-information lower bound, complete two-chain census and reconstructions were prepared by apoursh with substantial OpenAI Codex assistance under Apache-2.0. [Source pins](SOURCE-PINS.json) · [Source notice](retained/PR7786-NOTICE) · [Paid-port notice](retained/PR7795-NOTICE) · [License](retained/LICENSE) diff --git a/research/p104-private-route-recoding/SOURCE-PINS.json b/research/p104-private-route-recoding/SOURCE-PINS.json new file mode 100644 index 0000000000..79d2edad4d --- /dev/null +++ b/research/p104-private-route-recoding/SOURCE-PINS.json @@ -0,0 +1,102 @@ +{ + "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." + }, + "methods": [ + { + "source": 7814, + "head": "808476a49004abe3fcd24b5a7dfd012f021afb05", + "original_path": "research/p104-receiver-ingress-repair/check_exterior.py", + "git_blob": "16cd3a50659f1921c3f276ebe7e4e74d33e1e4f6", + "use": "Earlier exterior-only opposite egress shifts. Rational pulse propagation adapted." + }, + { + "source": 7814, + "head": "808476a49004abe3fcd24b5a7dfd012f021afb05", + "original_path": "research/p104-receiver-ingress-repair/check_repair.py", + "git_blob": "fa43bfad028f5463e91366405ae0f20afc0eb849", + "use": "Independent public-coordinate adjoint and rational tariff enclosure adapted." + }, + { + "source": 7808, + "head": "c44a0313cb1aee8b94803691529d1c109779f2f2", + "original_path": "research/p104-receiver-relay/check_prices.py", + "git_blob": "ce23d72d93f48e87dd7a74aee2245a70ac32ca2f", + "use": "Source of log and alternating exponential enclosure." + }, + { + "source": 7818, + "head": "bf3c8a8fde5a111954c76518818431f3999dc276", + "original_path": "research/p104-exterior-route-recoding/check_mergers.py", + "git_blob": "b7ab16ec830a7f176636e21e825094728b70d0ed", + "use": "Two exterior sum mergers and full-profile operator checking. Adapted the merger and adjoint algorithms." + }, + { + "source": 7818, + "head": "bf3c8a8fde5a111954c76518818431f3999dc276", + "original_path": "research/p104-exterior-route-recoding/check_cuts.py", + "git_blob": "36ac0900a598525d541c9eacaa7c438e5dfb556d", + "use": "Rational price enclosures and interval enumeration, reused for the two-route cut comparison." + }, + { + "source": 7808, + "head": "c44a0313cb1aee8b94803691529d1c109779f2f2", + "original_path": "research/p104-receiver-relay/check_paths.py", + "git_blob": "bbc53f3aea8c08dae5fea3900fac1a34fe114660", + "use": "Source-bound three-coordinate test and single-path geometry. This package replays the test after three releases." + } + ] +} diff --git a/research/p104-private-route-recoding/SOURCES.json b/research/p104-private-route-recoding/SOURCES.json new file mode 100644 index 0000000000..53b86f67d3 --- /dev/null +++ b/research/p104-private-route-recoding/SOURCES.json @@ -0,0 +1,76 @@ +{ + "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" + }, + { + "pr": 7814, + "head": "808476a49004abe3fcd24b5a7dfd012f021afb05", + "author": "apoursh", + "title": "Prove the seven-ingress threshold for direct P104 chart-278 repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7814" + }, + { + "pr": 7818, + "head": "bf3c8a8fde5a111954c76518818431f3999dc276", + "author": "apoursh", + "title": "Price both P104 exterior port retirements under joint coding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7818" + } + ] +} diff --git a/research/p104-private-route-recoding/TASK.json b/research/p104-private-route-recoding/TASK.json new file mode 100644 index 0000000000..51092d0107 --- /dev/null +++ b/research/p104-private-route-recoding/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": "eec38b3d0ceda5040a5eb29e919b7825", + "scope_key": "de10dd0ec51d85515c05", + "scope_status": "refined", + "actual_scope": "Determine the minimum tariff after jointly releasing the private chart-288 route and an exterior port at chart 278, allowing finite scalar linear codes across independent copies.", + "scope_change_reason": "The exterior port result funded both private transfers in advance. Here both private legs are released and credited together with the exterior port and a new network can use any comparable chart pair.", + "bottleneck_link": "Determines whether the remaining private-route freedom can finance the missing exterior scalar, on the exact rational supplier and enrolled 48-call tariff.", + "stop_rule": "Prove a matching bound across independent calls, enumerate all least-total-grade single-call topologies, compare the two best full paid profiles and reconstruct exact terminal operators.", + "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 changing an additional surviving ingress or exterior reader pay for the second required dimension?", + "why_it_matters": "The jointly recoded private and exterior routes alone still incur a paid surcharge.", + "first_step": "Identify a native receiver of the two-coordinate test above rank two, then replay its exterior obligations and the full new invoice.", + "blocked_by": "The lower bound freezes the other native payloads." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19756932", + "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. Compared recent #7815–#7818, the #1166 handoffs, the current #7111 research thread and all-state PR searches to the claimed scope.", + "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-private-route-recoding/VERIFY.json b/research/p104-private-route-recoding/VERIFY.json new file mode 100644 index 0000000000..64f790680e --- /dev/null +++ b/research/p104-private-route-recoding/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_witnesses.py" + ], + "timeout_seconds": 120, + "checks": "Original and released local stocks and exact terminal responses on the two-dimensional and side-information test inputs" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_witnesses.py" + ], + "timeout_seconds": 120, + "checks": "Original and released local stocks and exact terminal responses on the two-dimensional and side-information test inputs under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_reconstruction.py" + ], + "timeout_seconds": 120, + "checks": "Eight chronological words, all 1,289 terminals, literal pullbacks and grade profiles" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_reconstruction.py" + ], + "timeout_seconds": 120, + "checks": "Eight chronological words, all 1,289 terminals, literal pullbacks and grade profiles under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_topologies.py" + ], + "timeout_seconds": 120, + "checks": "Complete minimum-grade interval, path unions by positive-edge multiplicity, price ranking" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_topologies.py" + ], + "timeout_seconds": 120, + "checks": "Complete minimum-grade interval, path unions by positive-edge multiplicity, price ranking under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/check_prices.py" + ], + "timeout_seconds": 120, + "checks": "Directed rational enclosures for the flow, side-information charges and 48-call signed differences" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/check_prices.py" + ], + "timeout_seconds": 120, + "checks": "Directed rational enclosures for the flow, side-information charges and 48-call signed differences under optimized Python" + } + ] +} diff --git a/research/p104-private-route-recoding/check_prices.py b/research/p104-private-route-recoding/check_prices.py new file mode 100644 index 0000000000..83a3a8d6f6 --- /dev/null +++ b/research/p104-private-route-recoding/check_prices.py @@ -0,0 +1,61 @@ +"""Directed price bounds for the release of the two private slots and one exterior slot.""" +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 require + + +# Rigorous price intervals adapted from the rational checks in #7808 and #7814. +@cache +def price(d): + if d == 0: + return Fraction(0), Fraction(0) + + def log_bounds(x): + z = (x - 1) / (x + 1) + u, total = z, Fraction(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 exp_neg_bounds(x): + require(0 <= x < Fraction(1, 50), 'alternating exponential terms decrease') + u = total = Fraction(1) + for j in range(1, 14): + u *= -x / j + total += u + return total, total - u * x / 14 + + k = d.bit_length() - 1 + base, rest = log_bounds(Fraction(2)), log_bounds(Fraction(d, 1 << k)) + low, high = (Fraction('0.00387981257853') * (k*base[i] + rest[i]) for i in (0, 1)) + return d * exp_neg_bounds(high)[0], d * exp_neg_bounds(low)[1] + + +def main(): + p = [price(i) for i in range(10)] + # delta prices the compulsory side information after extraction of two + # independent lower-source paths. For grade >=8 reserve delta per edge. + dl,dh = p[2][0]+p[5][0]-p[7][1],p[2][1]+p[5][1]-p[7][0] + c = p[9][0]/9 + require(0 < dl <= dh < p[1][0], 'strict splitting surcharge') + require(all(p[g][0] >= g*c for g in range(1,10)), 'all directed grade prices') + require(8*(c-dh) > p[7][1], 'one detour pays for each exit') + require(15*c > 2*p[1][1]+p[5][1]+p[7][1], 'outside minimal grade exceeds runner-up') + for d, value in ((1,'285.472830172972358520270568'),(5,'94.966797106425725799489376')): + base = Fraction(value) + require(base < 48*(p[7][0]-p[d][1]) <= 48*(p[7][1]-p[d][0]) < + base + Fraction(1,10**24), 'net funded surcharge') + runner = Fraction('0.257824154185337662623932') + require(runner < 48*(2*p[1][0]-p[2][1]) <= 48*(2*p[1][1]-p[2][0]) < + runner + Fraction(1,10**24), 'runner-up') + print('PASS protected side-exit charge, nonminimal path and network gaps, ' + '48-call tariff differences in rational intervals of width 10^-24.') + + +if __name__ == '__main__': + main() diff --git a/research/p104-private-route-recoding/check_reconstruction.py b/research/p104-private-route-recoding/check_reconstruction.py new file mode 100644 index 0000000000..f7b0b0927d --- /dev/null +++ b/research/p104-private-route-recoding/check_reconstruction.py @@ -0,0 +1,93 @@ +"""Construct general two-chain repairs and verify each terminal as a rational form.""" +from collections import Counter +from fractions import Fraction +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from model import A, B, C, E, Y, add, check_causality, construct, read_word, require, span + + +def changed_cone(w, forms, seeds): + sensitive = set(seeds) + for k in w['schedule']: + if sensitive.intersection(forms[k]): + sensitive.add(k) + return sensitive + + +def reduced_rows(w, forms, cone): + # Every unchanged wire outside the union of dependency cones can serve as a + # formal symbol, shared by both programs. Equality here implies operator equality. + symbolic = {~j:{~j:1} for j in range(len(w['initial']))} + for k in w['schedule']: + if k not in cone: + symbolic[k] = {k:1} + continue + row = {} + for j,q in forms[k].items(): + add(row,symbolic[j],q) + symbolic[k] = row + return symbolic + + +def pullback(word, forms, k): + row = {k:1} + for j in reversed(word['schedule']): + q = row.pop(j,0) + if q: + add(row,forms[j],q) + return row + + +def main(): + w, old, native, ends = read_word() + spaces = list(map(span,w['frames'])) + ranks = [len(f) for f in w['frames']] + grade = lambda uv: abs(ranks[uv[0]]-ranks[uv[1]]) + profile = Counter(map(grade,native.values())) + require(profile == dict(enumerate((3842,792,487,230,314,40,3,1),1)), 'original profile') + old_seeds = {A,B,C,E} + affected = changed_cone(w,old,old_seeds) + reference = {k:pullback(w,old,k) for k in Y} + interval = [j for j,s in enumerate(spaces) if spaces[278]<=s<=spaces[127]] + longest = {} + for j in sorted(interval,key=ranks.__getitem__,reverse=True): + longest[j] = (j,) + max((longest[v] for v in interval if spaces[j] < spaces[v]), + key=len,default=()) + direct = (278,127) + private = (278,288,127) + detour = (278,561,288,239,127) + cases = [(direct,private,0),(direct,private,Fraction(-1,2)), + (direct,private,Fraction(1,2)),(longest[278],detour,Fraction(11,7))] + totals = 0 + for dead in (A,B): + for primary,auxiliary,slope in cases: + require(all(spaces[a]