diff --git a/research/p104-receiver-single-send/PROOF.md b/research/p104-receiver-single-send/PROOF.md new file mode 100644 index 0000000000..c987c384a3 --- /dev/null +++ b/research/p104-receiver-single-send/PROOF.md @@ -0,0 +1,61 @@ +# Sharp direct repair cost at receiver 127 + +## Cut and price + +Fix the rational word with SHA-256 c447b6d5ba956fbe40834fe3c1bc69af2f225736f1b97ecd84b57bab9dd283cb on 1,289 independent rational coordinates. Its 5,709 paid transfers and 1,289 terminal rules run on 1,103 fixed charts. The old path is chart $278\to288\to127$ through slots 95914 and 88. Its grades are 2 and 5. Remove both transfers. Keep the original initial stocks, all other paid rows, all other routes, all other chart assignments, and the exterior terminal rules. The 901 surviving deposits at receiver 127 may be combined freely. It has no initial coordinates and no outgoing paid transfer. Slot 95914 had only one reader, slot 88. Slot 88 had only two readers, both receiver terminals. Thus removing the path leaves every surviving paid stock value equal to its original value. [Pinned incumbent](https://github.com/CrocSwap/integer-mult-bounds/tree/89a67c404226d51028e135de2b9169e9020d57af/research/p104-iterated-returns/continuation) · [Predecessor stock contract](https://github.com/CrocSwap/integer-mult-bounds/blob/0893abefcc894991b67b2315f7e85e0dc4d58c5e/research/p104-paid88-stock-cones/STOCK.md) + +Allow any finite number of new direct transmissions from any original chart to receiver 127. The calculation charges only their paid grades and grants all local combining and receiving rules for free. Even the lower-bound relaxation lets each donor see every surviving arrival at its chart over the whole word. In its deterministic adaptive version the receiver may announce its entire transcript freely and choose the next donor from that transcript. Donors receive no other extra input. The upper bound uses a fixed chronological, rational-linear word with two sends at the original slots. No lower bound here requires speculative information about a later operator or the cost of a receiver addition. + +Chart 127 spans the whole nine-dimensional binary frame space. Every original chart of dimension $r$ is contained in that space, so its direct send has grade $9-r$. For any nonnegative nondecreasing discrete concave tariff $p$ on grades $0,\ldots,9$, with $p(0)=0$, the minimum paid replacement cost is + +$$ +p(8)+p(1). +$$ + +The minimum number of direct sends is two. The proof separately establishes impossibility for one send and attains the displayed tariff with two. + +## Four inputs separate all senders + +Give all unlisted coordinates value zero. Evaluate the original local rational rules on the following four inputs. A chart is live if some initial coordinate or surviving deposit in its full-time stock differs from its value on zero input. Each test has zero on all 901 surviving receiver deposits and value one on terminal 155442. Each requires at least one message from a live chart. + +| Test | Nonzero public coordinates | Number of live charts | Property used | +|---|---|---:|---| +| A | $x_{674}=1,\ x_{722}=1$ | 3 | Exactly charts 11, 58 and 278 | +| B | $x_{722}=1,\ x_{780}=-1$ | 293 | Chart 11 is silent and each live chart has grade at least 1 | +| C | $x_{674}=1,\ x_{825}=-1$ | 295 | Chart 58 is silent and each live chart has grade at least 1 | +| D | $x_{674}=1,\ x_{722}=1,\ x_{1288}=-1/845660160$ | 26 | Chart 278 is silent and each live chart has grade at least 5 | + +Test D comes from Clear1nsight's paid-pair obstruction. Tests A–C and the full-chart stock census supply the simultaneous cover here. The forward verifier authenticates the exact compressed source and uncompressed payload, checks each rule against the sender's chronological stock, and propagates the four inputs in exact rational arithmetic. The earlier and later path slots are excluded from the census of surviving arrivals. The verifier also computes all binary frame ranks independently. [Original input D](https://github.com/CrocSwap/integer-mult-bounds/blob/0893abefcc894991b67b2315f7e85e0dc4d58c5e/research/p104-paid88-stock-cones/verify_stock.py) · [Forward verifier](verify_cut.py) + +For any successful fixed strategy the chosen senders must intersect all four live sets. This applies also to the zero-input branch of a deterministic adaptive strategy. If its branch misses a live set, apply the corresponding test. The local input and prior transcript at every queried chart then coincide with their values on zero. The receiver takes the same branch and gets the same answer, although its required terminal changes from zero to one. Arbitrary deterministic encodings and nonlinear receiver postprocessing obey this implication. + +Test A forces a donor from $\{11,58,278\}$. If chart 11 is used, its grade is 8 and B requires another sender at grade at least 1. If chart 58 is used, C does the same. Otherwise chart 278 is used at grade 7 and D requires another sender at grade at least 5. No individual chart passes all tests. Concavity and monotonicity yield $p(8)-p(7)\le p(2)-p(1)\le p(5)-p(1)$. Every allowed direct strategy therefore costs at least $p(8)+p(1)$. This bound includes arbitrary extra grade-zero messages. + +## Chronological construction and exact operator + +At slot 95914 send the initial $x_{674}$ from chart 11 directly to chart 127. At slot 88 send stock atom 101539 from chart 138 directly to chart 127. Its old deposit occurs at time 3396, strictly before the replacement send at time 4067, and its full public-coordinate expansion is $x_{780}$. In the original word it is the half difference of 98143 and 100323. Their expansions are $x_{825}+x_{780}$ and $x_{825}-x_{780}$. The new pair has grades 8 and 1. On predecessor witness D the first donor sees a nonzero value. The two senders together recover the difference required on all public inputs. + +Let $y_1$ and $y_2$ be the original terminals 155442 and 155490, and let $t$ be the old outlet 88. Both rows have coefficient one on $t$. Write $r_i=y_i-t$ for the original rows with that local term removed. Reverse substitution gives $y_1=x_{674}-x_{780}$. The receiver returns +$$ +y'_1=x_{674}-x_{780},\qquad +y'_2=r_2-r_1+x_{674}-x_{780}. +$$ +Every term in this expression is available under the literal schedule. In particular, terminal 155490 is actually installed *before* 155442, so its evaluator uses the two arriving atoms and the old deposit rows directly. The implementation checks availability of every term at both installations. It changes exactly two transfers and two terminal forms. The other 1,287 terminals have no dependency path through a changed node. Independent backward substitution verifies both changed outputs as linear forms in all 1,289 coordinates. Omitting the second receiver recoding or reversing the two source signs is detected. [Constructive verifier](verify_operator.py) + +## Price at the signed target + +The incumbent tariff at $\kappa=0.00387981257853$ is $p(d)=d^{1-\kappa}$. Keeping the productive fields and other paid transfers fixed, the optimal direct replacement increases the 48-call paid cost by +$$ +48\big(8^{1-\kappa}+1-2^{1-\kappa}-5^{1-\kappa}\big) +\ \in\ (94.666202960674077138503464,\ 94.666202960674077138503465). +$$ +The enrolled 48-call invoice already needs more than 0.379442 signed units of saving at this target. Even granting all local recoding for free, the best direct replacement increases the paid bill. This rules out reaching that target by this family of changes alone. Additional modified paid rules, cooperative intermediate exchanges or altered productive credits change the optimization problem. [Frozen incumbent tariff and target shortfall](https://github.com/CrocSwap/integer-mult-bounds/blob/0893abefcc894991b67b2315f7e85e0dc4d58c5e/research/p104-paid88-stock-cones/cones/SOURCE.json) + +For power tariffs $p(d)=d^s$, $00$ multiplies the numerator by at least $5^h$ and the denominator by at most $2^h$. At $s=0$ the continuous limiting ratio is $\log(8/5)/\log 2<1$, and at $s=1$ it is 3. The unique positive equality lies between 0.25985761 and 0.25985762. The direct optimum is dearer above that crossover. The price verifier bounds the logarithm by a rational atanh series and its geometric tail, then encloses the exponential between alternating Taylor sums. All published price endpoints are obtained without floating-point arithmetic. + +Prepared by apoursh with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/p104-receiver-single-send/README.md b/research/p104-receiver-single-send/README.md new file mode 100644 index 0000000000..4f1a4f507c --- /dev/null +++ b/research/p104-receiver-single-send/README.md @@ -0,0 +1,32 @@ +# Exact price of replacing P104 paid slot 88 with direct sends + +On the submitted rational P104 word from #7786, remove the route through chart 288 at paid slots 95914 and 88. Allow any of the 1,103 original charts to send directly to receiver 127 while preserving all other transfers and permitting arbitrary receiver recoding. The least number of direct sends is **two**. For every nonnegative, nondecreasing concave grade tariff with zero cost at grade zero, the exact optimal paid cost is **one grade-eight send and one grade-one send**. [Proof and model](PROOF.md) + +At the enrolled target κ = 0.00387981257853, the incumbent route pays grades two and five. Across the 48 rational calls, the best direct solution **increases** the paid bill by 94.666202960674077138503464–94.666202960674077138503465 signed units. The incumbent already needs 0.379442 additional units of saving. This is a sharp obstruction for direct replacement of a fixed cut. A physical implementation would also pay for local restocking and terminal arithmetic. + +| What was checked | Result | +|---|---| +| Four exact sparse inputs on the complete word | All 901 surviving receiver deposits vanish. The required output is one. | +| Every donor with all-time stock | The first test is visible only at charts 11, 58 and 278. Each requires a different chart on another test. | +| Constructive replacement at the original times | Chart 11 sends public coordinate 674. Chart 138 sends an already available exact copy of coordinate 780. | +| Source and replacement operators | Two rewritten terminal forms agree on all 1,289 independent coordinates. The other 1,287 outputs have no changed dependency. | + +Clear1nsight's #7795 asked for an additional live observation on a three-coordinate witness after six proposed paid-pair recodings failed. Here chart 11 supplies one, and combining it with chart 138's live atom actually reconstructs the required rows. The four-witness argument prices the optimum across every possible set of fixed direct donors. Changes to other paid rows and inter-donor routing remain open. Clear1nsight's concurrent #7804 tests 126 two-ingress choices at adjoint chart 3 and a changed exterior. Its source and receiver boundary differ from the direct primal chart-127 cut studied here. [Predecessor handoff](https://github.com/CrocSwap/integer-mult-bounds/pull/7795) · [Parallel result #7804](https://github.com/CrocSwap/integer-mult-bounds/pull/7804) · [Coordination claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19754778) + +## Reproduce + +From the repository root, run the registered package with CPython 3.12. + +~~~sh +python3.12 -B scripts/research_package.py --package research/p104-receiver-single-send +~~~ + +The standalone checks are standard-library Python. The forward check propagates the four witnesses, verifies all chart ranks, and independently encloses the signed tariff. The second check constructs the legal two-send operator, validates all chronological sources, and verifies both changed outputs by reverse substitution. The immutable compressed word and its uncompressed payload are authenticated on each run. [Forward check](verify_cut.py) · [Adjoint check](verify_operator.py) · [Source pins](SOURCE-PINS.json) + +## Open next questions + +Can a change to an existing ingress at chart 278 combine the useful observations before the final direct leg at sufficiently low cost? Start by finding an ingress operator that carries the weight of coordinate 674 on test A and separates test D while preserving its original downstream readers. Price the altered ingress, the final send, and every required restoration against the incumbent 48-call invoice. Existing exclusions for six named pairs and the present fixed-stock optimum constrain different classes of changes. + +## Credit + +Clear1nsight supplied the #7786 rational word, the paid-slot-88 handoff and test D in #7795, building on Ali Romman's #7776 signed framework, the #7774 and #7781 lineages, and the contributors recorded in the retained notice. The other three sparse inputs, all-chart proof, exact attaining recoding and price comparison were prepared by apoursh with substantial OpenAI Codex assistance. New work is Apache-2.0. The project's selected conditional multiplication bound remains unchanged. [Incumbent source and contributor history](https://github.com/CrocSwap/integer-mult-bounds/tree/89a67c404226d51028e135de2b9169e9020d57af/research/p104-iterated-returns/continuation) · [Retained source notice](retained/PR7795-NOTICE) · [Original word notice](retained/PR7786-NOTICE) · [Source license](retained/LICENSE) diff --git a/research/p104-receiver-single-send/SOURCE-PINS.json b/research/p104-receiver-single-send/SOURCE-PINS.json new file mode 100644 index 0000000000..19e267aa02 --- /dev/null +++ b/research/p104-receiver-single-send/SOURCE-PINS.json @@ -0,0 +1,49 @@ +{ + "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": "retained/PR7786-NOTICE", + "source": 7786, + "head": "89a67c404226d51028e135de2b9169e9020d57af", + "original_path": "research/p104-iterated-returns/NOTICE", + "git_blob": "3b083891bf59f449b49df024ab7df3feaf6054b8", + "sha256": "4f7d16a4dcaae02de7e7583f7fbb14d5edd19dc4c10b4f47571c145204505844", + "bytes": 1048 + }, + { + "local": "retained/LICENSE", + "source": 7786, + "head": "89a67c404226d51028e135de2b9169e9020d57af", + "original_path": "research/p104-iterated-returns/LICENSE", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "bytes": 11357 + } + ], + "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-single-send/SOURCES.json b/research/p104-receiver-single-send/SOURCES.json new file mode 100644 index 0000000000..22d8e29d40 --- /dev/null +++ b/research/p104-receiver-single-send/SOURCES.json @@ -0,0 +1,41 @@ +{ + "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": 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" + } + ] +} diff --git a/research/p104-receiver-single-send/TASK.json b/research/p104-receiver-single-send/TASK.json new file mode 100644 index 0000000000..82241b2331 --- /dev/null +++ b/research/p104-receiver-single-send/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": "a44c8a401e6a6f9436c0627bc3684946", + "scope_key": "4045f5fea37856e1d039", + "scope_status": "refined", + "actual_scope": "Characterize the least direct-send grade tariff for restoring receiver 127 after removing two fixed observations from the #7786 rational word.", + "scope_change_reason": "This follows #7795's receiver-127 witness and expands the direct sender search to all source charts with arbitrary receivers. The chart-3 and cut-redesign investigations in #7804 use a different boundary.", + "bottleneck_link": "Determines whether the frozen receiver repair can reach the complete 48-call rational saving under the source tariff.", + "stop_rule": "Certify all eligible donor stocks, derive a lower price bound and supply a chronological construction matching the direct-send bound, with complete terminal checks.", + "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 modifying a surviving paid ingress reduce the total chart-127 repair cost?", + "why_it_matters": "The fixed-stock direct-send optimum constrains a specific cut and leaves altered stocks open.", + "first_step": "Select one existing ingress; preserve its other readers and price the complete rerouted network.", + "blocked_by": "An affordable change must preserve all independent owners, causality, and the complete invoice." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19754778", + "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. The P104 #7804 parallel chart-3 check is a separate contract.", + "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-single-send/VERIFY.json b/research/p104-receiver-single-send/VERIFY.json new file mode 100644 index 0000000000..cf25e0bf8c --- /dev/null +++ b/research/p104-receiver-single-send/VERIFY.json @@ -0,0 +1,63 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/verify_cut.py" + ], + "timeout_seconds": 180, + "checks": "All 1,103 donor charts, four separating inputs and the sharp directed price interval" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/verify_cut.py" + ], + "timeout_seconds": 180, + "checks": "All 1,103 donor charts, four separating inputs and the sharp directed price interval under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/verify_operator.py" + ], + "timeout_seconds": 180, + "checks": "Chronology, all 1,289 public directions and all 1,289 terminal rules for the attaining two-send construction" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/verify_operator.py" + ], + "timeout_seconds": 180, + "checks": "Chronology, all 1,289 public directions and all 1,289 terminal rules for the attaining two-send construction under optimized Python" + } + ] +} diff --git a/research/p104-receiver-single-send/retained/LICENSE b/research/p104-receiver-single-send/retained/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-receiver-single-send/retained/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-receiver-single-send/retained/PR7786-NOTICE b/research/p104-receiver-single-send/retained/PR7786-NOTICE new file mode 100644 index 0000000000..3b083891bf --- /dev/null +++ b/research/p104-receiver-single-send/retained/PR7786-NOTICE @@ -0,0 +1,16 @@ +Iterated returns on the P104 ordinary suppliers + +Clear1nsight prepared the successor construction, explicit witnesses and verification +with substantial OpenAI Codex assistance, including independent computational checks. +The new material is offered under Apache-2.0. + +The exact starting words and the rational and binary replay interfaces are from +Clear1nsight's PR #7781. The paid and productive scalar operations, the 48-call +complex schedule, the punctured binary supplier and the common outer application +come from Ali Romman's PR #7776. The two paid projections build on the local +quotient and terminal repair in #7774 and #7781. The binary paired caller and +finite compiler use work by DreamingOfClouds, Jerry Chen (CubeJerry), zxv and the +contributors cited in their retained sources. SYLforge, Rohan Arun, Cinna Davis, +Douglas Colkitt and other predecessors contributed the caller, physical and +analytic framework. The source-fetch helper is adapted from #7774. The immutable +source manifest identifies the public inputs and their notices. diff --git a/research/p104-receiver-single-send/retained/PR7795-NOTICE b/research/p104-receiver-single-send/retained/PR7795-NOTICE new file mode 100644 index 0000000000..6cbfdc843f --- /dev/null +++ b/research/p104-receiver-single-send/retained/PR7795-NOTICE @@ -0,0 +1,23 @@ +Paid slot 88 and linked chart bounds on the P104 four-return word + +Clear1nsight prepared the scoped arguments, source binding and replay package +with substantial OpenAI Codex assistance, including separate computational +checks of causal stock and directed price. New material is Apache-2.0. + +The source material from PR #7786 and the #7781 predecessor is credited to +Clear1nsight. Ali Romman's #7776 supplies the paid and productive scalar +operation model, the 48-call complex schedule, the punctured binary supplier +and the common outer application. The inherited reconstruction used the +restored-chain and local quotient work in #7774 and #7781. The chart-237 +operator and receiving-bank audit in Ali Romman's #7791 is a distinct earlier +source-aware check. Ali Romman's #7793 supplies a nearby one-source broadcast +result on a different information boundary. + +The cone roster, chart extraction, anchor closure and prior 66 integer-price +certificates preserve Clear1nsight's earlier P104 chart experiments. The +directed power enclosure retains the predecessor evaluate_recursive_power.py +implementation under Apache-2.0. DreamingOfClouds, Jerry Chen (CubeJerry), zxv, +SYLforge, Rohan Arun, Cinna Davis, Douglas Colkitt and the credited predecessor +contributors supplied the caller, compiler, physical and analytic framework. +See the source project's NOTICE and the source package's attribution for the +complete inherited lineage. diff --git a/research/p104-receiver-single-send/retained/WORD.json.gz b/research/p104-receiver-single-send/retained/WORD.json.gz new file mode 100644 index 0000000000..337a9d4f8b Binary files /dev/null and b/research/p104-receiver-single-send/retained/WORD.json.gz differ diff --git a/research/p104-receiver-single-send/verify_cut.py b/research/p104-receiver-single-send/verify_cut.py new file mode 100644 index 0000000000..f1980dcd74 --- /dev/null +++ b/research/p104-receiver-single-send/verify_cut.py @@ -0,0 +1,137 @@ +"""Four rational inputs and a directed tariff bound. apoursh with OpenAI Codex, Apache-2.0.""" +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 + +OLD_IN, OLD_OUT, RECEIVER = 95914, 88, 127 +INPUTS = ( + {674: 1, 722: 1}, + {722: 1, 780: -1}, + {674: 1, 825: -1}, + {674: 1, 722: 1, 1288: -F(1, 845660160)}, +) + + +def binary_rank(frame): + pivots = {} + for label in frame: + require(0 < label < 512, 'frame outside the ambient binary space') + while label: + top = label.bit_length() + if top not in pivots: + pivots[top] = label + break + label ^= pivots[top] + return len(pivots) + + +def live_on_input(word, rows, routes, terminal, public): + values = {~j: public.get(j, 0) for j in range(len(word['initial']))} + detected = {word['initial'][j] for j, x in public.items() if x} + retained = [k for k, (_, b) in routes.items() if b == RECEIVER and k != OLD_OUT] + for k in word['schedule']: + if k not in routes and k != terminal: + continue + values[k] = sum(q * values[s] for s, q in rows[k].items()) + if k in routes and k not in (OLD_IN, OLD_OUT) and values[k]: + detected.add(routes[k][1]) + require(len(retained) == 901 and all(values[k] == 0 for k in retained), + 'all surviving receiver inputs must vanish') + require(values[terminal] == values[OLD_OUT] == 1, 'unit output separation') + return detected + + +def log_box(d): + # log(d) = 2 * atanh((d-1)/(d+1)). Bound the tail by a geometric series. + x = F(d - 1, d + 1) + power = x + low = F(0) + for k in range(180): + low += 2 * power / (2*k + 1) + power *= x*x + high = low + 2 * power / (361 * (1-x*x)) + scale = 10**50 + return F(low*scale // 1, scale), F(-((-high*scale) // 1), scale) + + +def alternating_exp(z): + # At 0 <= z < 1 the odd/even partial sums enclose exp(-z). + require(0 <= z < 1, 'alternating exponential bounds') + term = partial = F(1) + for j in range(1, 16): + term *= -z / j + partial += term + return partial, partial - term*z/16 + + +def price_box(d, kappa=F('0.00387981257853')): + low_log, high_log = log_box(d) + return (d*alternating_exp(kappa*high_log/4)[0]**4, + d*alternating_exp(kappa*low_log/4)[1]**4) + + +def main(): + word, rows, routes, terminals = read_word() + check_causality(word, rows, routes, terminals) + require(routes[OLD_IN] == (278, 288) and routes[OLD_OUT] == (288, RECEIVER), + 'incumbent routes') + require([k for k, row in rows.items() if OLD_IN in row] == [OLD_OUT] and + {k for k, row in rows.items() if OLD_OUT in row} == {155442, 155490}, + 'only the two terminals see these removed rows downstream') + require(all(a != RECEIVER for a,b in routes.values()) and + RECEIVER not in word['initial'], 'no receiver egress or initial input') + rank = [binary_rank(fr) for fr in word['frames']] + require(len(rank) == 1103 and all(d == len(fr) for d, fr in zip(rank, word['frames'])), + 'span dimension for every potential donor') + require(rank[RECEIVER] == 9 and [rank[h] for h in (11,58,278,288,138)] == [1,1,2,4,8], + 'actual chart dimensions') + require(binary_rank(word['frames'][278] + word['frames'][288]) == 4, + 'the grade-two incumbent transfer has nested endpoint frames') + + hits = [live_on_input(word,rows,routes,155442,public) for public in INPUTS] + require(hits[0] == {11,58,278}, 'three possible senders at the first witness') + require(11 not in hits[1] and 58 not in hits[2] and 278 not in hits[3], + 'separate each remaining individual sender') + require([min(9-rank[h] for h in hit) for hit in hits] == [7,1,1,5], + 'grade floors of the four observations') + require(all(RECEIVER not in hit for hit in hits), 'complete receiver indistinguishability') + # The case split in the proof can also be recovered as a shortest weighted + # set cover on the four tests. A chart need only be used once in this bound. + lo = {0:F(0)} + prices = {d:price_box(d) for d in range(1,10)} + for h,d in enumerate(rank): + mask = sum((h in hit) << j for j,hit in enumerate(hits)) + if not mask: + continue + weight = prices[9-d][0] + for old, cost in list(lo.items()): + new = old | mask + candidate = cost + weight + if new not in lo or candidate < lo[new]: + lo[new] = candidate + require(lo[15] == prices[8][0]+prices[1][0] and + prices[7][0]+prices[5][0] > prices[8][1]+prices[1][1], + 'minimum four-witness cover') + low = 48 * (lo[15]-prices[2][1]-prices[5][1]) + high = 48 * (prices[8][1]+prices[1][1]-prices[2][0]-prices[5][0]) + unit = 10**24 + # Locate the unique price crossover for power tariffs on (0,1]. + for exponent, sign in ((F('0.25985761'), -1), (F('0.25985762'), 1)): + box = {d: price_box(d, 1-exponent) for d in (2,5,8)} + left = 1 + box[8][0] - box[2][1] - box[5][1] + right = 1 + box[8][1] - box[2][0] - box[5][0] + require(right < 0 if sign < 0 else left > 0, 'power crossover bracket') + print('PASS 1103 charts, 901 retained deposits, 4 tests; live counts', + [len(h) for h in hits], 'least possible grades 8 + 1') + print('48-call paid increase times 10^24 lies between', + low*unit//1, 'and', -((-high*unit)//1)) + require(low > F('94.666202960674077138503464') and + high < F('94.666202960674077138503465'), + 'signed price comparison') + + +if __name__ == '__main__': + main() diff --git a/research/p104-receiver-single-send/verify_operator.py b/research/p104-receiver-single-send/verify_operator.py new file mode 100644 index 0000000000..b0d6aa88b9 --- /dev/null +++ b/research/p104-receiver-single-send/verify_operator.py @@ -0,0 +1,80 @@ +"""Check the attaining paid word by independent adjoint substitution. Apache-2.0.""" +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, value in other.items(): + combined = row.get(k, 0) + value * factor + if combined: + row[k] = combined + elif k in row: + del row[k] + + +def pullback(schedule, forms, key): + terms = {key: 1} + for node in reversed(schedule): + coefficient = terms.pop(node, 0) + if coefficient: + add(terms, forms[node], coefficient) + require(all(k < 0 for k in terms), 'adjoint terminated at public coordinates') + return terms + + +def main(): + word, original, routes, terminals = read_word() + check_causality(word, original, routes, terminals) + schedule = word['schedule'] + old_in, old_out = 95914, 88 + first, second = 155442, 155490 + owner, local_copy = 674, 101539 + require(word['initial'][owner] == 11 and routes[local_copy] == (658,138), + 'live sources for the two replacement transfers') + require(pullback(schedule,original,local_copy) == {~780:1}, 'literal copy of x780') + require(original[first][old_out] == original[second][old_out] == 1, + 'same coefficient on old outlet') + desired = {~674:1, ~780:-1} + require(pullback(schedule,original,first) == desired, 'given output row') + replacement = original.copy() + rewired = routes | {old_in:(11,127), old_out:(138,127)} + replacement[old_in] = {~owner:1} + replacement[old_out] = {local_copy:1} + replacement[first] = {old_in:1,old_out:-1} + second_new = original[second].copy() + add(second_new,original[first],-1) + add(second_new,replacement[first],1) + replacement[second] = second_new + check_causality(word, replacement, rewired, terminals) + + # Both word versions have the same index order. Outside the union of + # their dependency cones equality follows by induction at every node. + affected = set() + for k in schedule: + if original[k] != replacement[k] or affected.intersection(original[k]) or affected.intersection(replacement[k]): + affected.add(k) + require(affected == {old_in,old_out,first,second}, 'exact influence cone') + for k in sorted(affected & terminals.keys()): + require(pullback(schedule,replacement,k) == pullback(schedule,original,k), + 'all 1289 coefficients of changed terminal') + + # Mistakenly retaining the old second output changes its identity. + broken = replacement | {second: original[second]} + require(pullback(schedule,broken,second) != pullback(schedule,original,second), + 'unchanged receiving decoder control') + # Swapping the two raw owners' signs must reverse the entire restored row. + flipped = replacement | {first:{old_in:-1,old_out:1}} + require(pullback(schedule,flipped,first) == {k:-q for k,q in desired.items()}, + 'wrong-sign control') + require(len(terminals)-len(affected & terminals.keys()) == 1287, 'untouched terminals') + print('PASS 1289 outputs on all 1289 rational coordinates, two adjusted terminals,' + ' 1287 unaffected; rank-eight and rank-one sends from charts 11 and 138.') + print('Schedule positions:', [(k,schedule.index(k)) for k in + (old_in,local_copy,old_out,second,first)]) + + +if __name__ == '__main__': + main() diff --git a/research/p104-receiver-single-send/word.py b/research/p104-receiver-single-send/word.py new file mode 100644 index 0000000000..c42aa2db12 --- /dev/null +++ b/research/p104-receiver-single-send/word.py @@ -0,0 +1,48 @@ +"""Read the source-bound rational P104 word. apoursh with OpenAI Codex, Apache-2.0.""" +from fractions import Fraction +from functools import cache +import gzip +import hashlib +import json +from pathlib import Path + + +def require(test, message): + if not test: + raise ValueError(message) + + +@cache +def scalar(value): + return Fraction(value) + + +def read_word(): + raw = (Path(__file__).parent / 'retained' / 'WORD.json.gz').read_bytes() + require(hashlib.sha256(raw).hexdigest() == + 'fde0f7eaa3749d0934a9fc0d6320074f021cd722ed6753f3a59a62fb5b221949', + 'original archive') + data = gzip.decompress(raw) + require(hashlib.sha256(data).hexdigest() == + 'c447b6d5ba956fbe40834fe3c1bc69af2f225736f1b97ecd84b57bab9dd283cb', + 'literal source word') + word = json.loads(data) + program = {k: {s: scalar(q) for s, q in row} for k, row in word['forms']} + routes = {k: (a, b) for k, a, b in word['moves']} + terminals = {word['first_output'] + j: c for j, c in enumerate(word['final'])} + require(len(word['schedule']) == len(program) == 6998 and + len(routes) == 5709 and len(terminals) == len(word['initial']) == 1289, + 'source dimensions') + require(set(word['schedule']) == set(program) == routes.keys() | terminals.keys(), + 'complete schedule') + return word, program, routes, terminals + + +def check_causality(word, program, routes, terminals): + homes = {~i: chart for i, chart in enumerate(word['initial'])} + for k in word['schedule']: + owner = routes[k][0] if k in routes else terminals[k] + require(all(homes.get(s) == owner for s in program[k]), + f'wrong causal stock at {k}') + if k in routes: + homes[k] = routes[k][1]