diff --git a/research/nested-broadcast-auxiliary-optimum/CREDITS.md b/research/nested-broadcast-auxiliary-optimum/CREDITS.md new file mode 100644 index 0000000000..3513b801f1 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/CREDITS.md @@ -0,0 +1,27 @@ +# Attribution + +Ali Romman (@aliromman) prepared the auxiliary-chart theorem and new +checker with substantial OpenAI Codex assistance in research, +implementation, verification and writing. Apache-2.0. + +- Ali Romman's [PR #7790](https://github.com/CrocSwap/integer-mult-bounds/pull/7790) + supplies the [fixed-port theorem and independent source audit](https://github.com/aliromman/integer-mult-bounds/blob/8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e/research/binary-rooted-routing-optimum/PROOF.md). + Its full 17-file package is retained unchanged and replayed. The new + contribution removes its ban on extra chart ports for concave tariffs. +- Clear1nsight (@Clear1nsight) supplies + [PR #7786](https://github.com/CrocSwap/integer-mult-bounds/pull/7786)'s + [rooted binary construction](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/binary/PROOF.md). + Its [source notice](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/NOTICE) + and the retained credits preserve the earlier construction lineage. + This result does not claim the source construction or its kappa gain. +- Related work: Ali Romman's + [PR #7750](https://github.com/CrocSwap/integer-mult-bounds/pull/7750) + gives a [relay obstruction at nine fixed-library BIT deadlines](https://github.com/aliromman/integer-mult-bounds/blob/bd2684e60d122e7c490f0b4fbceb97742584b773/research/bit-nine-deadline-relay-floor/PROOF.md). + It fixes available stock and charts, with a different information + boundary. Its theorem is not used here. + +The retained notices preserve DreamingOfClouds, Jerry Chen (CubeJerry), +zxv, SYLforge, Rohan Arun, Cinna Davis, Douglas Colkitt and earlier +caller, physical, compiler and analytic credit. Elementary concavity, +Prufer codes and minimum-spanning-tree exchange are classical methods. +No global literature priority or independent endorsement is claimed. diff --git a/research/nested-broadcast-auxiliary-optimum/PROOF.md b/research/nested-broadcast-auxiliary-optimum/PROOF.md new file mode 100644 index 0000000000..96e8c6d60a --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/PROOF.md @@ -0,0 +1,216 @@ +# Auxiliary charts do not reduce a nested broadcast tariff + +This is a scoped routing theorem with exact finite corroboration. It +removes the fixed-port restriction from +[PR #7790](https://github.com/CrocSwap/integer-mult-bounds/pull/7790) +for increasing concave rank tariffs. No new kappa follows. + +## Contract and theorem + +Fix any finite strict chain of terminal subspaces +`U_0 < U_1 < ... < U_m`, with dimensions `d_0 < ... < d_m`. +One independent scalar u is available at one terminal. Every other +terminal must receive u. All initial states outside the source are +independent of u. Other inputs can be arbitrary. A circuit must work +for every value of those inputs and u. + +Allow arbitrarily many additional chart ports, chosen from subspaces +of any common finite-dimensional ambient space. A finite circuit can +use arbitrary local linear operations, temporary storage, repeated +messages and either transfer direction. A paid transfer carries one +scalar between strictly nested subspaces A and B, at cost +`H(|dim A-dim B|)`. There is no free cross-port communication, shared +broadcast or second initial copy of information about u. Local work +and storage have no charge in this routing comparison. + +Let `H:[0,infinity)->[0,infinity)` be nondecreasing and concave, with +H(0)=0. Then the exact minimum paid transfer cost is + +```text +sum_(i=1)^m H(d_i-d_(i-1)). +``` + +The adjacent chain attains it. This includes `H(r)=r^t` for every +0= ((b-x)/(b-a)) F(a) + ((x-a)/(b-a)) F(b) + >= min(F(a),F(b)). +``` + +Move x to an endpoint with no greater cost. It now coincides with a +neighbor. Contract their zero-length connecting edge, retaining the +neighbor's label. Because x was not a terminal, every terminal stays +fixed. The graph remains a tree; one nonterminal and one edge disappear. +All other edge lengths after contraction equal their values after the +move. This step also handles nonterminal leaves. + +Repeat. The original tree is finite, so the procedure terminates with +a tree on the terminals alone. Its cost is no greater than the +original cost. Intermediate coordinate trees need not correspond to +legal physical charts. They are used only in a relaxation that gives +a lower bound, not as a proposed native circuit. + +## 3. The adjacent terminal chain is minimum + +On the terminal-only complete graph, consider the cut between d_(i-1) +and d_i. Every crossing edge has length at least their gap. The adjacent +edge is therefore a minimum-weight crossing edge for every +nondecreasing H. If a terminal tree omits that edge, insert it and +remove another edge of the resulting cycle that crosses this cut. +The cost cannot increase. + +Do this for each adjacent pair. A previously inserted adjacent edge +does not cross any other such cut, so it need not be removed. The +result is the adjacent chain, of cost given in the theorem. Combining +the two reductions proves the lower bound for every finite circuit. +Sending u outward along this chain from its source terminal attains +the bound, using one scalar transfer per edge. The original terminal +subspaces are nested, so those transfers are legal in the stated model. + +## 4. Binding to the actual rooted binary route + +The retained +[source proof](https://github.com/aliromman/integer-mult-bounds/blob/8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e/research/binary-rooted-routing-optimum/PROOF.md) +independently interprets the frozen binary word from +[PR #7786](https://github.com/CrocSwap/integer-mult-bounds/pull/7786) +at `ff6f1d8ab3fafb71ea12ccd943013d058c0f5847`. Its actual chart +chain and final emitted packet ordinals are + +```text +charts: 0 -> 509 -> 390 -> 517, +ranks: 0 -> 4 -> 6 -> 7, +packets: 2944 2943 2942. +``` + +The root is a nonzero 55-input form. The next two packets copy it. +Exact rational row reduction verifies every containment. The new +theorem gives the same sharp cost `H(4)+H(2)+H(1)` even after allowing +arbitrarily many auxiliary charts, under the same one-source boundary. +It does not assert that every other bank in the complete supplier is +independent of this form. A proposal that uses such a bank changes the +information contract and needs a separate analysis. + +The separate owner-411 bridge has grade four and is preserved. The root +preparation, all other packets, productive targets and cleanup are +outside this route comparison. The source's full conditional kappa is +not recertified. Its PR can advance without changing this frozen claim. + +## 5. Exact finite corroboration + +The checker decodes every labeled tree by its unique Prufer sequence +and independently checks connectivity, edge count and uniqueness. +For terminal ranks 0,4,6,7 it tests every assignment of each auxiliary +rank in {0,...,9}, including repeated ranks. + +| Auxiliary vertices | Labeled trees | Placements per tree | Cases | +|---:|---:|---:|---:| +| 0 | 16 | 1 | 16 | +| 1 | 125 | 10 | 1,250 | +| 2 | 1,296 | 100 | 129,600 | +| Total | | | 130,866 | + +For each case it checks all nine tariffs `H_s(r)=min(r,s)`, s=1,...,9. +Their minimum costs are `[3,5,6,7,7,7,7,7,7]`. These checks cover +every nondecreasing concave tariff on this integer grid. To see this, +let `Delta_r=H(r)-H(r-1)`. Then + +```text +H(r) = sum_(s=1)^8 (Delta_s-Delta_(s+1)) min(r,s) + + Delta_9 min(r,9), 0<=r<=9. +``` + +Every coefficient is nonnegative. The checker reconstructs all 512 +binary combinations of these basis tariffs as a separate check. +This finite domain is corroboration, not the arbitrary-size proof. + +A separate contraction calculation uses all 1,296 six-vertex trees, +three auxiliary coordinate pairs `(-2,9)`, `(1/2,11/2)` and `(4,4)`, +and caps 1,3,9. All 11,664 exact traces preserve the terminals and +connectivity, decrease the vertex count, and never increase cost. +They test 23,328 contractions, including fractional, outside-interval +and coincident positions. Hashes identify the complete deterministic +censuses; representative traces and aggregate counts are in RESULT.json. + +## 6. Controls and limits + +Concavity is necessary. With `H(r)=r^2`, the original terminal-chain +cost is 21. An extra rank-two port gives the legal nested chain +`0,2,4,6,7`, of cost 13. The checker rejects that convex tariff and +verifies the strict gain. If u is supplied free at rank four as well +as rank zero, the linear-tariff cost drops from seven to three. Thus +the unique-source premise cannot be dropped. Additional controls +reject a decreasing tariff, a nonzero origin and a false strict floor; +a disconnected demand graph is also detected. + +The entire 17-file source package is retained unchanged. Its verifier +runs in both modes and checks all 462,400 scalar coefficients in each +orientation, the actual chart geometry, the independent packet graph, +root/bridge faults and 3,554 dirty retirements per orientation. This +is reuse of the source implementation, not a new independent replay +of those facts. The new census and contraction code is separate. + +The earlier construction history, physical erasure, paired caller, +ordinary compiler, finite stock, precision and outer services are +not replayed. No Lean, independent human acceptance or global +literature-priority claim is made. The proof uses elementary +concavity and minimum-spanning-tree exchange. All five framework +assumptions and the selected frontier remain unchanged. + +## Open next questions + +Identify another already-paid observation that reduces the source +information requirement. Give its exact location, time, extraction +cost and restoration before comparing invoices. + +State a joint multi-value demand matrix and initial information +contract. Shared coded messages between different demands are outside +this one-scalar theorem and can require a different lower bound. diff --git a/research/nested-broadcast-auxiliary-optimum/README.md b/research/nested-broadcast-auxiliary-optimum/README.md new file mode 100644 index 0000000000..17124b66a5 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/README.md @@ -0,0 +1,42 @@ +# Exact nested broadcast cost with auxiliary charts + +For one scalar available at one source terminal, the exact broadcast +cost along any strictly nested terminal chain is the sum of H over +adjacent rank gaps. The tariff H is nondecreasing and concave, with +H(0)=0. Arbitrarily many extra charts, finite linear mixing, repeated +transfers and local storage do not lower that cost. Other initial +information about the scalar is excluded. + +For the published binary route through charts 0,509,390,517, the cost +remains H(4)+H(2)+H(1). This resolves the extra-chart part of PR7790's +open question. It does not optimize the complete supplier or change +kappa. All five assumptions and the selected frontier are unchanged. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[SOURCE-PINS.json](SOURCE-PINS.json) and [CREDITS.md](CREDITS.md). +Use Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/nested-broadcast-auxiliary-optimum +``` + +Both modes print this prefix and elapsed seconds: + +```text +PASS_NESTED_BROADCAST_AUXILIARY_OPTIMUM 130866 tree placements; 11664 contraction traces; +``` + +The verifier runs the unchanged rooted-route source suite. New checks +cover every labeled tree and integer placement through two auxiliary +vertices, all nine concave basis tariffs, 512 tariff reconstructions +and 23328 exact contractions. Convex-tariff and second-source examples +show why the theorem needs its hypotheses. The written proof covers +arbitrary finite circuits; the census alone does not. + +## Open next questions + +Identify an already-paid second observation of the demanded scalar, +with its location, time, extraction and restoration costs. + +Price a joint multi-value demand contract. Shared coded messages for +different demands are outside this scalar broadcast theorem. diff --git a/research/nested-broadcast-auxiliary-optimum/RESULT.json b/research/nested-broadcast-auxiliary-optimum/RESULT.json new file mode 100644 index 0000000000..0f07c8a621 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/RESULT.json @@ -0,0 +1,724 @@ +{ + "source_files": 17, + "source_word_sha256": "d3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d", + "ports": [ + 0, + 509, + 390, + 517 + ], + "source_packet_chain": [ + 2944, + 2943, + 2942 + ], + "source_replay": { + "coefficients_each_orientation": 462400, + "dirty_retirements_each_orientation": 3554 + }, + "integer_census": { + "terminal_ranks": [ + 0, + 4, + 6, + 7 + ], + "auxiliary_rank_domain": [ + 0, + 9 + ], + "basis_caps": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9 + ], + "basis_floor": [ + 3, + 5, + 6, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "cases": [ + { + "auxiliary_vertices": 0, + "labeled_trees": 16, + "placements_per_tree": 1, + "cases": 16, + "basis_minimum": [ + 3, + 5, + 6, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "basis_minimizer_counts": [ + 16, + 8, + 3, + 3, + 1, + 1, + 1, + 1, + 1 + ] + }, + { + "auxiliary_vertices": 1, + "labeled_trees": 125, + "placements_per_tree": 10, + "cases": 1250, + "basis_minimum": [ + 3, + 5, + 6, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "basis_minimizer_counts": [ + 200, + 104, + 42, + 45, + 16, + 16, + 16, + 16, + 16 + ] + }, + { + "auxiliary_vertices": 2, + "labeled_trees": 1296, + "placements_per_tree": 100, + "cases": 129600, + "basis_minimum": [ + 3, + 5, + 6, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "basis_minimizer_counts": [ + 3024, + 1628, + 696, + 792, + 300, + 300, + 300, + 300, + 300 + ] + } + ], + "total_cases": 130866, + "census_sha256": "560500b07d9d72538794eb7e9921ca7f072257f9857bc6377dd6a69e5d72f56c", + "tariff_reconstructions": 512 + }, + "contraction_census": { + "cases": 11664, + "contractions": 23328, + "trace_sha256": "5c70a066c6af6363d584cd438e3ea713a7f4d7385de66e20934772883411830a", + "maximum_cost_drop": "32", + "sample_traces": [ + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 1, + "steps": [ + [ + 4, + 0, + "-2", + "0", + "5", + "4" + ], + [ + 5, + 0, + "9", + "0", + "4", + "3" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 3, + "steps": [ + [ + 4, + 0, + "-2", + "0", + "14", + "12" + ], + [ + 5, + 0, + "9", + "0", + "12", + "9" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 0, + "-2", + "0", + "28", + "26" + ], + [ + 5, + 0, + "9", + "0", + "26", + "17" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 5 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 5, + "-2", + "9", + "35", + "26" + ], + [ + 5, + 0, + "9", + "0", + "26", + "17" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 5 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 3, + "-2", + "7", + "37", + "21" + ], + [ + 5, + 3, + "9", + "7", + "21", + "17" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 1, + 4 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 1, + "-2", + "4", + "34", + "18" + ], + [ + 5, + 1, + "9", + "4", + "18", + "13" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 1, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 2, + "-2", + "6", + "36", + "14" + ], + [ + 5, + 2, + "9", + "6", + "14", + "11" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 2, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 5 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 2, + "-2", + "6", + "39", + "17" + ], + [ + 5, + 2, + "9", + "6", + "17", + "11" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 2, + 3 + ] + ] + }, + { + "edges": [ + [ + 0, + 5 + ], + [ + 1, + 4 + ], + [ + 2, + 4 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ] + ], + "auxiliary": [ + "-2", + "9" + ], + "cap": 9, + "steps": [ + [ + 4, + 1, + "-2", + "4", + "41", + "19" + ], + [ + 5, + 1, + "9", + "4", + "19", + "9" + ] + ], + "final_edges": [ + [ + 0, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ] + } + ] + }, + "controls": [ + { + "control": "convex squared tariff", + "rejection": "concave tariff" + }, + { + "control": "decreasing tariff", + "rejection": "nondecreasing tariff" + }, + { + "control": "nonzero origin", + "rejection": "zero origin tariff" + }, + { + "control": "false strict floor", + "rejection": "attaining chain has cap-one cost three" + } + ], + "scope_counterexamples": { + "convex_old_cost": 21, + "convex_extra_port_cost": 13, + "free_second_copy_linear_cost": 3, + "one_source_linear_cost": 7 + }, + "disconnected_demand_control": true +} diff --git a/research/nested-broadcast-auxiliary-optimum/SOURCE-PINS.json b/research/nested-broadcast-auxiliary-optimum/SOURCE-PINS.json new file mode 100644 index 0000000000..3c2de627c7 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/SOURCE-PINS.json @@ -0,0 +1,141 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/CREDITS.md", + "retained": "retained/source7790/CREDITS.md", + "sha256": "0a9c52c990a516becd23bd963011b5afb11022f66fb3b7f17ab1868fa15b5c0c", + "git_blob": "7c97e0afe0cb2966196396dd534e7eed5facc5d0" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/LICENSE", + "retained": "retained/source7790/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/PROOF.md", + "retained": "retained/source7790/PROOF.md", + "sha256": "b5093863e896359c05826cb1239e08473727dfd274298184ad0e82336f069b8d", + "git_blob": "062b799aa7562a1ed755a79dd6a73c398db61226" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/README.md", + "retained": "retained/source7790/README.md", + "sha256": "c4367cf0c7b8aa3d20b6c0297915e9d703e6d172cc55abc30de66acf8e6152af", + "git_blob": "dee472da486d34a055a02e8999e1198697b00949" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/RESULT.json", + "retained": "retained/source7790/RESULT.json", + "sha256": "c2c4330e2febea692cc84e33bb4c8d8358f45b6a2fe9a0bbdb858c56e00c095d", + "git_blob": "800318c803f9e0420c4653128c36464b921dc967" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/SOURCE-PINS.json", + "retained": "retained/source7790/SOURCE-PINS.json", + "sha256": "ff12fb7876aa8ecfcea7aa57c387b7931eced0d5b9580ae31f3517cdc473f2cc", + "git_blob": "a72a0055ce69da7f84e4917da8d14e380a5dab23" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/SOURCES.json", + "retained": "retained/source7790/SOURCES.json", + "sha256": "0761fd793723c2df1e2ca51733251cfd597ff3e120f7e2ee8ebb8e10e8e98c08", + "git_blob": "5335fa97d97f6df5a917eea1ee2fcd01c082d261" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/TASK.json", + "retained": "retained/source7790/TASK.json", + "sha256": "3d03c08830882cd22c81a67e856715466b154d66f86cf338bc039850f0061e85", + "git_blob": "8c7695bcf359cadb10b7b94fba7fc576368ed8b0" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/VERIFY.json", + "retained": "retained/source7790/VERIFY.json", + "sha256": "f35b92a93fe78b9c5e3f2508ca8775056f9f69fad9c111a5ad64a4a1ff7d1e6e", + "git_blob": "d1a0c7f2a6c230a0095b99d016542499c05f1f04" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/LICENSE", + "retained": "retained/source7790/retained/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/NOTICE", + "retained": "retained/source7790/retained/NOTICE", + "sha256": "4f7d16a4dcaae02de7e7583f7fbb14d5edd19dc4c10b4f47571c145204505844", + "git_blob": "3b083891bf59f449b49df024ab7df3feaf6054b8" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/binary/PROOF.md", + "retained": "retained/source7790/retained/binary/PROOF.md", + "sha256": "ecd0f7df5cfbac821e13f48a4140535f4a4083d92916d4b1d520361ae8661d50", + "git_blob": "d57ee61b276e1c42da251d4b1d6166dfb80fa544" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/binary/REPLAY.json", + "retained": "retained/source7790/retained/binary/REPLAY.json", + "sha256": "0c90174cef40c742972296f306eaf0dc1eadfb04b3f2cfa3feaa49c368d7480b", + "git_blob": "bd90421508470adac9cde63e1af968819b8ac7bf" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/binary/ROOT411-CONTROL.json", + "retained": "retained/source7790/retained/binary/ROOT411-CONTROL.json", + "sha256": "1fa2bd65dd8779e76865cd7a0922ecd5e97d85e8cc56e6ecb3fdeebeb47e8782", + "git_blob": "c3ac1bc06383dff80969faaad89cc60f7fd8e7b1" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/binary/WORD.json.gz", + "retained": "retained/source7790/retained/binary/WORD.json.gz", + "sha256": "d28f0d28d9d87d5fe57b8ef19e12faf98014f0bbef781987ce22daaa82f21cb9", + "git_blob": "efb2e9d1c3caec25bea36803ca6994997e3256b0" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/retained/binary/intermediate/OWNER411.json", + "retained": "retained/source7790/retained/binary/intermediate/OWNER411.json", + "sha256": "d6ff13c1a0a3930312b1e72fdac57b284482e1bb4562c4804b50174536fe17f7", + "git_blob": "8a75080ae04564f771f0576b14d924c96a1bf3cd" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "8cae9a6b7fed315f704144f27a89bf9b0ad9fd6e", + "path": "research/binary-rooted-routing-optimum/verify.py", + "retained": "retained/source7790/verify.py", + "sha256": "22af5be8833f25090741621378739ee29cc57d1080f38d96b84b9b7fead57edc", + "git_blob": "5b3a9f39e662e5ed891ebe4ec3d3beda8edcd060" + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/SOURCES.json b/research/nested-broadcast-auxiliary-optimum/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/SOURCES.json @@ -0,0 +1,18 @@ +{ + "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" + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/TASK.json b/research/nested-broadcast-auxiliary-optimum/TASK.json new file mode 100644 index 0000000000..9641453ed7 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/TASK.json @@ -0,0 +1,101 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Sharp one-source broadcast cost along any strictly nested terminal chain with arbitrarily many auxiliary chart ports and increasing concave rank tariffs.", + "scope_change_reason": "PR7790 leaves extra charts outside its four-port theorem. Eliminate that restriction for one-source broadcast under concave tariffs, while preserving the explicit information boundary.", + "bottleneck_link": "Extra charts alone cannot lower this rooted route. A useful change must alter available information, demands, paid communication or another charged part of the supplier.", + "budget_minutes": 60, + "stop_rule": "Stop after the general elimination proof, exact bounded census and source-bound route check. Do not resynthesize the supplier or claim a global optimum.", + "outcome": "completed", + "evidence": "PROOF.md proves the arbitrary finite auxiliary-chart theorem. RESULT.json records exhaustive labeled trees and placements, exact contraction traces and source replay.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Can another already-paid observation reduce the route cost?", + "why_it_matters": "The theorem requires one available copy of one independent scalar.", + "first_step": "Name a second observation and its exact source, time and extraction cost.", + "blocked_by": "No such fully priced source-compatible observation is supplied." + }, + { + "question": "Can joint delivery of several dependent values improve the complete invoice?", + "why_it_matters": "The scalar broadcast theorem does not price shared messages between distinct demands.", + "first_step": "State the full demand matrix, initial information and restoration boundary.", + "blocked_by": "The multi-demand information contract and all additional charges remain open." + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/VERIFY.json b/research/nested-broadcast-auxiliary-optimum/VERIFY.json new file mode 100644 index 0000000000..99f8a9a63c --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Run the unchanged rooted-route source checker, enumerate every tree and integer placement through two auxiliary vertices, verify exact contraction traces and reject changed hypotheses." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Run the unchanged rooted-route source checker, enumerate every tree and integer placement through two auxiliary vertices, verify exact contraction traces and reject changed hypotheses." + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/CREDITS.md b/research/nested-broadcast-auxiliary-optimum/retained/source7790/CREDITS.md new file mode 100644 index 0000000000..7c97e0afe0 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/CREDITS.md @@ -0,0 +1,21 @@ +# Attribution + +Ali Romman (@aliromman) prepared this independent scalar audit and +fixed-port routing theorem with substantial OpenAI Codex assistance +in research, implementation, verification and writing. Apache-2.0. + +Clear1nsight (@Clear1nsight) supplied the rooted binary construction in +[PR #7786](https://github.com/CrocSwap/integer-mult-bounds/pull/7786). +Its [binary proof](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/binary/PROOF.md) +and [source notice](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/NOTICE) +identify the supplied construction and predecessors. The frozen word, +root receipt, proof and notices are retained byte for byte. + +Clear1nsight's preceding binary births in +[PR #7781](https://github.com/CrocSwap/integer-mult-bounds/pull/7781) +build on Ali Romman's native carrier and punctures in +[PR #7776](https://github.com/CrocSwap/integer-mult-bounds/pull/7776). +The source notice preserves DreamingOfClouds, Jerry Chen (CubeJerry), +zxv, SYLforge, Rohan Arun, Cinna Davis, Douglas Colkitt and the earlier +caller, physical, compiler and analytic lineage. This audit does not +claim authorship of the source construction or its kappa improvement. diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/LICENSE b/research/nested-broadcast-auxiliary-optimum/retained/source7790/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/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/nested-broadcast-auxiliary-optimum/retained/source7790/PROOF.md b/research/nested-broadcast-auxiliary-optimum/retained/source7790/PROOF.md new file mode 100644 index 0000000000..062b799aa7 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/PROOF.md @@ -0,0 +1,156 @@ +# The rooted binary repair is optimal at its fixed ports + +This is a scoped routing lower bound and an independent scalar audit of +[PR #7786](https://github.com/CrocSwap/integer-mult-bounds/pull/7786) +at `ff6f1d8ab3fafb71ea12ccd943013d058c0f5847`. It does not change the +construction or its complete multiplication exponent. + +## Exact class and result + +Fix four rational chart ports with strictly nested subspaces and ranks +0,4,6,7. One independent value u is available at the rank-zero port. +The other three ports must each receive u. They have no initial +information about u. Auxiliary inputs may be arbitrary, but independent +of u. Permit any finite straight-line linear computation within a port, +any finite number of scalar paid transfers in either direction between +these four ports, and arbitrary temporary local storage. There is no +additional port, pre-existing copy, free cross-port communication or +shared broadcast. Each transfer between ranks a and b costs +H_(|a-b|), where H_r=r^t and t>0. + +The exact minimum paid cost is + +```text +H_4 + H_2 + H_1. +``` + +Every minimum uses the three adjacent port pairs, once each. Information +must travel outward from the rank-zero port. Local linear computations +need not be unique. The bound covers arbitrary finite linear routing, +not only a list of candidate trees. It includes the recursive tariffs +t=1-kappa for 00. For the cut after rank 0, the unique shortest crossing pair +is (0,4). For the cut after rank 4, it is (4,6). For the cut after rank +6, it is (6,7). Strict increase of r^t preserves those comparisons. +If a minimum tree omitted one of these edges, inserting it would form +a cycle. That cycle contains a different edge across the same cut. +Replacing that longer edge strictly lowers the cost, a contradiction. + +Thus all three chain edges are necessary in a minimum tree. Sending u +along the chain attains the bound. Additional paid transmissions cost +strictly more. With only one transmission per chain edge, causality +forces the outward direction and order. This proves the result. + +The exact finite certificate separately enumerates all 64 undirected +graphs on four labeled vertices. It finds 38 connected graphs and 16 +spanning trees. The sorted rank list of every tree is componentwise at +least (1,2,4), with equality only for the chain. Every connected graph +contains one of the checked trees. This corroborates the proof through +a different finite calculation. + +## Binding to the actual owner-411 repair + +The [source binary proof](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/binary/PROOF.md) +identifies the four ports as charts 0,509,390,517. The checker reads +their actual rational bases from the frozen word. Exact rational row +reduction verifies ranks 0,4,6,7 and every pairwise containment. Chart +1 has rank eight, so the separate owner-411 bridge to chart 509 has +grade four. + +The checker interprets all 42,958 literal instructions without importing +any predecessor execution engine. It assigns a separate GF(2) variable +to every one of the 680 public inputs. Forward interpretation gives + +```text +X_i -> X_i, 0 <= i < 111, +Y_i -> Y_i + X_i, Y_i has address 111+i, +h_j -> h_j, 222 <= j < 680. +``` + +Reverse interpretation transposes each ADD, reverses each MOVE, and +exchanges activation with retirement. It gives the full adjoint. +All 462,400 matrix coefficients agree in each direction. Chart tags, +local ADD contacts and private lifetimes are checked. All 3,554 private +retirements carry nonzero values in each orientation; this is evidence +under the source's owned-erasure semantics, not a physical erasure proof. + +A separate extraction replaces each paid arrival with an independent +symbol, then transposes those local linear equations. Expanding this +packet graph gives the same complete adjoint as the literal interpreter. +In this independently numbered graph, the rooted chain is + +```text +packet 2944: chart 0 -> 509, with 55 direct exterior donors, +packet 2943: chart 509 -> 390, copies packet 2944, +packet 2942: chart 390 -> 517, copies packet 2943. +``` + +The expanded root is exactly the 55-input form specified in the +[source feedback receipt](https://github.com/Clear1nsight/integer-mult-bounds/blob/ff6f1d8ab3fafb71ea12ccd943013d058c0f5847/research/p104-iterated-returns/binary/intermediate/OWNER411.json). +These packet numbers are ordinals in the final emitted word. They are +not the original recipe labels 2329,2590,2944. + +The separate packet 3553 sends x_411 from chart 1 to chart 509. Its +only sender is input 411, and output 411 reads only this packet. The +root form contains no input 411 and is nonzero. Thus the two required +values are independent; the root cannot replace the helper bridge. + +Replacing the rooted chain by three equal-value cycle equations leaves +an undetermined common value. The chronological scheduler rejects it. +Setting the root to zero also changes the complete operator. Neither +operation gives a valid cheaper realization of the specified value. + +Every one of the 55 direct root terms is essential to this fixed word. +Let v_j be the expanded value of one donor, and let h be the complete +output response to a unit pulse at the root. The dependency graph is +acyclic, so deleting that donor changes the operator by h times v_j. +The checker proves h and all 55 v_j are nonzero. These are nonzero +rank-one faults over GF(2). A complete recomputation for one donor +agrees coefficient by coefficient with that outer product. This does +not exclude a different algebraically equivalent expression for the +root; it establishes the role of each term in the published expression. + +## Consequence for further searches + +The source already uses the minimum (4,2,1) route at these ports. A +different chronological tree, repeated messages or local XOR mixing +cannot improve that route's signed invoice. The separate grade-four +helper bridge is preserved in this comparison. To seek a gain, change +the ports, available information or consumer contract, then price that +new boundary. This result is not an optimum for the whole binary word. + +## Evidence, limits and open next questions + +The checker authenticates seven retained files, checks both full scalar +operators, both independent graph/word calculations, the rational port +geometry, the complete graph census and root/bridge omission effects. +It rejects an unrooted cycle, a missing private CLEAR and an altered +port subspace. Deleting the helper bridge changes exactly coefficient +(411,411). The certificate records the root faults' exact supports. + +The predecessor's eight-birth construction and intermediate quotient +history are not regenerated. Full physical chart validity, the paired +caller, ordinary compiler, finite stock, precision and outer services +are not replayed. The complete source kappa and ordinary saving are not +recertified. No Lean, Docker, selected cold replay or independent human +acceptance is claimed. All five framework assumptions and the selected +frontier remain unchanged. + +An open next question is whether another already-paid observation or an +additional chart can deliver the same value more cheaply under a fully +charged interface. Such an extension is outside the fixed-port theorem. diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/README.md b/research/nested-broadcast-auxiliary-optimum/retained/source7790/README.md new file mode 100644 index 0000000000..dee472da48 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/README.md @@ -0,0 +1,37 @@ +# Fixed-port optimum for the rooted binary repair + +The owner-411 repair in PR #7786 already has the minimum paid root route +on its four specified ports. The exact cost is H4+H2+H1 for every +H(r)=r^t with t>0. The theorem permits arbitrary finite local linear +computation and repeated transfers. It fixes the unique exterior +information port, demanded ports and single-field transfer cost. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[SOURCE-PINS.json](SOURCE-PINS.json) and [CREDITS.md](CREDITS.md). +Use Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/binary-rooted-routing-optimum +``` + +Both modes print this prefix and elapsed seconds: + +```text +PASS_BINARY_ROOTED_ROUTING_OPTIMUM 462400 coefficients each way 16 trees +``` + +The separate interpreter checks the full 680-owner forward and adjoint +operators. Exact rational geometry and all 64 port graphs corroborate +the optimum. Root, helper-bridge, cycle and retirement controls expose +their distinct roles. No source execution engine is imported. + +## Open next questions + +Change the available information, chart ports or consumer contract to +seek a cheaper route. Price every new transfer. This theorem does not +exclude such changes or claim an optimum for the full supplier. + +The source history, physical charts, paired caller, ordinary compiler, +finite stock and outer service are not replayed. No new kappa or +independent human/formal acceptance is claimed. All five assumptions +and the selected frontier remain unchanged. diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/RESULT.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/RESULT.json new file mode 100644 index 0000000000..800318c803 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/RESULT.json @@ -0,0 +1,613 @@ +{ + "source_files": 7, + "word_sha256": "d3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d", + "coefficients_each_orientation": 462400, + "dirty_retirements_each_orientation": 3554, + "paid_packets": 2874, + "actual_packet_chain": [ + 2944, + 2943, + 2942 + ], + "independent_bridge": 3553, + "root_input_support": [ + 111, + 113, + 116, + 118, + 120, + 121, + 122, + 124, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 145, + 147, + 149, + 152, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 194, + 196, + 198, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 218, + 219 + ], + "root_direct_donors": [ + 3301, + 3305, + 3309, + 3324, + 3326, + 3330, + 3332, + 3334, + 3336, + 3338, + 3340, + 3342, + 3344, + 3346, + 3348, + 3366, + 3368, + 3370, + 3372, + 3374, + 3376, + 3393, + 3395, + 3397, + 3399, + 3401, + 3403, + 3411, + 3413, + 3415, + 3417, + 3419, + 3422, + 3424, + 3426, + 3461, + 3464, + 3466, + 3468, + 3470, + 3472, + 3474, + 3476, + 3478, + 3480, + 3483, + 3485, + 3487, + 3490, + 3492, + 3494, + 3536, + 3538, + 3540, + 3542 + ], + "root_output_support": [ + 0, + 1, + 4, + 5, + 8, + 12, + 15, + 17, + 18, + 20, + 22, + 25, + 26, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 40, + 43, + 45, + 47, + 49, + 50, + 54, + 55, + 58, + 60, + 63, + 64, + 67, + 70, + 72, + 74, + 76, + 77, + 79, + 82, + 84, + 87, + 92, + 93, + 94, + 95, + 96, + 98, + 101, + 104, + 106, + 107, + 109, + 226, + 236, + 243, + 254, + 266, + 267, + 277, + 284, + 286, + 295, + 298, + 301, + 303, + 308, + 314, + 320, + 321, + 326, + 337, + 350, + 359, + 364, + 376, + 384, + 386, + 395, + 401, + 405, + 421, + 425, + 441, + 445, + 447, + 449, + 450, + 454, + 461, + 470, + 477, + 488, + 503, + 525, + 534, + 556, + 567, + 592, + 607, + 627, + 645 + ], + "essential_root_terms": 55, + "sampled_omission_donor": 3301, + "omission_changed_coefficients": 105, + "root_zero_changed_coefficients": 5775, + "helper_bridge_changed_coefficients": 1, + "routing": { + "ports": [ + 0, + 509, + 390, + 517 + ], + "dimensions": [ + 0, + 4, + 6, + 7 + ], + "trees": [ + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ] + ], + "ranks": [ + 4, + 6, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "ranks": [ + 2, + 4, + 7 + ] + }, + { + "edges": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 2 + ] + ], + "ranks": [ + 2, + 6, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 1, + 3 + ] + ], + "ranks": [ + 3, + 4, + 6 + ] + }, + { + "edges": [ + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 1, + 3 + ] + ], + "ranks": [ + 3, + 6, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "ranks": [ + 2, + 3, + 4 + ] + }, + { + "edges": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "ranks": [ + 2, + 3, + 6 + ] + }, + { + "edges": [ + [ + 0, + 3 + ], + [ + 1, + 2 + ], + [ + 1, + 3 + ] + ], + "ranks": [ + 2, + 3, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 4, + 6 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 0, + 3 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 4, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 1, + 2 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 2, + 4 + ] + }, + { + "edges": [ + [ + 0, + 2 + ], + [ + 1, + 2 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 2, + 6 + ] + }, + { + "edges": [ + [ + 0, + 3 + ], + [ + 1, + 2 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 2, + 7 + ] + }, + { + "edges": [ + [ + 0, + 1 + ], + [ + 1, + 3 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 3, + 4 + ] + }, + { + "edges": [ + [ + 0, + 2 + ], + [ + 1, + 3 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 3, + 6 + ] + }, + { + "edges": [ + [ + 0, + 3 + ], + [ + 1, + 3 + ], + [ + 2, + 3 + ] + ], + "ranks": [ + 1, + 3, + 7 + ] + } + ], + "connected_graphs": 38, + "all_graphs": 64 + }, + "controls": [ + { + "control": "unrooted equal-value cycle", + "rejection": "acyclic packet dependency" + }, + { + "control": "missing final private CLEAR", + "rejection": "complete field retirement" + }, + { + "control": "changed root-port subspace", + "rejection": "actual four port ranks" + } + ], + "optimal_paid_ranks": [ + 1, + 2, + 4 + ], + "owner_bridge_rank": 4 +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCE-PINS.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCE-PINS.json new file mode 100644 index 0000000000..a72a0055ce --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCE-PINS.json @@ -0,0 +1,60 @@ +{ + "sources": [ + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/binary/WORD.json.gz", + "retained": "retained/binary/WORD.json.gz", + "sha256": "d28f0d28d9d87d5fe57b8ef19e12faf98014f0bbef781987ce22daaa82f21cb9", + "git_blob": "efb2e9d1c3caec25bea36803ca6994997e3256b0" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/binary/PROOF.md", + "retained": "retained/binary/PROOF.md", + "sha256": "ecd0f7df5cfbac821e13f48a4140535f4a4083d92916d4b1d520361ae8661d50", + "git_blob": "d57ee61b276e1c42da251d4b1d6166dfb80fa544" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/binary/REPLAY.json", + "retained": "retained/binary/REPLAY.json", + "sha256": "0c90174cef40c742972296f306eaf0dc1eadfb04b3f2cfa3feaa49c368d7480b", + "git_blob": "bd90421508470adac9cde63e1af968819b8ac7bf" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/binary/ROOT411-CONTROL.json", + "retained": "retained/binary/ROOT411-CONTROL.json", + "sha256": "1fa2bd65dd8779e76865cd7a0922ecd5e97d85e8cc56e6ecb3fdeebeb47e8782", + "git_blob": "c3ac1bc06383dff80969faaad89cc60f7fd8e7b1" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/binary/intermediate/OWNER411.json", + "retained": "retained/binary/intermediate/OWNER411.json", + "sha256": "d6ff13c1a0a3930312b1e72fdac57b284482e1bb4562c4804b50174536fe17f7", + "git_blob": "8a75080ae04564f771f0576b14d924c96a1bf3cd" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/NOTICE", + "retained": "retained/NOTICE", + "sha256": "4f7d16a4dcaae02de7e7583f7fbb14d5edd19dc4c10b4f47571c145204505844", + "git_blob": "3b083891bf59f449b49df024ab7df3feaf6054b8" + }, + { + "repository": "Clear1nsight/integer-mult-bounds", + "commit": "ff6f1d8ab3fafb71ea12ccd943013d058c0f5847", + "path": "research/p104-iterated-returns/LICENSE", + "retained": "retained/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCES.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/SOURCES.json @@ -0,0 +1,18 @@ +{ + "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" + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/TASK.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/TASK.json new file mode 100644 index 0000000000..8c7695bcf3 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/TASK.json @@ -0,0 +1,95 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Independent complete 680-owner binary scalar audit and exact minimum routing cost for the source-bound owner-411 repair at four fixed nested chart ports.", + "scope_change_reason": "The latest candidate introduces a rooted feedback repair. Resolve its exterior-value binding and prove the limit of rerouting at the same ports before another construction search.", + "bottleneck_link": "Separate a valid chronological supplier from a cyclic scalar relation, and identify the changed boundary required for a further paid improvement.", + "budget_minutes": 60, + "stop_rule": "Stop after the fixed-port theorem, both full scalar operators, actual rational port geometry and discriminating root/bridge controls.", + "outcome": "completed", + "evidence": "PROOF.md gives the arbitrary finite linear-routing lower bound. RESULT.json binds it to the frozen word, all 924800 scalar coefficients, 16 trees and root/bridge faults.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Can a changed available-information boundary improve this repair?", + "why_it_matters": "The current four-port route is already optimal.", + "first_step": "Name another available copy or chart and price all added transfers.", + "blocked_by": "No additional free observation is part of this theorem." + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/VERIFY.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/VERIFY.json new file mode 100644 index 0000000000..d1a0c7f2a6 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check seven source pins, both complete literal scalar operators, the independently extracted packet graph, rational nested chart ranks, all 64 port graphs and root/bridge/retirement controls." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check seven source pins, both complete literal scalar operators, the independently extracted packet graph, rational nested chart ranks, all 64 port graphs and root/bridge/retirement controls." + } + ] +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/LICENSE b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/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/nested-broadcast-auxiliary-optimum/retained/source7790/retained/NOTICE b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/NOTICE new file mode 100644 index 0000000000..3b083891bf --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/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/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/PROOF.md b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/PROOF.md new file mode 100644 index 0000000000..d57ee61b27 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/PROOF.md @@ -0,0 +1,43 @@ +# Ordinary BIT from eight births and ten paid quotients + +The 680-owner binary word `d3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d` supplies **0.003879927836145** ordinary BIT saving under the retained physical, owned-erasure, compiler and precision-tape assumptions. The complete 36-call signed invoice at `0.00387981257853` has margin in `[0.044469702525047757782581495783214766, 0.044469702525047757782581495783214767]`. The raw crossing lies in `[0.003879928046154, 0.003879928046155]`. [Sharpened finite receipt](FINITE.json) · [Complete construction receipt](REPLAY.json) + +## Source and first nine quotients + +The source is the #7781 exact-head word `861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff` at head `913fb6febe28cc3ccad1c16de8e45b8bce0da063`. Eight additional calibrated paid subdivisions give `0cfae4f0a7a47628f7ce45b5c11bcacbb2957592f5be511230434d7b7e8f0d37`. Owner 432 descends from the thirteenth #7781 binary birth, which split its chart `1→0` grade-eight return at chart 509. Owner 411 descends from the twelfth birth at the same intermediate chart. The eight further daughter quotients use the contact journal’s original owners 237, 250, 264, 351, 355, 383, 387 and 391. [Published #7781 birth recipe](https://github.com/CrocSwap/integer-mult-bounds/blob/913fb6febe28cc3ccad1c16de8e45b8bce0da063/research/p104-subdivided-helper-births/binary/BIRTHS.json) · [Cohort receipt](WITHDRAWALS.json) + +Work in the transposed scalar graph. Give every public input its own independent variable $x_r$. Let $D$ be the coordinate set temporarily restricted to zero, and let $V_k$ be the old value at paid arrival $k$. A same-chart expression $L_k$ in retained arrivals permits the retirement of $k$ when $V_k=L_k$ after setting the coordinates in $D$ to zero. The replay compares that identity symbolically on every input basis column. It then substitutes $L_k$ at every use, assigns each remaining producer to its original chart, and checks the rebuilt chronological order. The nine removed corner relations use either a zero row or a single cocharted donor. Distinct direct paid bridges return each isolated $x_r$ on its original nested helper charts. This reinstates every productive owner and preserves all other arbitrary outputs. Transposing the verified word produces the matching adjoint. These contractions follow Ali Romman's binary-source puncture and its independent audit. [PR #7776](https://github.com/CrocSwap/integer-mult-bounds/pull/7776) · [PR #7780](https://github.com/CrocSwap/integer-mult-bounds/pull/7780) · [Chronological reproducer](replay_quotients.py) + +Owner 432 replaces a rank-one and rank-three paid pair by one rank-four paid return. The eight-owner cohort replaces sixteen rank-one transfers by eight rank-two direct returns. All 680 labels and boundaries survive in intermediate `c38f1881fa87f9b9e4a27e6ba8f4ce1a608a6d6ab014648bbe758d3c48a353d9`. This intermediate remains short by `0.268603545909298631752980047687504785` signed units at the target. [Cohort receipt](WITHDRAWALS.json) + +## Rooted owner-411 quotient + +On the pinned `c38f1881…` adjoint, slot 2946 carries $x_{411}$ from chart 1 to 517. The difference of the cocharted arrivals 3298 and 2329 at chart 509 also equals $x_{411}$. Use $D=\{411\}$ and substitute slot 2329 for 3298 and zero for 2946. The unrooted quotient contains the three equal-value equations + +$$ +V'_{2329}=V'_{2590},\qquad V'_{2590}=V'_{2944},\qquad V'_{2944}=V'_{2329}. +$$ + +The cyclic block has rank two. Its free common value must equal the old sender of slot 3298 evaluated at $x_{411}=0$. That sender uses earlier arrivals in chart 0 and survives the restriction. Send its unchanged projected form from chart 0 into the chart-509 arrival labeled 2329, then forward through chart 390 into slot 2590 and through chart 517 into slot 2944. The charts are strictly nested in the order $0\subset509\subset390\subset517$. This restores the original restricted value in every one of the three arrival slots. The resulting paid graph is acyclic. The exact replay checks every surviving paid value against the corresponding original form after restriction. The rank-four paid bridge from chart 1 to chart 509 reinstates the independent owner 411 return. [Cyclic equations and rank](intermediate/OWNER411.json) · [Retirement and replacement rows](REPLAY.json) + +The unrooted substitution removes grades 4 and 1 and adds the grade-four helper bridge. Rooting the common value replaces the retained grades $(2,1,3)$ by $(4,2,1)$. Thus the net additional credit across 36 calls is $36(H_1+H_3-H_4)$ for $H_r=r^{1-C}$. This is at least `0.313073248434346389535561543470719551` signed units at the exact target. The complete improvement from #7781 is $36(10H_1+2H_3-2H_4+8H_6-8H_7)$. All retired and replacement paid slots and all productive targets remain in the resulting histograms with their appropriate signed counts. [Signed histograms](REPLAY.json) + +## Independent replay and finite ordinary service + +The separate literal interpreter checks 462,400 scalar endpoint coefficients in each direction, verifies all 2,385 used ordered paid geometries per direction, and reconciles all 3,554 dirty lifetimes. The unchanged polynomial caller has 1,444 coefficients in each orientation across its literal 36 native invocations. The tape contains 107,460 paid positions and 20,706 productive fields, including 16,488 independently supplied native helpers across the caller. The ordinary recount uses 934,182,831,504 raw ordinary records and 6,998,544 owned fields. These satisfy the retained bounds of $10^{12}$ records and $10^7$ fields. [Independent receipt](INDEPENDENT.json) + +The reconstruction checks that the unrooted cycle fails the chronological scheduler and that omitting root donor 3303 changes the full transfer. In the separate literal word, omitting the isolated-411 bridge's only source ADD changes exactly coefficient $(411,411)$ in both orientations. Removing the last CLEAR fails the private-retirement check. [Rooted repair controls](ROOT411-CONTROL.json) · [Independent verifier](verify_target.py) + +A separate finite replay admits **0.0038799074072**. At trial `0.003879908046154`, the retained chronological power 768, paid cutoff base 15 and productive floor base 16 give a strict normalized separation slack of at least `0.000020445039920241`. The maximum productive rank is $127^{768}$ and the working ambient is $134^{768}$. The verified uniform power is 621 with $N=2^{298610000000000}$. The uniform and delayed-cover losses are each $10^{-10}$. Starting with selected ordinary saving `0.00385248`, the two exact stock stages admit `0.0038797981346` and `0.0038799074072`, both with strict envelope slack. [Finite receipt](INDEPENDENT.json) · [Inherited ordinary proof](https://github.com/CrocSwap/integer-mult-bounds/blob/913fb6febe28cc3ccad1c16de8e45b8bce0da063/research/p104-subdivided-helper-births/binary/PROOF.md) + +## Reproduction + +Use the prepared source cache specified by the parent package. Run from this directory. + + python3 -I -B construction.py --cache "$cache" --out "$build" + python3 -I -B verify_target.py \ + --word WORD.json.gz --source-root "$cache/source" \ + --independent "$cache/parent/binary/independent" --out "$build/independent.json" + cmp "$build/independent.json" INDEPENDENT.json + +The construction script regenerates the successor to submitted #7781 from its chronological birth, withdrawal and rooted-411 recipes. It compares the decompressed generated word with the frozen payload. [Birth journal](BIRTHS.json) · [Withdrawals](WITHDRAWALS.json) · [Rooted repair](REPLAY.json) diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/REPLAY.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/REPLAY.json new file mode 100644 index 0000000000..bd90421508 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/REPLAY.json @@ -0,0 +1,267 @@ +{ + "caller_coefficients_each_way": 1444, + "goal": "goal-e6198eb08f2d4bceae61ce995ab9d599", + "gzip_sha256": "d28f0d28d9d87d5fe57b8ef19e12faf98014f0bbef781987ce22daaa82f21cb9", + "instructions": { + "ADD": 32296, + "CLEAR": 3554, + "INIT": 3554, + "MOVE": 2874, + "SWAP": 680 + }, + "margin": [ + "0.044469702525047757782581495783214766", + "0.044469702525047757782581495783214767" + ], + "native": { + "checked_public_matrix_coefficients": 462400, + "exact_scalar_endpoint": "X_i\u2192X_i; Y_i\u2192Y_i+X_i; each helper independent", + "native_edges": 2874, + "nonzero_owned_erasures": 3554, + "owned_labels": 3554, + "owned_lifetimes": 3554, + "peak_owned": 3554, + "public": 680 + }, + "native_calls": 36, + "native_paid": { + "1": 1376, + "2": 1281, + "3": 54, + "4": 44, + "5": 17, + "6": 102 + }, + "native_targets": { + "1": 8, + "2": 9, + "4": 43, + "5": 8, + "6": 1, + "8": 389 + }, + "ordinary": { + "caller_bank_transits": 3507600, + "native_bank_transits_per_call": 2912896064, + "native_banks_and_scratch": 4238, + "ordinary_records": 934182831504, + "owned_backing": 6998544, + "raw_ordinary_allowance": 1000000000000, + "raw_owned_allowance": 10000000, + "route_groups": 573048, + "route_records": 829315065600 + }, + "paid": { + "1": 49980, + "2": 46116, + "3": 1944, + "4": 1584, + "5": 612, + "6": 3672, + "7": 444, + "14": 444, + "21": 444, + "28": 444, + "35": 444, + "42": 444, + "49": 444, + "56": 444 + }, + "program_sha256": "d3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d", + "saving": [ + "3.818300623062402804637991647072044339", + "3.818300623062402804637991647072044340" + ], + "signed_delta": { + "1": 10, + "3": 2, + "4": -2, + "6": 8, + "7": -8 + }, + "signed_positions": { + "ambient": 134, + "fresh_helpers": 16488, + "native_calls": 36, + "native_private_banks": 127944, + "paid_calls": 107460, + "paid_position_sha256": "e60548e331918cb5fd287576edff7d56e9a69b5f1b2b79ab8feaf3dfa939b70a", + "productive_fields": 20706, + "rank_surplus": 1506, + "rational_frame_sha256": "d8e64b466cd0f0d7548a804b5274adcada4adb31fb71f7f0783a59af7443e887", + "rational_frames": 636, + "rational_main_charts": 111, + "raw_prime_exclusions": [ + 1, + 2, + 4, + 16, + 64 + ], + "serial_query_bank": 1 + }, + "source_head": "913fb6febe28cc3ccad1c16de8e45b8bce0da063", + "source_native_sha256": "861f5181e4f34db638ab0c573c319fe26ff034d63b21242d67220a4a5d6433ff", + "source_receipt": "progress.goal-e6198eb08f2d4bceae61ce995ab9d599.00000001", + "target": "0.00387981257853", + "targets": { + "1": 288, + "2": 324, + "4": 1548, + "5": 288, + "6": 36, + "8": 14448, + "15": 444, + "22": 444, + "29": 444, + "36": 444, + "43": 444, + "50": 444, + "57": 444, + "64": 444, + "127": 222 + }, + "trace": { + "alias": { + "chart": 509, + "label": 2329, + "retired_label": 3298 + }, + "changed_rank_histogram": { + "1": 1, + "3": 1, + "4": -1 + }, + "owner": 411, + "owner_bridge": { + "charts": [ + 1, + 509 + ], + "label": 3555, + "sender": [ + 411 + ] + }, + "receipt": "progress.goal-e6198eb08f2d4bceae61ce995ab9d599.00000006", + "retire": { + "2946": { + "charts": [ + 1, + 517 + ], + "clock": 10385, + "label": 2946 + }, + "3298": { + "charts": [ + 0, + 509 + ], + "clock": 11474, + "label": 3298 + } + }, + "saving": [ + "0.313073248434346389535561543470719551", + "0.313073248434346389535561543470719552" + ], + "source_word": "c38f1881fa87f9b9e4a27e6ba8f4ce1a608a6d6ab014648bbe758d3c48a353d9", + "transposed": true, + "tree": { + "2329": { + "after": [ + 0, + 509 + ], + "before": [ + 390, + 509 + ], + "row": [ + 3303, + 3307, + 3311, + 3326, + 3328, + 3332, + 3334, + 3336, + 3338, + 3340, + 3342, + 3344, + 3346, + 3348, + 3350, + 3368, + 3370, + 3372, + 3374, + 3376, + 3378, + 3395, + 3397, + 3399, + 3401, + 3403, + 3405, + 3413, + 3415, + 3417, + 3419, + 3421, + 3424, + 3426, + 3428, + 3463, + 3466, + 3468, + 3470, + 3472, + 3474, + 3476, + 3478, + 3480, + 3482, + 3485, + 3487, + 3489, + 3492, + 3494, + 3496, + 3538, + 3540, + 3542, + 3544 + ] + }, + "2590": { + "after": [ + 509, + 390 + ], + "before": [ + 517, + 390 + ], + "row": [ + 2329 + ] + }, + "2944": { + "after": [ + 390, + 517 + ], + "before": [ + 509, + 517 + ], + "row": [ + 2590 + ] + } + } + } +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/ROOT411-CONTROL.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/ROOT411-CONTROL.json new file mode 100644 index 0000000000..c3ac1bc063 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/ROOT411-CONTROL.json @@ -0,0 +1,32 @@ +{ + "arbitrary_coefficients_each_direction": 462400, + "dirty_owned_erasures_each_direction": 3554, + "exact_tree_ranks": [ + 4, + 2, + 1 + ], + "grade_of_independent_owner_bridge": 4, + "old_alias_chart": 509, + "old_exterior_producer_direct_terms": 55, + "old_exterior_producer_transitive_ancestors": 170, + "omitted_old_producer_donor_rejected": 3303, + "owner": 411, + "parent_sha256": "c38f1881fa87f9b9e4a27e6ba8f4ce1a608a6d6ab014648bbe758d3c48a353d9", + "pure_packet": 2946, + "retained_paid_rows": 2873, + "signed_delta_by_rank": { + "1": 1, + "3": 1, + "4": -1 + }, + "strict_nested_tree": true, + "tree_charts": [ + 0, + 509, + 390, + 517 + ], + "unrooted_control": "causal binary packet schedule", + "word_sha256": "d3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d" +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/WORD.json.gz b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/WORD.json.gz new file mode 100644 index 0000000000..efb2e9d1c3 Binary files /dev/null and b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/WORD.json.gz differ diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/intermediate/OWNER411.json b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/intermediate/OWNER411.json new file mode 100644 index 0000000000..8a75080ae0 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/retained/binary/intermediate/OWNER411.json @@ -0,0 +1,242 @@ +{ + "available_paid_prefix": 2726, + "blocked": 148, + "causal_exact": [], + "components": [ + { + "dimension": 3, + "labels": [ + 2329, + 2590, + 2944 + ], + "rank": 2, + "rows": { + "2329": { + "chart": [ + 390, + 509 + ], + "clock": 7339, + "desired_inputs": [ + 111, + 113, + 116, + 118, + 120, + 121, + 122, + 124, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 145, + 147, + 149, + 152, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 194, + 196, + 198, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 218, + 219 + ], + "inside": [ + 2590 + ], + "parents": [ + 2590 + ] + }, + "2590": { + "chart": [ + 517, + 390 + ], + "clock": 8992, + "desired_inputs": [ + 111, + 113, + 116, + 118, + 120, + 121, + 122, + 124, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 145, + 147, + 149, + 152, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 194, + 196, + 198, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 218, + 219 + ], + "inside": [ + 2944 + ], + "parents": [ + 2944 + ] + }, + "2944": { + "chart": [ + 509, + 517 + ], + "clock": 10379, + "desired_inputs": [ + 111, + 113, + 116, + 118, + 120, + 121, + 122, + 124, + 125, + 126, + 127, + 128, + 134, + 136, + 138, + 140, + 141, + 143, + 145, + 147, + 149, + 152, + 154, + 155, + 157, + 158, + 161, + 162, + 163, + 165, + 166, + 168, + 170, + 171, + 173, + 174, + 177, + 179, + 181, + 183, + 194, + 196, + 198, + 199, + 201, + 203, + 205, + 208, + 209, + 212, + 213, + 214, + 215, + 218, + 219 + ], + "inside": [ + 2329 + ], + "parents": [ + 2329 + ] + } + } + } + ], + "cpu": 0.267731123, + "goal": "goal-e6198eb08f2d4bceae61ce995ab9d599", + "nominal_gain": [ + "35.999999999999999999999999999999999999", + "36.000000000000000000000000000000000001" + ], + "receipt": "progress.goal-e6198eb08f2d4bceae61ce995ab9d599.00000006", + "receiving_alias": 2329, + "recovery_candidates": [], + "removed": [ + 3298, + 2946 + ], + "source_word": "c38f1881fa87f9b9e4a27e6ba8f4ce1a608a6d6ab014648bbe758d3c48a353d9" +} diff --git a/research/nested-broadcast-auxiliary-optimum/retained/source7790/verify.py b/research/nested-broadcast-auxiliary-optimum/retained/source7790/verify.py new file mode 100644 index 0000000000..5b3a9f39e6 --- /dev/null +++ b/research/nested-broadcast-auxiliary-optimum/retained/source7790/verify.py @@ -0,0 +1,256 @@ +"""Check the frozen binary transfer and the fixed-port routing optimum.""" +from fractions import Fraction as F +from hashlib import sha1, sha256 +from itertools import combinations +from pathlib import Path +import argparse +import gzip +import json +import time + +HERE = Path(__file__).resolve().parent + + +def need(value, label): + if not value: + raise ValueError(label) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def bits(value): + while value: + low = value & -value + yield low.bit_length()-1 + value ^= low + + +def xor(values): + result = 0 + for value in values: + result ^= value + return result + + +def rank(rows): + rows = [list(map(F, row)) for row in rows] + r = 0 + for c in range(8): + pivot = next((i for i in range(r, len(rows)) if rows[i][c]), None) + if pivot is None: + continue + rows[r], rows[pivot] = rows[pivot], rows[r] + scale = rows[r][c] + rows[r] = [v/scale for v in rows[r]] + for i in range(r+1, len(rows)): + scale = rows[i][c] + rows[i] = [v-scale*w for v,w in zip(rows[i], rows[r], strict=True)] + r += 1 + return r + + +def literal(word, reverse=False, omit=None): + n = word['public'] + origin, final = (word['final'], word['start']) if reverse else (word['start'], word['final']) + state = {j:1<= n, 'private lifetime') + if opening: + need(dst not in state, 'new private field') + state[dst], chart[dst] = 0, args[0] + else: + need(dst in state and chart[dst] == args[0], 'private erasure chart') + dirty += bool(state[dst]) + del state[dst], chart[dst] + elif op == 'ADD': + src, location = args + need(src != dst and chart[src] == chart[dst] == location, 'local ADD') + if reverse: + state[src] ^= state[dst] + else: + state[dst] ^= state[src] + elif op == 'SWAP': + src, = args + state[src], state[dst] = state[dst], state[src] + chart[src], chart[dst] = chart[dst], chart[src] + else: + need(op == 'MOVE', 'known operation') + a,b = args[::-1] if reverse else args + need(chart[dst] == a, 'paid chronology') + chart[dst] = b + need(chart == dict(enumerate(final)) and set(state) == set(range(n)), 'complete field retirement') + return [state[i] for i in range(n)], dirty + + +def graph(word): + n = word['public'] + state = {j:1<>i&1] + if not connected(selected): + continue + weights = sorted(dimensions[b]-dimensions[a] for a,b in selected) + graphs.append(selected) + if len(selected) == 3: + need(all(a<=b for a,b in zip([1,2,4],weights,strict=True)), 'tree rank dominance') + need((weights == [1,2,4]) == (set(selected) == chain), 'unique minimum tree') + trees.append(dict(edges=list(map(list,selected)), ranks=weights)) + need(len(trees) == 16 and len(graphs) == 38, 'complete four-vertex graph census') + for selected in graphs: + need(any(set(map(tuple,t['edges'])) <= set(selected) for t in trees), 'every connected graph contains a checked tree') + return dict(ports=ports, dimensions=dimensions, trees=trees, connected_graphs=len(graphs), all_graphs=64) + + +def reject(name, action): + try: + action() + except ValueError as error: + return dict(control=name, rejection=str(error)) + raise ValueError('control passed: '+name) + + +def run(): + pins = read(HERE/'SOURCE-PINS.json')['sources'] + for p in pins: + raw = (HERE/p['retained']).read_bytes() + need(sha256(raw).hexdigest() == p['sha256'] and sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == p['git_blob'], 'retained bytes') + word = read(HERE/'retained/binary/WORD.json.gz') + canonical = sha256(json.dumps(word,sort_keys=True,separators=(',',':')).encode()).hexdigest() + need(canonical == 'd3aa4426fa8fe7dc167270d01f2515184f2bff6a82744a14e941c5dd3afca27d', 'frozen word') + n = word['public'] + need(n == 680, 'all independent owners') + expected = [1<>411&1, 'independent helper bridge') + need(rank(word['frames']['1']['B']) == 8 and rank(word['frames']['509']['B']) == 4, + 'independent bridge grade four') + influence = dict.fromkeys(values,0) + for i in range(n): + for j in bits(rows[~i]): + influence[j] ^= 1<>i&1 else 0 for i in range(n)], 'exact rank-one root fault') + need(any(fault), 'nonzero root fault') + zeroed,_,_ = expand(n,routes,rows | {root:0}) + need(zeroed != output, 'root-zero failure') + unbridged,_,_ = expand(n,routes,rows | {bridge:0}) + need([a^b for a,b in zip(unbridged,output,strict=True)] == [1<<411 if i==411 else 0 for i in range(n)], 'isolated helper fault') + cycle = rows | {root:1<= 0, 'nondecreasing tariff') + need(all(a >= b for a, b in zip(slopes, slopes[1:])), 'concave tariff') + weights = [a-b for a, b in zip(slopes, slopes[1:])]+[slopes[-1]] + need(all(sum(w*min(r, s+1) for s, w in enumerate(weights)) == values[r] + for r in range(len(values))), 'exact concave-basis reconstruction') + return weights + + +def integer_census(): + floor = basis_cost([1, 2, 4]) + digest = sha256() + rows = [] + for extra in range(3): + n = 4+extra + family = trees(n) + minimum = [10**9]*9 + minimizers = [0]*9 + cases = 0 + for edges in family: + for auxiliary in product(range(10), repeat=extra): + ranks = TERMINALS+auxiliary + lengths = sorted(abs(ranks[a]-ranks[b]) for a, b in edges) + costs = basis_cost(lengths) + need(all(a >= b for a, b in zip(costs, floor, strict=True)), + 'all increasing concave integer-grid tariffs') + for i, cost in enumerate(costs): + if cost < minimum[i]: + minimum[i], minimizers[i] = cost, 1 + elif cost == minimum[i]: + minimizers[i] += 1 + digest.update(json.dumps([extra, edges, auxiliary, lengths], separators=(',', ':')).encode()+b'\n') + cases += 1 + need(minimum == floor and cases == n**(n-2)*10**extra, 'census completeness and attainment') + rows.append(dict(auxiliary_vertices=extra, labeled_trees=len(family), + placements_per_tree=10**extra, cases=cases, + basis_minimum=minimum, basis_minimizer_counts=minimizers)) + weights = [] + # Every one of these spectra defines an increasing concave tariff exactly. + for mask in range(512): + w = [(mask>>s)&1 for s in range(9)] + values = [sum(a*min(r, s+1) for s, a in enumerate(w)) for r in range(10)] + need(check_tariff(values) == w, 'all binary basis combinations') + weights.append(w) + return dict(terminal_ranks=list(TERMINALS), auxiliary_rank_domain=[0, 9], + basis_caps=list(range(1, 10)), basis_floor=floor, cases=rows, + total_cases=sum(r['cases'] for r in rows), census_sha256=digest.hexdigest(), + tariff_reconstructions=len(weights)) + + +def cost(edges, ranks, cap): + return sum(min(abs(ranks[a]-ranks[b]), cap) for a, b in edges) + + +def contract_auxiliaries(edges, positions, cap): + edges = set(edges) + ranks = dict(enumerate(positions)) + start = cost(edges, ranks, cap) + steps = [] + for vertex in range(4, len(positions)): + neighbors = sorted(b if a == vertex else a for a, b in edges if vertex in (a, b)) + need(neighbors, 'connected auxiliary vertex') + x = ranks[vertex] + points = sorted({ranks[v] for v in neighbors}) + if x <= points[0]: + choices = [points[0]] + elif x >= points[-1]: + choices = [points[-1]] + else: + choices = [max(y for y in points if y <= x), min(y for y in points if y >= x)] + def local(y): + return sum(min(abs(y-ranks[v]), cap) for v in neighbors) + target = min(choices, key=lambda y: (local(y), y)) + need(local(target) <= local(x), 'concave endpoint move does not increase cost') + before = cost(edges, ranks, cap) + ranks[vertex] = target + survivor = next(v for v in neighbors if ranks[v] == target) + replacement = set() + for a, b in edges: + a = survivor if a == vertex else a + b = survivor if b == vertex else b + if a != b: + replacement.add(tuple(sorted((a, b)))) + need(len(replacement) == len(edges)-1, 'one tree edge contracted') + edges = replacement + del ranks[vertex] + after = cost(edges, ranks, cap) + need(after <= before and connected(ranks, edges), 'connected nonincreasing contraction') + need(all(ranks[i] == TERMINALS[i] for i in range(4)), 'terminals do not move') + steps.append([vertex, survivor, str(x), str(target), str(before), str(after)]) + need(set(ranks) == set(range(4)) and len(edges) == 3, 'terminal tree remains') + final = cost(edges, ranks, cap) + floor = sum(min(r, cap) for r in (1, 2, 4)) + need(start >= final >= floor, 'terminal-tree lower bound') + return steps, sorted(edges), start-final + + +def contraction_census(): + digest = sha256() + cases = 0 + maximum_drop = F(0) + samples = [] + positions = [(-2, 9), (F(1, 2), F(11, 2)), (4, 4)] + for edges in trees(6): + for pair in positions: + for cap in (1, 3, 9): + steps, final, drop = contract_auxiliaries(edges, TERMINALS+pair, cap) + row = dict(edges=[list(edge) for edge in edges], auxiliary=list(map(str, pair)), cap=cap, + steps=steps, final_edges=[list(edge) for edge in final]) + digest.update(json.dumps(row, sort_keys=True, separators=(',', ':')).encode()+b'\n') + if not samples or drop > maximum_drop: + samples.append(row) + maximum_drop = max(maximum_drop, drop) + cases += 1 + need(cases == 1296*3*3, 'all specified contraction traces') + return dict(cases=cases, contractions=2*cases, trace_sha256=digest.hexdigest(), + maximum_cost_drop=str(maximum_drop), sample_traces=samples) + + +def reject(label, operation): + try: + operation() + except ValueError as error: + return dict(control=label, rejection=str(error)) + raise ValueError('accepted mutation '+label) + + +def run(): + pins = read(HERE/'SOURCE-PINS.json')['sources'] + for pin in pins: + raw = (HERE/pin['retained']).read_bytes() + need(sha256(raw).hexdigest() == pin['sha256'] and + sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'retained source bytes') + source = HERE/'retained/source7790' + command = [sys.executable, '-W', 'error', *(['-O'] if sys.flags.optimize else []), + '-B', str(source/'verify.py')] + replay = subprocess.run(command, capture_output=True, text=True, check=True, timeout=60) + need('PASS_BINARY_ROOTED_ROUTING_OPTIMUM' in replay.stdout, 'unchanged source replay') + receipt = read(source/'RESULT.json') + need(receipt['routing']['dimensions'] == list(TERMINALS) and + receipt['routing']['ports'] == [0, 509, 390, 517] and + receipt['optimal_paid_ranks'] == [1, 2, 4] and + receipt['actual_packet_chain'] == [2944, 2943, 2942], 'actual source-chain binding') + census = integer_census() + contraction = contraction_census() + controls = [reject('convex squared tariff', lambda: check_tariff([r*r for r in range(10)])), + reject('decreasing tariff', lambda: check_tariff([0, 2, 1])), + reject('nonzero origin', lambda: check_tariff([1, 2, 3]))] + need(sum(r*r for r in (2, 2, 2, 1)) == 13 < 21 == sum(r*r for r in (4, 2, 1)), + 'convex tariff gains from one auxiliary rank-two port') + need(2+1 < 4+2+1, 'a free second copy at rank four changes the boundary') + need(not connected(range(4), [(0, 1), (2, 3)]), 'disconnected demand control') + controls.append(reject('false strict floor', lambda: need(min(census['basis_floor']) > 3, + 'attaining chain has cap-one cost three'))) + return dict(source_files=len(pins), source_word_sha256=receipt['word_sha256'], + ports=receipt['routing']['ports'], source_packet_chain=receipt['actual_packet_chain'], + source_replay=dict(coefficients_each_orientation=receipt['coefficients_each_orientation'], + dirty_retirements_each_orientation=receipt['dirty_retirements_each_orientation']), + integer_census=census, contraction_census=contraction, controls=controls, + scope_counterexamples=dict(convex_old_cost=21, convex_extra_port_cost=13, + free_second_copy_linear_cost=3, one_source_linear_cost=7), + disconnected_demand_control=True) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--write-result', action='store_true') + args = parser.parse_args() + start = time.monotonic() + result = run() + path = HERE/'RESULT.json' + if args.write_result: + path.write_text(json.dumps(result, indent=2)+'\n') + else: + need(result == read(path), 'computed receipt matches committed receipt') + print('PASS_NESTED_BROADCAST_AUXILIARY_OPTIMUM', result['integer_census']['total_cases'], + 'tree placements;', result['contraction_census']['cases'], 'contraction traces;', + round(time.monotonic()-start, 2), 'seconds')