diff --git a/.gitattributes b/.gitattributes index 41aef290fd..76e425cdaf 100644 --- a/.gitattributes +++ b/.gitattributes @@ -8,3 +8,8 @@ upstream/** -whitespace references/copied-centers/pr29/** -whitespace references/copied-centers/pr33/** -whitespace references/semantic-bulk/** -whitespace + +# Preserve the exact bytes of pinned upstream proof and witness snapshots. +references/partial-gauge/pr97/** whitespace=-blank-at-eof +# Preserve the exact pinned PR117 source bytes and legal notices. +references/three-stage-cover/pr117/** -whitespace diff --git a/.github/workflows/cover-local-reuse.yml b/.github/workflows/cover-local-reuse.yml new file mode 100644 index 0000000000..2764788fc4 --- /dev/null +++ b/.github/workflows/cover-local-reuse.yml @@ -0,0 +1,29 @@ +name: Verify padded triple covers + +on: + push: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + focused: + runs-on: ubuntu-24.04 + timeout-minutes: 35 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13', '3.14'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7 + with: + python-version: ${{ matrix.python-version }} + - name: Replay local word, padded geometry and exact cover assembly + run: python3 research/cover-local-reuse/verify.py + - name: Require untouched frozen sources + run: git diff --exit-code diff --git a/.github/workflows/verify.yml b/.github/workflows/verify.yml index 6bd374e1ca..f4f07a20f5 100644 --- a/.github/workflows/verify.yml +++ b/.github/workflows/verify.yml @@ -16,7 +16,7 @@ jobs: fail-fast: false matrix: python-version: ['3.11', '3.13', '3.14'] - group: [community, producers, certificates, ternary, research, tests, strips, clones, positive, joint, pair] + group: [community, producers, certificates, ternary, research, tests, strips, clones, positive, joint, pair, partial-gauge, three-stage-cover] steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 with: diff --git a/Makefile b/Makefile index 84fe8290f3..3c154f295d 100644 --- a/Makefile +++ b/Makefile @@ -15,6 +15,8 @@ community-followup-check: verify: $(MAKE) verify-community $(MAKE) verify-producers + $(MAKE) verify-partial-gauge + $(MAKE) verify-three-stage-cover $(MAKE) verify-certificates $(MAKE) verify-ternary $(MAKE) verify-research @@ -30,6 +32,7 @@ verify-community: community-audit-check community-followup-check copied-reversed $(MAKE) climbed-48-verify verify-producers: + $(MAKE) stopped-product-verify $(MAKE) copied-centers-verify $(MAKE) structured-bulk-verify $(MAKE) endpoint-gauge-producer endpoint-gauge-certificate @@ -428,3 +431,38 @@ pair-assembly-verify: pair-assembly-producer pair-assembly-check .PHONY: verify-pair verify-pair: pair-assembly-verify python3 scripts/audit_pair_candidate.py --check docs/research/community-pair-arithmetic.json + +.PHONY: stopped-product-producer stopped-product-certificate stopped-product-verify +stopped-product-producer: + python3 scripts/stopped_product_producer.py + +stopped-product-certificate: + python3 scripts/stopped_product_network.py + +stopped-product-verify: stopped-product-producer stopped-product-certificate + +.PHONY: partial-gauge-bit partial-gauge-producer partial-gauge-certificate partial-gauge-verify +partial-gauge-bit: + python3 scripts/partial_gauge_bit.py + +partial-gauge-producer: + python3 scripts/partial_gauge_producer.py + +partial-gauge-certificate: + python3 scripts/partial_gauge_network.py + +partial-gauge-verify: partial-gauge-bit partial-gauge-producer partial-gauge-certificate + +.PHONY: verify-partial-gauge +verify-partial-gauge: partial-gauge-verify + +.PHONY: three-stage-cover-producer three-stage-cover-certificate three-stage-cover-verify verify-three-stage-cover +three-stage-cover-producer: + python3 scripts/three_stage_cover_producer.py + +three-stage-cover-certificate: + python3 scripts/three_stage_cover_network.py + +three-stage-cover-verify: three-stage-cover-producer three-stage-cover-certificate + +verify-three-stage-cover: three-stage-cover-verify diff --git a/NOTICE b/NOTICE index b565637758..c719bbed04 100644 --- a/NOTICE +++ b/NOTICE @@ -302,3 +302,60 @@ inherited PR #48 sources. The stacked witness in research/pair-assembly/frame uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. diff --git a/PATCHING.md b/PATCHING.md index b60f3f101b..a02e230256 100644 --- a/PATCHING.md +++ b/PATCHING.md @@ -1,6 +1,6 @@ # Applying the inherited manuscript patch -This patch is the PR #10 baseline. The current copied-center extension is +This patch is the PR #10 baseline. The PR #36 copied-center extension is presented in `notes/copied-centers-note.tex`; it is not included in this historical combined manuscript patch. @@ -30,3 +30,6 @@ alternatives for the same base. PR7 is pinned at `6725c6a17b17871a35353fd29157f4ed851bc114` for the retained producer sources. The old uniform recurrences keep their original exponents. The active consumers use `lem:batched-chunk-swap` and `prop:batched-simultaneous-layer`. + +The stopped product-ring extension is supplied separately in +`notes/stopped-product-note.tex`; it does not regenerate this historical patch. diff --git a/README.md b/README.md index 035c259b68..9aff3ee61b 100644 --- a/README.md +++ b/README.md @@ -3,6 +3,87 @@ **Community research maintained by Douglas Colkitt — conditional on the original OpenAI #109 framework.** +## Three-stage cover extension + +The construction contributed by **icekylinx**, extending +[PR #115](https://github.com/CrocSwap/integer-mult-bounds/pull/115), gives + +$$ +T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=\frac{3146011}{10000000000}=3.146011\times10^{-4}. +$$ + +Three signed shears on a regular Cayley cover align all interstage data +frames. The complex branch combines eumemic's PR #117 local DAG with +arbitrary-subspace Clifford frames; the bit branch retains the PR #97 / +Swapnil physical word and uses a batched weighted q-adic cover. Local +transitions, copied centers, rare-class fallback, finite routers and +internal row borrowing are charged. The retained analytic and fixed-tape +hypotheses still apply. + +[Proof source](notes/three-stage-cover-note.tex) · +[Exact certificate](certificates/three-stage-cover-network.json) · +[Incremental reproduction](docs/three-stage-cover.md) + +```sh +make three-stage-cover-verify +``` + +## Partial-gauge extension + +The construction contributed by **icekylinx**, extending +[PR #104](https://github.com/CrocSwap/integer-mult-bounds/pull/104), gives + +$$ +T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=\frac{7237}{78125000}=9.26336\times10^{-5}. +$$ + +It applies the stopped whole-projector bit interface to the physical deferred +word of Zhihao Chen's PR #97, based on Swapnil Jain's witness. The new complex +producer combines cyclic interval contractions, pair-first cube assembly, +compatible frame enlargement and partial source gauges. Every residual, +endpoint correction and target-data transition is charged. The bound retains +the analytic and fixed-tape hypotheses of the preceding construction. + +[Proof source](notes/partial-gauge-note.tex) · +[Exact certificate](certificates/partial-gauge-network.json) · +[Incremental reproduction](docs/partial-gauge.md) + +```sh +make partial-gauge-verify +``` + +## Stopped product-ring extension + +The new construction contributed by **icekylinx**, extending merged +[PR #36](https://github.com/CrocSwap/integer-mult-bounds/pull/36), gives + +$$ +T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=\frac{194869}{2500000000}=7.79476\times10^{-5}. +$$ + +It combines a stopped product-ring bit interchange on `(23,23)` with an +all-disjoint rational-center complex network on `(24,24)`. The new generic +opposite-bank factorization pays one reversed child per projector rank; +atom adapters, ordinary leaves, endpoint copies and the exact denominator-21 +grid are included in the proof. The bound retains the original analytic +and fixed-tape hypotheses. + +[Proof source](notes/stopped-product-note.tex) · +[Exact certificate](certificates/stopped-product-network.json) · +[Incremental reproduction](docs/stopped-product.md) + +```sh +make stopped-product-verify +``` + +The maintainer-reviewed community checkpoint below remains its own result +and validation record. + +## Reviewed community checkpoint + The reviewed community witness gives $$ diff --git a/SOURCES.json b/SOURCES.json index 6096d5aff9..ab7ec8e74c 100644 --- a/SOURCES.json +++ b/SOURCES.json @@ -234,5 +234,190 @@ } ], "continuing_analytic_dependencies": "See structured_bulk_extension.adopted and references/semantic-bulk/MANIFEST.json." + }, + "stopped_product_extension": { + "contributor": "icekylinx", + "base_commit": "56b66d58297deca1d7dd130247d720e960f77a37", + "proof_predecessor_PR": "https://github.com/CrocSwap/integer-mult-bounds/pull/36", + "proof_predecessor_commit": "11817ccacb564bb7f98789c20dc11d3fece207e3", + "predecessor_merged": true, + "archive": "integer_mult_round5_kappa_7_79476e-5_complete.zip", + "archive_sha256": "714cbffa0cccba3c18f046a63e62d6981683cb386b5d5cd09761be7b70f0b0be", + "kappa": "194869/2500000000", + "proof": "notes/stopped-product-note.tex", + "certificate": "certificates/stopped-product-network.json", + "producer": "scripts/stopped_product_producer.py", + "assistance": "Substantial OpenAI GPT-6 Astra and Codex assistance.", + "scope": "Conditional on the retained analytic and fixed-tape framework; new product-ring and exact rational-grid arguments supplied as written proofs.", + "continuing_dependencies": [ + "copied_centers_extension", + "structured_bulk_extension" + ], + "icekylinx_lineage": [ + { + "pr": 10, + "commit": "62691e395a0458ce089a1c7b5d89e74291e95e29" + }, + { + "pr": 18, + "commit": "f2ab41aebad47861caf6316282c1793e5513845e" + }, + { + "pr": 24, + "commit": "ed90fd940279c336ebc45968631bdebfb087b505" + }, + { + "pr": 32, + "commit": "0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52" + }, + { + "pr": 36, + "commit": "11817ccacb564bb7f98789c20dc11d3fece207e3" + } + ], + "curation": "Selected h23/h24 inputs, generator, exact certificate and proofs only; excludes raw graphs, research alternatives and recursive predecessor copies." + }, + "partial_gauge_extension": { + "contributor": "icekylinx", + "predecessor_pr": 104, + "predecessor_commit": "948ce1510df750f4c18b96bdaef436a86f8bf834", + "archive": "integer_mult_round6_kappa_9_26336e-5_complete.zip", + "archive_sha256": "e701a98b10864dc4b1414d9fcb1fc7c67b28e2363cb2a2292f9fed577a081d2d", + "kappa": "7237/78125000", + "proof": "notes/partial-gauge-note.tex", + "certificate": "certificates/partial-gauge-network.json", + "producer": "scripts/partial_gauge_producer.py", + "assistance": "Substantial OpenAI GPT-6 Astra and Codex assistance.", + "adopted": [ + { + "pr": 97, + "contributor": "Zhihao Chen (jacklightChen)", + "commit": "e15350b66e4bf796153a68c240a6cc1b788abe3e", + "role": "Actual deferred bit word, reflected physical ledger, fan-order clarification, gauged exits and signed endpoint correction" + }, + { + "contributor": "Swapnil Jain", + "repository": "Swapnil-jain/integer-mult-kappa", + "commit": "741e7aa078392553815df7926ee17ac5e25a8c38", + "role": "Underlying deferred readouts, V leaves, lifted frames and frozen witness" + }, + { + "pr": 62, + "contributor": "Avi Eisenberg (ikeboy)", + "commit": "ad0f25ff7b23cff7f08ad237c2254e6ecf74257e", + "role": "Cyclic interval and core-aware pair primitives" + } + ], + "icekylinx_lineage": [ + { + "pr": 10, + "commit": "62691e395a0458ce089a1c7b5d89e74291e95e29" + }, + { + "pr": 18, + "commit": "f2ab41aebad47861caf6316282c1793e5513845e" + }, + { + "pr": 24, + "commit": "ed90fd940279c336ebc45968631bdebfb087b505" + }, + { + "pr": 32, + "commit": "0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52" + }, + { + "pr": 36, + "commit": "11817ccacb564bb7f98789c20dc11d3fece207e3" + }, + { + "pr": 104, + "commit": "948ce1510df750f4c18b96bdaef436a86f8bf834" + } + ], + "continuing_dependencies": [ + "stopped_product_extension", + "copied_centers_extension", + "structured_bulk_extension" + ], + "curation": "Selected generators, exact counts, proof sources and pinned dependencies; excludes alternatives, large generated graphs and recursive handoff copies.", + "scope": "Conditional on retained analytic and fixed-tape framework; finite verification and written proofs have separate scopes." + }, + "three_stage_cover_extension": { + "contributor": "icekylinx", + "predecessor_pr": 115, + "predecessor_commit": "cf60442983c153a3a0f5272ea4713f99eba13c86", + "archives": [ + { + "filename": "integer_mult_round7_kappa_1_080522e-4_incremental.zip", + "sha256": "ba7a7d10be57f614fdb4df4074ec5ffd2feddeac583f1fdf2da12ae7c02f6058" + }, + { + "filename": "integer_mult_round8_kappa_3_146011e-4_incremental.zip", + "sha256": "8e730754c2076bf3ee7ff1bd320486172ef6ab1c9897ddd633aef02a9ce5257a" + } + ], + "kappa": "3146011/10000000000", + "proof": "notes/three-stage-cover-note.tex", + "general_subspace_proof": "notes/general-clifford-frames.tex", + "certificate": "certificates/three-stage-cover-network.json", + "producer": "scripts/three_stage_cover_producer.py", + "assistance": "Construction supplied with substantial OpenAI GPT-6 Astra assistance; repository integration with Codex assistance.", + "adopted": [ + { + "pr": 117, + "contributor": "eumemic", + "commit": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "role": "Pinned positive h24 local DAG and its exact support/label replay; original Claude disclosure retained", + "dag_sha256": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b" + }, + { + "pr": 97, + "contributor": "Zhihao Chen (jacklightChen)", + "commit": "e15350b66e4bf796153a68c240a6cc1b788abe3e", + "role": "Retained physical deferred bit word and reflected ledger" + }, + { + "contributor": "Swapnil Jain", + "commit": "741e7aa078392553815df7926ee17ac5e25a8c38", + "role": "Underlying deferred word, lifted frames and frozen witness" + } + ], + "icekylinx_lineage": [ + { + "pr": 10, + "commit": "62691e395a0458ce089a1c7b5d89e74291e95e29" + }, + { + "pr": 18, + "commit": "f2ab41aebad47861caf6316282c1793e5513845e" + }, + { + "pr": 24, + "commit": "ed90fd940279c336ebc45968631bdebfb087b505" + }, + { + "pr": 32, + "commit": "0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52" + }, + { + "pr": 36, + "commit": "11817ccacb564bb7f98789c20dc11d3fece207e3" + }, + { + "pr": 104, + "commit": "948ce1510df750f4c18b96bdaef436a86f8bf834" + }, + { + "pr": 115, + "commit": "cf60442983c153a3a0f5272ea4713f99eba13c86" + } + ], + "continuing_dependencies": [ + "partial_gauge_extension", + "stopped_product_extension", + "structured_bulk_extension" + ], + "scope": "Conditional on retained analytic, precision, ordinary-leaf and fixed-tape contracts. New general Clifford frames, weighted routing, local-ring fallback and internal row borrowing supplied as written proofs.", + "curation": "Selected round7 PR117 input and frame theorem plus round8 three-stage cover only. Excludes PR112 reclaim, two-stage alternatives, half-sign motif, research screens, raw generated graphs and PDFs." } } diff --git a/certificates/joint-dual-kappa.json b/certificates/joint-dual-kappa.json index d92f653fe4..d721fd7b84 100644 --- a/certificates/joint-dual-kappa.json +++ b/certificates/joint-dual-kappa.json @@ -842,7 +842,7 @@ "scripts/experiments/pin_joint_dual_sources.py": "4d31cc0e38b7902709ca5f8f714cba109760d2592346dd7f8dc0b900a2d9fe00", "scripts/experiments/verify_joint_dual.py": "7a31bba1e9c0ded32ae285df2ca9bc91ef20c330f6789fdba361876f3c7a1985" }, - "source_manifest_sha256": "fd1aab7d75753b4b55b2377f26119dae74f367b0b4fab66cba42d944b3042cc9", + "source_manifest_sha256": "f9a5b92f86b1eee61cb5f867b7a4097c5d4b91c33e618804754cd259f187625a", "sources": [ { "files": { diff --git a/certificates/joint-dual-validation.json b/certificates/joint-dual-validation.json index 99adb4cf74..50fbc39e9a 100644 --- a/certificates/joint-dual-validation.json +++ b/certificates/joint-dual-validation.json @@ -226,7 +226,7 @@ } }, "bit_saving": "2382370177/50000000000000", - "certificate_sha256": "2ed658f05365b28825e24a6e7bac9fc9cc015d5a5d63d9579f4ac6e0640ae559", + "certificate_sha256": "ed18aa80841734755a141d59853b6fc5d8a0e164f0407e368537527480f7f3fe", "kappa": "4764513337/100000000000000", "margins": 7, "producer_words_regenerated_and_matched": true, diff --git a/certificates/partial-gauge-bit-input.json b/certificates/partial-gauge-bit-input.json new file mode 100644 index 0000000000..f01ac32417 --- /dev/null +++ b/certificates/partial-gauge-bit-input.json @@ -0,0 +1,142 @@ +{ + "N": 3136441, + "R": 28866, + "W": 108516254, + "deficit": 1344189, + "dimensions": [ + 23, + 23 + ], + "exit_nullity_histogram": { + "1": 1760, + "10": 96, + "11": 335, + "12": 28, + "13": 116, + "14": 36, + "15": 319, + "16": 5, + "17": 91, + "18": 4, + "19": 164, + "2": 1596, + "20": 83, + "21": 49, + "22": 154, + "23": 17301, + "3": 1307, + "4": 3871, + "5": 806, + "6": 177, + "7": 447, + "8": 30, + "9": 91 + }, + "local_rank_histograms": { + "aux": { + "1": 55349, + "10": 162, + "11": 299, + "12": 208, + "13": 202, + "14": 38, + "15": 649, + "16": 208, + "17": 1309, + "18": 599, + "19": 533, + "2": 64873, + "20": 2310, + "21": 413, + "3": 13926, + "4": 11248, + "5": 6151, + "6": 1617, + "7": 883, + "8": 1243, + "9": 458 + }, + "center": { + "22": 23 + }, + "data": { + "1": 11386, + "10": 86, + "11": 93, + "12": 97, + "13": 65, + "14": 26, + "15": 43, + "16": 218, + "17": 38, + "18": 8, + "19": 1547, + "2": 2402, + "21": 1, + "22": 2, + "3": 1144, + "4": 2013, + "5": 521, + "6": 475, + "7": 276, + "8": 382, + "9": 130 + } + }, + "m": 529, + "max_child": 528, + "rank_mass": 57403754177, + "schema": 1, + "source": "PR97 e15350b66e4bf796153a68c240a6cc1b788abe3e; opposite-bank whole-projector compiler applied to its actual physical idempotent increments.", + "source_manifest": "references/partial-gauge/pr97/SOURCE.json", + "source_manifest_sha256": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "v": 1771, + "whole_projector_histogram": { + "1": 239511811, + "10": 878416, + "11": 1388464, + "12": 1080310, + "13": 945714, + "14": 226688, + "15": 2451064, + "16": 1508892, + "17": 4771074, + "18": 2149994, + "19": 7367360, + "2": 238288050, + "20": 8182020, + "21": 1466388, + "22": 88550, + "3": 53377940, + "4": 46970462, + "484": 6272882, + "5": 23632224, + "506": 61280142, + "507": 545468, + "508": 173558, + "509": 293986, + "510": 580888, + "511": 14168, + "512": 322322, + "513": 17710, + "514": 1129898, + "515": 127512, + "516": 410872, + "517": 99176, + "518": 1186570, + "519": 340032, + "520": 322322, + "521": 106260, + "522": 1583274, + "523": 626934, + "524": 2854852, + "525": 13711082, + "526": 4629394, + "527": 5653032, + "528": 6233920, + "6": 7409864, + "7": 4105178, + "8": 5755750, + "9": 2082696 + } +} diff --git a/certificates/partial-gauge-complex-input.json b/certificates/partial-gauge-complex-input.json new file mode 100644 index 0000000000..b404923928 --- /dev/null +++ b/certificates/partial-gauge-complex-input.json @@ -0,0 +1,101 @@ +{ + "h": 24, + "v": 2024, + "R": 34307, + "q": 8120, + "c": 146284, + "matched": 120097, + "loss": 552, + "selected_roles": 6341, + "selected_rank_histogram": { + "22": 850, + "21": 70, + "20": 770, + "19": 81, + "18": 1503, + "16": 761, + "14": 487, + "12": 406, + "10": 374, + "8": 257, + "6": 294, + "4": 252, + "2": 236 + }, + "remaining_internal_histogram": [ + 27033, + 203910, + 83148, + 13608, + 17316, + 6534, + 5740, + 2708, + 2218, + 787, + 642, + 404, + 288, + 218, + 223, + 1296, + 352, + 1944, + 305, + 1566, + 852, + 188, + 22, + 24, + 0 + ], + "source_data_histogram": { + "23": 2024 + }, + "target_data_histogram": { + "23": 18, + "12": 188, + "11": 4, + "16": 82, + "2": 5576, + "3": 802, + "10": 239, + "6": 641, + "4": 3354, + "8": 634, + "1": 908, + "5": 141, + "7": 82, + "14": 89, + "9": 63, + "13": 2, + "17": 1, + "19": 3, + "18": 8 + }, + "copied_centers_already": true, + "phase1_operations": 32446, + "total_M_operations": 178567, + "untouched_non_source_roles": 8079, + "selection": "Descending first-frame rank; intersect all incident latest target frames; retain maximal nondegenerate summand", + "partial_first_transition_histogram": { + "0": 2241, + "1": 371, + "2": 1793, + "3": 221, + "4": 636, + "5": 150, + "7": 25, + "6": 534, + "8": 259, + "10": 73, + "12": 5, + "9": 29, + "13": 2, + "11": 2 + }, + "distinct_caps": 2278, + "repaired_caps": 369, + "scalar_readout": "Exact rational C=J M; Boolean support is a safe superset only", + "chronological_contract": "Nondeferred reads at0; source V; center-closed M phase1; copied centers at0; selected partial-gauge reads in reverse selection order; remaining M; side scatter; inverse M/V atfull F" +} diff --git a/certificates/partial-gauge-input.json b/certificates/partial-gauge-input.json new file mode 100644 index 0000000000..158600c7e9 --- /dev/null +++ b/certificates/partial-gauge-input.json @@ -0,0 +1,170 @@ +{ + "assembly": { + "absorption_gap": "210905811144819709520320681/5352018951262406227316993998984375000", + "margins": { + "Gaussian_arithmetic": "7615340165060206281200290342476813/54804674060927039767726018549600000000", + "bulk_exposure": "92650807349/1000000000000000", + "compact_phase_layer": "6345945518457246442476813/68505842576158799709657523187", + "coordinate_movement": "92650807349/1000000000000000", + "dimension": "68493150000000000000000000000/68505842576158799709657523187", + "original_prefix": "634663057688300803047390957523187/6850584257615879970965752318700000000", + "scalar_work": "10153992421197191567218839942476813/54804674060927039767726018549600000000" + }, + "minimum_margin": "6345945518457246442476813/68505842576158799709657523187", + "parameters": { + "C0": 316603394779621611419893923923079016464961761204405165715149703864163276249149334956086075455540666229511598112768, + "C1": 1, + "a_bit": "92650807349/1000000000000000", + "a_complex": "92651/1000000000", + "actual_bit_saving": "1240183559/10000000000000", + "alpha_squared_power": "9519260838628478050000000/68505842576158799709657523187", + "beta": "1/1000000", + "c": "463254032112459539899192651/5000000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "68493150000000000000000000000/68505842576158799709657523187", + "eta": "1/100000000", + "kappa": "7237/78125000", + "lambda_": "99990734919357750807349/100000000000000000000000", + "lambda_prime": "49995367459725200807349/50000000000000000000000", + "q": "4632540274799192651/50000000000000000000000", + "sigma": "999907349/1000000000", + "tau": "999907349192651/1000000000000000" + }, + "recurrence": { + "internal": "999907349192651/1000000000000000", + "leaf": "999907349092651/1000000000000000", + "reservations": "4999536745967887540460100807349/5000000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "63464647749247881254316635764014661/1370116851523175994193150463740000000000", + "K_dominates_log": "634594558191670162704927742476813/6850584257615879970965752318700000000", + "K_geometry": "634663057688300803047390957523187/6850584257615879970965752318700000000", + "alpha_below_one": "68496323315320171231607523187/68505842576158799709657523187", + "alpha_below_one_fourth": "68467765532804285797457523187/274023370304635198838630092748", + "alpha_positive": "9519260838628478050000000/68505842576158799709657523187", + "artificial_boundary": "383645411071166612550935367236742476813/54804674060927039767726018549600000000", + "beta_below_one": "999999/1000000", + "beta_positive": "1/1000000", + "bit_positive": "92650807349/1000000000000000", + "bulk_exposure_above_kappa": "17207349/1000000000000000", + "c_below_one": "4999536745967887540460100807349/5000000000000000000000000000000", + "c_positive": "463254032112459539899192651/5000000000000000000000000000000", + "cell_above_band": "68489976684679828768392476813/137011685152317599419315046374", + "compact_leaf": "5092650807349/50000000000000000000000", + "compact_phase_layer_above_kappa": "210905811144819709520320681/5352018951262406227316993998984375000", + "compact_reservations": "4632540274799192651/5000000000000000000000000000000", + "complex_above_bit": "192651/1000000000000000", + "complex_below_one_over32": "31157349/1000000000", + "coordinate_movement_above_kappa": "17207349/1000000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "5350531566967276338766501208504695681/5352018951262406227316993998984375000", + "epsilon_below_one": "12692576158799709657523187/68505842576158799709657523187", + "epsilon_positive": "68493150000000000000000000000/68505842576158799709657523187", + "gamma_sublinear": "3173315320171231607523187/68505842576158799709657523187", + "guard_width": "12692576158799709657523187/68505842576158799709657523187", + "lambda_above_internal": "92650807349/100000000000000000000000", + "lambda_above_sigma": "19357750807349/100000000000000000000000", + "lambda_above_tau": "92650807349/100000000000000000000000", + "lambda_prime_above_lambda": "92650807349/100000000000000000000000", + "lambda_prime_below_one": "4632540274799192651/50000000000000000000000", + "leaf_saving_above_bit": "1/10000000000", + "literal_scalar_guard": "4144494358077648199882179832972772983517776031870487164", + "original_prefix_above_kappa": "1719395050360604223446088341467/171264606440396999274143807967500000000", + "phase_boundary": "7615340165060206281200290342476813/54804674060927039767726018549600000000", + "phase_local": "10153992421197191567218839942476813/54804674060927039767726018549600000000", + "prime_interval_packing": "12692576158799709657523187/68505842576158799709657523187", + "q_below_internal": "92650807349/50000000000000000000000", + "q_below_leaf": "5092650807349/50000000000000000000000", + "q_below_reservations": "4632540274799192651/5000000000000000000000000000000", + "q_positive": "4632540274799192651/50000000000000000000000", + "record_suffix": "12692576158799709657523187/68505842576158799709657523187", + "row_product_gap": "196189/25", + "scalar_work_above_kappa": "126930954152672513404780375764014661/1370116851523175994193150463740000000000", + "short_record_fallback": "68486802878377195389187669443684432762498737/68505842576158799709657523187000000000000000", + "small_field_exposure": "6346630640342463215046374/68505842576158799709657523187" + } + }, + "bit_moment_gap": "2345601674306500121278928059/20544779051332707747863228438542286848", + "complex_children": { + "1": 833199840, + "10": 3566288, + "11": 1651584, + "12": 1926848, + "13": 890560, + "14": 1262976, + "15": 5246208, + "16": 1756832, + "17": 7873360, + "18": 1267024, + "19": 6351312, + "2": 359154752, + "20": 3448896, + "21": 761024, + "22": 89056, + "23": 8363168, + "3": 58331680, + "4": 83672160, + "5": 27020400, + "529": 8193152, + "552": 113206368, + "554": 955328, + "556": 1020096, + "558": 1190112, + "560": 1040336, + "562": 1513952, + "564": 1643488, + "566": 1971376, + "568": 3080528, + "570": 6084144, + "571": 327888, + "572": 3116960, + "573": 283360, + "574": 3440800, + "6": 25830288, + "7": 11293920, + "8": 11544896, + "9": 3440800 + }, + "complex_moment_gap": "6947945558372714213404511085632686811861949217860391879028915309604480988411792203593654326893420995161697220962982459380483297217453126140766882894450707727872135725750714093424451390422155481794610385088421430349919862961400734121438410175507282680663373459309957086540191130088180658275438367642668711397505393879394098039098682461552387767220901721149553580423917366079258626166642510006729132879146700629636588392951851953971879190591805102214143246580666019441282051332500197714419089886096021915668614902179480238040948226365454770137923895463114114185382271238145181098303472869639639530600622478928996375011894122390381864017062683331911338976682281294666432146822560930028375258667985523681323914572020123776804960736030357054532314591192452677528611229466742011541822395019902459/167852999431527138668457861376200612707328488672519882138889232846747479926088857765945414575361982185609633426543097157912490128124910372999225579642156258283421237016089680301794258163909517608838521439800122744227600202644475417848450879443411364263972083620854461752803585992206375722588207612958331938749304200543152875805119794945451095437837541676814955673989171040600685943867630086954353447234398681746181800111132168899079225441657090373821768884273857085436195465138227878901247795252436006727813935800658126959810773997881702000283632464353818559774489796750339762225905607282924984001191963169994170327205763462351020551718167078118315983767319570891176632402601675415585523151673218915561491262533667533095664389192097063006529840051822018304057629587556989230316224000000000000000000000", + "finite_bridge": { + "bit_coarse": { + "W": 108516254, + "halving_degree": 367, + "m": 529, + "maxchild": 528, + "wire_bits": 27 + }, + "complex": { + "W": 147067888, + "coefficient_bound": 28, + "coefficient_denominator_divides": 42, + "halving_degree": 200, + "local_group_upper": 99202668726680, + "m": 576, + "maxchild": 574, + "s": 84709241408, + "scalar_group_upper": 401572403009697216, + "wire_bits": 28 + }, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 15761, + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse", + "degree": 40000, + "degree_gap": "196189/25", + "suffix_slope": 160000 + }, + "semantic": { + "B": 4144494358077648199899551022812574000922568626809480832, + "C0": 316603394779621611419893923923079016464961761204405165715149703864163276249149334956086075455540666229511598112768, + "C1": 1, + "E": 4144494358077648199899551022812574000922568542100239424, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 21, + "induction_gap": 12433483074232944599698653068437722002767705880428442496, + "literal_charge": 17371189839801017404792510229752260, + "strict_literal_gap": 4144494358077648199882179832972772983517776031870487164 + } + } +} diff --git a/certificates/partial-gauge-network.json b/certificates/partial-gauge-network.json new file mode 100644 index 0000000000..fae9fef678 --- /dev/null +++ b/certificates/partial-gauge-network.json @@ -0,0 +1,557 @@ +{ + "assembly": { + "absorption_gap": "210905811144819709520320681/5352018951262406227316993998984375000", + "margins": { + "Gaussian_arithmetic": "7615340165060206281200290342476813/54804674060927039767726018549600000000", + "bulk_exposure": "92650807349/1000000000000000", + "compact_phase_layer": "6345945518457246442476813/68505842576158799709657523187", + "coordinate_movement": "92650807349/1000000000000000", + "dimension": "68493150000000000000000000000/68505842576158799709657523187", + "original_prefix": "634663057688300803047390957523187/6850584257615879970965752318700000000", + "scalar_work": "10153992421197191567218839942476813/54804674060927039767726018549600000000" + }, + "minimum_margin": "6345945518457246442476813/68505842576158799709657523187", + "parameters": { + "C0": 316603394779621611419893923923079016464961761204405165715149703864163276249149334956086075455540666229511598112768, + "C1": 1, + "a_bit": "92650807349/1000000000000000", + "a_complex": "92651/1000000000", + "actual_bit_saving": "1240183559/10000000000000", + "alpha_squared_power": "9519260838628478050000000/68505842576158799709657523187", + "beta": "1/1000000", + "c": "463254032112459539899192651/5000000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "68493150000000000000000000000/68505842576158799709657523187", + "eta": "1/100000000", + "kappa": "7237/78125000", + "lambda_": "99990734919357750807349/100000000000000000000000", + "lambda_prime": "49995367459725200807349/50000000000000000000000", + "q": "4632540274799192651/50000000000000000000000", + "sigma": "999907349/1000000000", + "tau": "999907349192651/1000000000000000" + }, + "recurrence": { + "internal": "999907349192651/1000000000000000", + "leaf": "999907349092651/1000000000000000", + "reservations": "4999536745967887540460100807349/5000000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "63464647749247881254316635764014661/1370116851523175994193150463740000000000", + "K_dominates_log": "634594558191670162704927742476813/6850584257615879970965752318700000000", + "K_geometry": "634663057688300803047390957523187/6850584257615879970965752318700000000", + "alpha_below_one": "68496323315320171231607523187/68505842576158799709657523187", + "alpha_below_one_fourth": "68467765532804285797457523187/274023370304635198838630092748", + "alpha_positive": "9519260838628478050000000/68505842576158799709657523187", + "artificial_boundary": "383645411071166612550935367236742476813/54804674060927039767726018549600000000", + "beta_below_one": "999999/1000000", + "beta_positive": "1/1000000", + "bit_positive": "92650807349/1000000000000000", + "bulk_exposure_above_kappa": "17207349/1000000000000000", + "c_below_one": "4999536745967887540460100807349/5000000000000000000000000000000", + "c_positive": "463254032112459539899192651/5000000000000000000000000000000", + "cell_above_band": "68489976684679828768392476813/137011685152317599419315046374", + "compact_leaf": "5092650807349/50000000000000000000000", + "compact_phase_layer_above_kappa": "210905811144819709520320681/5352018951262406227316993998984375000", + "compact_reservations": "4632540274799192651/5000000000000000000000000000000", + "complex_above_bit": "192651/1000000000000000", + "complex_below_one_over32": "31157349/1000000000", + "coordinate_movement_above_kappa": "17207349/1000000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "5350531566967276338766501208504695681/5352018951262406227316993998984375000", + "epsilon_below_one": "12692576158799709657523187/68505842576158799709657523187", + "epsilon_positive": "68493150000000000000000000000/68505842576158799709657523187", + "gamma_sublinear": "3173315320171231607523187/68505842576158799709657523187", + "guard_width": "12692576158799709657523187/68505842576158799709657523187", + "lambda_above_internal": "92650807349/100000000000000000000000", + "lambda_above_sigma": "19357750807349/100000000000000000000000", + "lambda_above_tau": "92650807349/100000000000000000000000", + "lambda_prime_above_lambda": "92650807349/100000000000000000000000", + "lambda_prime_below_one": "4632540274799192651/50000000000000000000000", + "leaf_saving_above_bit": "1/10000000000", + "literal_scalar_guard": "4144494358077648199882179832972772983517776031870487164", + "original_prefix_above_kappa": "1719395050360604223446088341467/171264606440396999274143807967500000000", + "phase_boundary": "7615340165060206281200290342476813/54804674060927039767726018549600000000", + "phase_local": "10153992421197191567218839942476813/54804674060927039767726018549600000000", + "prime_interval_packing": "12692576158799709657523187/68505842576158799709657523187", + "q_below_internal": "92650807349/50000000000000000000000", + "q_below_leaf": "5092650807349/50000000000000000000000", + "q_below_reservations": "4632540274799192651/5000000000000000000000000000000", + "q_positive": "4632540274799192651/50000000000000000000000", + "record_suffix": "12692576158799709657523187/68505842576158799709657523187", + "row_product_gap": "196189/25", + "scalar_work_above_kappa": "126930954152672513404780375764014661/1370116851523175994193150463740000000000", + "short_record_fallback": "68486802878377195389187669443684432762498737/68505842576158799709657523187000000000000000", + "small_field_exposure": "6346630640342463215046374/68505842576158799709657523187" + } + }, + "bit": { + "counts": { + "N": 3136441, + "W": 108516254, + "child_multiplicities": { + "1": 239511811, + "10": 878416, + "11": 1388464, + "12": 1080310, + "13": 945714, + "14": 226688, + "15": 2451064, + "16": 1508892, + "17": 4771074, + "18": 2149994, + "19": 7367360, + "2": 238288050, + "20": 8182020, + "21": 1466388, + "22": 88550, + "3": 53377940, + "4": 46970462, + "484": 6272882, + "5": 23632224, + "506": 61280142, + "507": 545468, + "508": 173558, + "509": 293986, + "510": 580888, + "511": 14168, + "512": 322322, + "513": 17710, + "514": 1129898, + "515": 127512, + "516": 410872, + "517": 99176, + "518": 1186570, + "519": 340032, + "520": 322322, + "521": 106260, + "522": 1583274, + "523": 626934, + "524": 2854852, + "525": 13711082, + "526": 4629394, + "527": 5653032, + "528": 6233920, + "6": 7409864, + "7": 4105178, + "8": 5755750, + "9": 2082696 + }, + "deficit": 1344189, + "dimensions": [ + 23, + 23 + ], + "m": 529, + "maxchild": 528, + "total_rank": 57403754177 + }, + "exponent": "124984487/125000000", + "logarithm_upper_bounds": { + "1": "1987355562417364065669439618237/316912650057057350374175801344", + "10": "2515274437229490418617839725263/633825300114114700748351602688", + "11": "4909728867822167960512763283247/1267650600228229401496703205376", + "12": "2399714421777289519579293961239/633825300114114700748351602688", + "13": "4697962657128327885574713503543/1267650600228229401496703205376", + "14": "1151004910436491358992364195459/316912650057057350374175801344", + "15": "2258280393397031167285649759463/633825300114114700748351602688", + "16": "2217374245868088984102352158015/633825300114114700748351602688", + "17": "4357897653501964928993364503311/1267650600228229401496703205376", + "18": "4285440755889660536494207989699/1267650600228229401496703205376", + "19": "1054225602598430741931079593279/316912650057057350374175801344", + "2": "3535376905093068344529747466859/633825300114114700748351602688", + "20": "4151880434975661263617415911297/1267650600228229401496703205376", + "21": "4090031554081046933305076849055/1267650600228229401496703205376", + "22": "4031060428338848386894499744017/1267650600228229401496703205376", + "3": "6556765722521218186395115000937/1267650600228229401496703205376", + "4": "6192085370702817115441231394489/1267650600228229401496703205376", + "484": "28174651752060127777810254067/316912650057057350374175801344", + "5": "1477304328485575102713485747439/316912650057057350374175801344", + "506": "28174651752060127777810254067/633825300114114700748351602688", + "507": "13461634359740358047256265827/316912650057057350374175801344", + "508": "51348702935746093527376467017/1267650600228229401496703205376", + "509": "24427890298974148366428397635/633825300114114700748351602688", + "510": "46367751143251427268642011075/1267650600228229401496703205376", + "511": "1371393606332916105007939035/39614081257132168796771975168", + "512": "20703147159790050056693309941/633825300114114700748351602688", + "513": "19466414474504369438193979723/633825300114114700748351602688", + "514": "36464180456598060831658809501/1267650600228229401496703205376", + "515": "8500082529457066293647807479/316912650057057350374175801344", + "516": "3942657414643595698964051979/158456325028528675187087900672", + "517": "7271737386783571020444791587/316912650057057350374175801344", + "518": "13318691203824549237528752541/633825300114114700748351602688", + "519": "24192539605019349297275627047/1267650600228229401496703205376", + "520": "21752402951213312896107403843/1267650600228229401496703205376", + "521": "19316954363029548999871947393/1267650600228229401496703205376", + "522": "16886175861292832110759445655/1267650600228229401496703205376", + "523": "3615012392514444337161355435/316912650057057350374175801344", + "524": "12038557715820072556759192101/1267650600228229401496703205376", + "525": "9621682626735229657445885033/1267650600228229401496703205376", + "526": "901175841480596175664643281/158456325028528675187087900672", + "527": "2400856280154877413264946061/633825300114114700748351602688", + "528": "2398582740651589757065655499/1267650600228229401496703205376", + "6": "1419524320759474653194212865427/316912650057057350374175801344", + "7": "2741344040614642504793860160533/633825300114114700748351602688", + "8": "5313416931219497541822967855259/1267650600228229401496703205376", + "9": "161378412355405628441014735279/39614081257132168796771975168" + }, + "moment_upper": "20544779048987106073556728317263358789/20544779051332707747863228438542286848", + "rank_moment": "1409269/1409302", + "rounding_denominator": 1267650600228229401496703205376, + "saving": "15513/125000000", + "stopped_adapter": { + "atom_exponent": "1/1000", + "base_ordinary_saving": "384599/10000000000", + "coarse_toll_exponent": "999/1000", + "coarse_toll_subordinate_gap": "109487/125000000", + "effective_saving": "1240183559/10000000000000" + }, + "strict_gap": "2345601674306500121278928059/20544779051332707747863228438542286848" + }, + "complex": { + "child_width_multiplicities": [ + [ + 1, + 833199840 + ], + [ + 2, + 359154752 + ], + [ + 3, + 58331680 + ], + [ + 4, + 83672160 + ], + [ + 5, + 27020400 + ], + [ + 6, + 25830288 + ], + [ + 7, + 11293920 + ], + [ + 8, + 11544896 + ], + [ + 9, + 3440800 + ], + [ + 10, + 3566288 + ], + [ + 11, + 1651584 + ], + [ + 12, + 1926848 + ], + [ + 13, + 890560 + ], + [ + 14, + 1262976 + ], + [ + 15, + 5246208 + ], + [ + 16, + 1756832 + ], + [ + 17, + 7873360 + ], + [ + 18, + 1267024 + ], + [ + 19, + 6351312 + ], + [ + 20, + 3448896 + ], + [ + 21, + 761024 + ], + [ + 22, + 89056 + ], + [ + 23, + 8363168 + ], + [ + 529, + 8193152 + ], + [ + 552, + 113206368 + ], + [ + 554, + 955328 + ], + [ + 556, + 1020096 + ], + [ + 558, + 1190112 + ], + [ + 560, + 1040336 + ], + [ + 562, + 1513952 + ], + [ + 564, + 1643488 + ], + [ + 566, + 1971376 + ], + [ + 568, + 3080528 + ], + [ + 570, + 6084144 + ], + [ + 571, + 327888 + ], + [ + 572, + 3116960 + ], + [ + 573, + 283360 + ], + [ + 574, + 3440800 + ] + ], + "counts": { + "L": 2234496, + "N": 4096576, + "W": 147067888, + "child_multiplicities": { + "1": 833199840, + "10": 3566288, + "11": 1651584, + "12": 1926848, + "13": 890560, + "14": 1262976, + "15": 5246208, + "16": 1756832, + "17": 7873360, + "18": 1267024, + "19": 6351312, + "2": 359154752, + "20": 3448896, + "21": 761024, + "22": 89056, + "23": 8363168, + "3": 58331680, + "4": 83672160, + "5": 27020400, + "529": 8193152, + "552": 113206368, + "554": 955328, + "556": 1020096, + "558": 1190112, + "560": 1040336, + "562": 1513952, + "564": 1643488, + "566": 1971376, + "568": 3080528, + "570": 6084144, + "571": 327888, + "572": 3116960, + "573": 283360, + "574": 3440800, + "6": 25830288, + "7": 11293920, + "8": 11544896, + "9": 3440800 + }, + "deficit": 1862080, + "dimensions": [ + 24, + 24 + ], + "m": 576, + "maxchild": 574, + "total_rank": 84709241408 + }, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "999907349/1000000000", + "logarithm_upper_bounds": { + "1": "794513457587/125000000000", + "10": "2026761283851/500000000000", + "11": "1979106193949/500000000000", + "12": "967800252727/250000000000", + "13": "758231660647/200000000000", + "14": "3717050331081/1000000000000", + "15": "1824028729797/500000000000", + "16": "3583518938457/1000000000000", + "17": "22018089479/6250000000", + "18": "8664339757/2500000000", + "19": "341166868153/100000000000", + "2": "707870060017/125000000000", + "20": "1680187693571/500000000000", + "21": "3311585222973/1000000000000", + "22": "1632532603669/500000000000", + "23": "3220613444767/1000000000000", + "3": "1314373843007/250000000000", + "4": "4969813299577/1000000000000", + "5": "2373334874131/500000000000", + "529": "42559614419/500000000000", + "552": "42559614419/1000000000000", + "554": "38942973949/1000000000000", + "556": "17669683223/500000000000", + "558": "6349739663/200000000000", + "560": "28170876967/1000000000000", + "562": "24605810803/1000000000000", + "564": "10526704599/500000000000", + "566": "17513582493/1000000000000", + "568": "559449679/40000000000", + "570": "2617824967/250000000000", + "571": "54490319/6250000000", + "572": "6968669317/1000000000000", + "573": "2610971991/500000000000", + "574": "3478264377/1000000000000", + "6": "1141087047867/250000000000", + "7": "4410197511641/1000000000000", + "8": "4276666119017/1000000000000", + "9": "25993019271/6250000000" + }, + "moment_upper": "167852999424579193110085147162796101621695801860657932921028840967718564616484376777533622371768327858716212431381399936949507668744427075781772453501389375388970529288217544576043544070485066218416365958005512359139178772294555554887050145321972954088464800940191088293493628905666184592500026954682893571106635489145647481925725696906352412976285153909594053952839617460176768577788371460787710937227669548867035099481495580506127373487685211183229963782059713838855529445696945827568747597538016916841717913884989512057631293759840753773918177694215894664311375682564957490987760426184621511131552323639393547848276767087339126429327785214101253300435408231914494351107935243268762962221644843656893505738852343618523644265415292102270499482997289703712865176910028378000849481988458177604980097541/167852999431527138668457861376200612707328488672519882138889232846747479926088857765945414575361982185609633426543097157912490128124910372999225579642156258283421237016089680301794258163909517608838521439800122744227600202644475417848450879443411364263972083620854461752803585992206375722588207612958331938749304200543152875805119794945451095437837541676814955673989171040600685943867630086954353447234398681746181800111132168899079225441657090373821768884273857085436195465138227878901247795252436006727813935800658126959810773997881702000283632464353818559774489796750339762225905607282924984001191963169994170327205763462351020551718167078118315983767319570891176632402601675415585523151673218915561491262533667533095664389192097063006529840051822018304057629587556989230316224000000000000000000000", + "saving": "92651/1000000000", + "strict_gap": "6947945558372714213404511085632686811861949217860391879028915309604480988411792203593654326893420995161697220962982459380483297217453126140766882894450707727872135725750714093424451390422155481794610385088421430349919862961400734121438410175507282680663373459309957086540191130088180658275438367642668711397505393879394098039098682461552387767220901721149553580423917366079258626166642510006729132879146700629636588392951851953971879190591805102214143246580666019441282051332500197714419089886096021915668614902179480238040948226365454770137923895463114114185382271238145181098303472869639639530600622478928996375011894122390381864017062683331911338976682281294666432146822560930028375258667985523681323914572020123776804960736030357054532314591192452677528611229466742011541822395019902459/167852999431527138668457861376200612707328488672519882138889232846747479926088857765945414575361982185609633426543097157912490128124910372999225579642156258283421237016089680301794258163909517608838521439800122744227600202644475417848450879443411364263972083620854461752803585992206375722588207612958331938749304200543152875805119794945451095437837541676814955673989171040600685943867630086954353447234398681746181800111132168899079225441657090373821768884273857085436195465138227878901247795252436006727813935800658126959810773997881702000283632464353818559774489796750339762225905607282924984001191963169994170327205763462351020551718167078118315983767319570891176632402601675415585523151673218915561491262533667533095664389192097063006529840051822018304057629587556989230316224000000000000000000000" + }, + "finite_bridge": { + "bit_coarse": { + "W": 108516254, + "halving_degree": 367, + "m": 529, + "maxchild": 528, + "wire_bits": 27 + }, + "complex": { + "W": 147067888, + "coefficient_bound": 28, + "coefficient_denominator_divides": 42, + "halving_degree": 200, + "local_group_upper": 99202668726680, + "m": 576, + "maxchild": 574, + "s": 84709241408, + "scalar_group_upper": 401572403009697216, + "wire_bits": 28 + }, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 15761, + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse", + "degree": 40000, + "degree_gap": "196189/25", + "suffix_slope": 160000 + }, + "semantic": { + "B": 4144494358077648199899551022812574000922568626809480832, + "C0": 316603394779621611419893923923079016464961761204405165715149703864163276249149334956086075455540666229511598112768, + "C1": 1, + "E": 4144494358077648199899551022812574000922568542100239424, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 21, + "induction_gap": 12433483074232944599698653068437722002767705880428442496, + "literal_charge": 17371189839801017404792510229752260, + "strict_literal_gap": 4144494358077648199882179832972772983517776031870487164 + } + }, + "kappa": "7237/78125000", + "predecessor_commit": "948ce1510df750f4c18b96bdaef436a86f8bf834", + "scope": "Exact moments, stopped bit saving and semantic assembly. Finite producer/frame checks are separate; common-basis, fixed-tape and analytic transfer remain written proof dependencies.", + "source_sha256": { + "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf", + "certificates/partial-gauge-bit-input.json": "367b9844db23f8fa64002637903bcc5ce28ffc8879d274b5c54c0390fb0234e4", + "certificates/partial-gauge-complex-input.json": "ce3c9e3e35a95d1926eee5cc83d020cb7130836e997074378609dbc74e4d9523", + "certificates/partial-gauge-input.json": "f1692977d2d3f59b02d89b4f08a1d56574168139536e5900dc8524b452a57b5e", + "certificates/stopped-product-network.json": "43ddb7ee033d316375102cf2d97bb2cf47f879f36a005d3726fa6647a2cbecc5", + "notes/partial-gauge-assembly.tex": "ef27afc3a70656d3139bf3661ac0b2088622f37221141cc386d41324b7c563d0", + "notes/partial-gauge-construction.tex": "2fcc68553131170c5082707970017f52c1de19a5123b0987f99fc381e543c028", + "notes/partial-gauge-frames.tex": "c27001764091825c99720b7d49e8520d3117fdbef24a8148b5221ddfe822c0b8", + "notes/partial-gauge-note.tex": "0740cc6702d165df899af097afeee6a9060689de808b62ed3e951dc6f2043a95", + "references/partial-gauge/pr62/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "references/partial-gauge/pr62/NOTICE": "95d7dabb54a327216e007f1e0cf37dd2f138ab31527f2cc5ee0de55e87f274ca", + "references/partial-gauge/pr62/PROOF.md": "30685624bf922bb9d9f7ed4b0d367a660fe373cc9ee28fec33585bd8c7023e75", + "references/partial-gauge/pr62/SOURCE.json": "9946b96d382b26e9efc4d87e9b733186c089a4de74289b8f2fffbc9adb59e443", + "references/partial-gauge/pr97/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "references/partial-gauge/pr97/NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f", + "references/partial-gauge/pr97/PROOF.md": "f2c95747d9a5858da43932d857be999e6166d4740f25e2c57f99ce05a8902352", + "references/partial-gauge/pr97/README.md": "6e1729758a88a1e01011054afcb6ea10770bf0a117e3d0b3d019222dbd3b5348", + "references/partial-gauge/pr97/SOURCE.json": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "references/partial-gauge/pr97/bit-ledger-result.json": "c3dd79e5e6d72e49d8d1be2d4d9ad808cd7d24b7a725190d24100cbd3644394a", + "references/partial-gauge/pr97/check_frames.py": "1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8", + "references/partial-gauge/pr97/check_lifted.py": "c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c", + "references/partial-gauge/pr97/deferred-readout.tex": "4e848f7f06c975045629da7cca9f79e10f255d08dc17a72629c9bed522565d52", + "references/partial-gauge/pr97/deferred.py": "9b2acaeb6f1beb2a53c15e00c027f9ba22397a12071ad0b71131e12012a98036", + "references/partial-gauge/pr97/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c", + "references/partial-gauge/pr97/linalg.py": "56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b", + "references/partial-gauge/pr97/round7_literal_frame_ledger.py": "02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59", + "references/partial-gauge/pr97/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588", + "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_triple_circuit.py": "8f5f2de32fdbd8e0005154638660ff416e5a8cd59623bd0dc03f6f7f97ce2fb1", + "scripts/partial_gauge/README.md": "8725c7c0d3b2287904026caea8e94d62c2f66dbbd085e4fd6e5c10933ad9a72f", + "scripts/partial_gauge/__init__.py": "298aa57fbc2de1ff3f9fcfea0fcc02ee7f6758576c52879cb60e9b9c38d471ee", + "scripts/partial_gauge/binary.py": "b29e2f37d7f32a959a378190d7f1da3c2da534fbdaf878044800301957bffc03", + "scripts/partial_gauge/cube.py": "304b653ae6a30f08cee07b5285d48c3793559d63e623bb9bbe8383d8ce68aa24", + "scripts/partial_gauge/interval.py": "c7cf97aa327c92feedfcc098c77d51f3ba8075ccc6f94ecb064bb7a27e44df0a", + "scripts/partial_gauge/lift.py": "895874399113faa090d168d6168f0664136df6e21205671e7f7f9239cad93d1d", + "scripts/partial_gauge/match.cpp": "12b8b7c93bb78324e7328e624b166be2067ae8861540531c024040220d86f368", + "scripts/partial_gauge/scalar.py": "c9fb22e8643ab6d63f7f64ed8143bc5c469794a53e4914cf482e9ad7fcc10cc4", + "scripts/partial_gauge/select.py": "e23f6af42ee5e96d7b2eb29fccf15892f210253a45623255642a62ba93e20cf7", + "scripts/partial_gauge/verify.py": "d31683af845c1de75ac90c0a208b2d335806b6fb346f9960279204812f92bc63", + "scripts/partial_gauge/word.py": "96015b7b08a261673ab8be1ea47f89302f8a1d62a822d657a09f6a1fcfb51e58", + "scripts/partial_gauge_bit.py": "7d58e86061da2d73991531e9bc431589019359391adea866c61c7dd1f99ac855", + "scripts/partial_gauge_network.py": "76b09c4b8f9570766d94b77b265914e4662f8f782e5fa7b4749a1092972b0d68", + "scripts/partial_gauge_producer.py": "8d9284b02ed5915008bfe2e8186ef18f882306192ddd4873b7856341b061305f", + "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782", + "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d" + }, + "status": "Conditional partial-gauge multiplication witness" +} diff --git a/certificates/stopped-product-bit-axis.json b/certificates/stopped-product-bit-axis.json new file mode 100644 index 0000000000..5824891de9 --- /dev/null +++ b/certificates/stopped-product-bit-axis.json @@ -0,0 +1,38 @@ +{ + "h": 23, + "v": 1771, + "c": 34764, + "q": 5336, + "baseline_R": 40100, + "matching": 1324, + "R": 38776, + "loss": 506, + "histogram": [ + 9840, + 38409, + 32471, + 8898, + 9754, + 2116, + 5737, + 1725, + 4145, + 1547, + 3128, + 1551, + 2893, + 1925, + 2841, + 2450, + 2327, + 3096, + 2344, + 3628, + 9435, + 2110, + 23, + 23 + ], + "label_source": "positive", + "description": "Retained-total aligned triple producer, base-two recursion, original maximum carrier matching, and compatible positive labels." +} diff --git a/certificates/stopped-product-complex-input.json b/certificates/stopped-product-complex-input.json new file mode 100644 index 0000000000..7b1d99c518 --- /dev/null +++ b/certificates/stopped-product-complex-input.json @@ -0,0 +1,41 @@ +{ + "h": 24, + "v": 2024, + "c": 45764, + "q": 8120, + "baseline_R": 53884, + "matched": 8966, + "R": 44918, + "orientation_changes": 7338, + "rank_sum": 1079136, + "loss": 552, + "histogram": [ + 8930, + 49042, + 30844, + 15972, + 11883, + 8272, + 6399, + 4356, + 6682, + 2263, + 5109, + 1808, + 5317, + 1733, + 5391, + 1757, + 4908, + 3290, + 6233, + 4363, + 4056, + 264, + 564, + 24, + 24 + ], + "central_disjoint": 24, + "center_denominator": 21 +} diff --git a/certificates/stopped-product-input.json b/certificates/stopped-product-input.json new file mode 100644 index 0000000000..f0a910a495 --- /dev/null +++ b/certificates/stopped-product-input.json @@ -0,0 +1,253 @@ +{ + "bit": { + "dimensions": [ + 23, + 23 + ], + "m": 529, + "N": 3136441, + "W": 143617474, + "L": 1792252, + "total_rank": 75972299557, + "deficit": 1344189, + "maxchild": 506, + "child_multiplicities": { + "1": 139262585, + "2": 115012282, + "3": 31516716, + "4": 34548668, + "5": 7494872, + "6": 20320454, + "7": 6109950, + "8": 14681590, + "9": 5479474, + "10": 11079376, + "11": 5493642, + "12": 10247006, + "13": 6818350, + "14": 10062822, + "15": 8677900, + "16": 8242234, + "17": 10966032, + "18": 8302448, + "19": 12850376, + "20": 33418770, + "21": 7473620, + "22": 12627230, + "484": 6272882, + "506": 137344592 + } + }, + "complex": { + "dimensions": [ + 24, + 24 + ], + "m": 576, + "N": 4096576, + "B1": 90914032, + "B2": 90914032, + "W": 190021216, + "L": 2234496, + "total_rank": 109450358336, + "deficit": 1862080, + "child_multiplicities": { + "552": 181828064, + "529": 8193152, + "1": 202715744, + "2": 124856512, + "3": 64654656, + "4": 48102384, + "5": 33485056, + "6": 25903152, + "7": 17633088, + "8": 27048736, + "9": 9160624, + "10": 20681232, + "11": 7318784, + "12": 21523216, + "13": 7015184, + "14": 21822768, + "15": 7112336, + "16": 19867584, + "17": 13317920, + "18": 25231184, + "19": 17661424, + "20": 16418688, + "21": 1068672, + "22": 2283072, + "23": 16483456 + }, + "maxchild": 552, + "copied_histogram": [ + 8930, + 49066, + 30844, + 15972, + 11883, + 8272, + 6399, + 4356, + 6682, + 2263, + 5109, + 1808, + 5317, + 1733, + 5391, + 1757, + 4908, + 3290, + 6233, + 4363, + 4056, + 264, + 564, + 24, + 0 + ] + }, + "bit_moment_gap": "5833629405069796335513229037/13595148940731587639987765177686687744", + "complex_moment_gap": "5499421901694541095908997425024101371546537414283732387206104389099738183215366564793192567257041780652609318673168302647523216560182242981533611801155442603608986943408777543208667066118724847925169249370145237707441178592436788856344246441565482324551821454604550454953780270300756671351666361036963486701477553679079126088067165335949185500960812006586245961913848693714754073033035419679174118868763905107326417918471742975833959733450001524553321932789312500612407132407690299/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000", + "finite_bridge": { + "bit_coarse": { + "m": 529, + "W": 143617474, + "maxchild": 506, + "halving_degree": 16, + "wire_bits": 28 + }, + "ordinary_leaf_row_degree": 252, + "complex": { + "m": 576, + "W": 190021216, + "s": 109450358336, + "maxchild": 552, + "halving_degree": 17, + "wire_bits": 28, + "scalar_terms": [ + { + "h": 24, + "v": 2024, + "c": 45764, + "invocations": 2024, + "local_group_upper": 408200, + "copied_center_extra_groups": 48 + }, + { + "h": 24, + "v": 2024, + "c": 45764, + "invocations": 2024, + "local_group_upper": 408200, + "copied_center_extra_groups": 48 + } + ], + "scalar_group_upper": 1656684480 + }, + "semantic": { + "E": 403063477262941121443761178688, + "literal_charge": 119639333593035096270287748, + "strict_literal_gap": 402943837929348086347490890940, + "B": 403063477262941121553211537024, + "C0": 2994465792675104952757349965746759652008778122322142627817848832, + "C1": 1, + "induction_gap": 18943983431358232713000942240128, + "fixed_odd_divisor": 21, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding" + }, + "rows": { + "coefficient": 1176, + "degree": 4000, + "suffix_slope": 16000, + "degree_gap": "40024/25", + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse" + } + }, + "assembly": { + "parameters": { + "actual_bit_saving": "803380799/10000000000000", + "a_bit": "1948995551/25000000000000", + "a_complex": "1949/25000000", + "tau": "24998051004449/25000000000000", + "sigma": "24998051/25000000", + "eta": "1/100000000", + "beta": "1/1000000", + "q": "97449775601004449/1250000000000000000000", + "c": "9744977657550220501004449/125000000000000000000000000000", + "epsilon": "124999998750000000000000000000/125019489955217650665401004449", + "lambda_": "2499805100446848995551/2500000000000000000000", + "lambda_prime": "1249902550224398995551/1250000000000000000000", + "alpha_squared_power": "14618091340150667350000000/125019489955217650665401004449", + "delta": "1/800000000", + "C0": 2994465792675104952757349965746759652008778122322142627817848832, + "C1": 1, + "kappa": "194869/2500000000" + }, + "strict_constraints": { + "bit_positive": "1948995551/25000000000000", + "complex_above_bit": "4449/25000000000000", + "complex_below_one_over32": "779301/25000000", + "beta_positive": "1/1000000", + "beta_below_one": "999999/1000000", + "leaf_saving_above_bit": "1/10000000000", + "q_positive": "97449775601004449/1250000000000000000000", + "q_below_internal": "1948995551/1250000000000000000000", + "q_below_leaf": "126948995551/1250000000000000000000", + "c_positive": "9744977657550220501004449/125000000000000000000000000000", + "c_below_one": "124990255022342449779498995551/125000000000000000000000000000", + "q_below_reservations": "97449775601004449/125000000000000000000000000000", + "lambda_above_tau": "1948995551/2500000000000000000000", + "lambda_above_sigma": "446848995551/2500000000000000000000", + "lambda_above_internal": "1948995551/2500000000000000000000", + "lambda_prime_above_lambda": "1948995551/2500000000000000000000", + "compact_leaf": "126948995551/1250000000000000000000", + "compact_reservations": "97449775601004449/125000000000000000000000000000", + "lambda_prime_below_one": "97449775601004449/1250000000000000000000", + "epsilon_positive": "124999998750000000000000000000/125019489955217650665401004449", + "epsilon_below_one": "19491205217650665401004449/125019489955217650665401004449", + "guard_width": "19491205217650665401004449/125019489955217650665401004449", + "K_geometry": "974622765755022147550220501004449/12501948995521765066540100444900000000", + "K_dominates_log": "974497756010044392550224398995551/12501948995521765066540100444900000000", + "record_suffix": "19491205217650665401004449/125019489955217650665401004449", + "phase_local": "15592839154630577103152893798995551/100015591964174120532320803559200000000", + "phase_boundary": "11694348052630578662349334598995551/100015591964174120532320803559200000000", + "gamma_sublinear": "4873113877499998051004449/125019489955217650665401004449", + "cell_above_band": "124995125636122500001948995551/250038979910435301330802008898", + "prime_interval_packing": "19491205217650665401004449/125019489955217650665401004449", + "alpha_positive": "14618091340150667350000000/125019489955217650665401004449", + "alpha_below_one": "125004871863877499998051004449/125019489955217650665401004449", + "alpha_below_one_fourth": "124961017589857047996001004449/500077959820870602661604017796", + "delta_positive": "1/800000000", + "delta_below_one_eighth": "99999999/800000000", + "short_record_fallback": "3124756306320288991609616461252697967793601/3125487248880441266635025111225000000000000", + "small_field_exposure": "9746227754999996102008898/125019489955217650665401004449", + "artificial_boundary": "700128635079475474301789581367398995551/100015591964174120532320803559200000000", + "literal_scalar_guard": "402943837929348086347490890940", + "row_product_gap": "40024/25", + "original_prefix_above_kappa": "786538948061330309871047284761/78137181222011031665875627780625000000", + "coordinate_movement_above_kappa": "305551/25000000000000", + "compact_phase_layer_above_kappa": "20668543364879972849164027819/312548724888044126663502511122500000000", + "bulk_exposure_above_kappa": "305551/25000000000000", + "Gaussian_arithmetic_above_kappa": "97459317411097999618605138287111327/2500389799104353013308020088980000000000", + "scalar_work_above_kappa": "194921594961097960638694118287111327/2500389799104353013308020088980000000000", + "dimension_above_kappa": "312475634452011916691632483971664027819/312548724888044126663502511122500000000" + }, + "margins": { + "original_prefix": "974622765755022147550220501004449/12501948995521765066540100444900000000", + "coordinate_movement": "1948995551/25000000000000", + "compact_phase_layer": "9744977462650669298995551/125019489955217650665401004449", + "bulk_exposure": "1948995551/25000000000000", + "Gaussian_arithmetic": "11694348052630578662349334598995551/100015591964174120532320803559200000000", + "scalar_work": "15592839154630577103152893798995551/100015591964174120532320803559200000000", + "dimension": "124999998750000000000000000000/125019489955217650665401004449" + }, + "minimum_margin": "9744977462650669298995551/125019489955217650665401004449", + "absorption_gap": "20668543364879972849164027819/312548724888044126663502511122500000000", + "recurrence": { + "internal": "24998051004449/25000000000000", + "leaf": "24998051001949/25000000000000", + "reservations": "124990255022342449779498995551/125000000000000000000000000000" + } + } +} diff --git a/certificates/stopped-product-network.json b/certificates/stopped-product-network.json new file mode 100644 index 0000000000..998a8a7ea2 --- /dev/null +++ b/certificates/stopped-product-network.json @@ -0,0 +1,482 @@ +{ + "assembly": { + "absorption_gap": "20668543364879972849164027819/312548724888044126663502511122500000000", + "margins": { + "Gaussian_arithmetic": "11694348052630578662349334598995551/100015591964174120532320803559200000000", + "bulk_exposure": "1948995551/25000000000000", + "compact_phase_layer": "9744977462650669298995551/125019489955217650665401004449", + "coordinate_movement": "1948995551/25000000000000", + "dimension": "124999998750000000000000000000/125019489955217650665401004449", + "original_prefix": "974622765755022147550220501004449/12501948995521765066540100444900000000", + "scalar_work": "15592839154630577103152893798995551/100015591964174120532320803559200000000" + }, + "minimum_margin": "9744977462650669298995551/125019489955217650665401004449", + "parameters": { + "C0": 2994465792675104952757349965746759652008778122322142627817848832, + "C1": 1, + "a_bit": "1948995551/25000000000000", + "a_complex": "1949/25000000", + "actual_bit_saving": "803380799/10000000000000", + "alpha_squared_power": "14618091340150667350000000/125019489955217650665401004449", + "beta": "1/1000000", + "c": "9744977657550220501004449/125000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "124999998750000000000000000000/125019489955217650665401004449", + "eta": "1/100000000", + "kappa": "194869/2500000000", + "lambda_": "2499805100446848995551/2500000000000000000000", + "lambda_prime": "1249902550224398995551/1250000000000000000000", + "q": "97449775601004449/1250000000000000000000", + "sigma": "24998051/25000000", + "tau": "24998051004449/25000000000000" + }, + "recurrence": { + "internal": "24998051004449/25000000000000", + "leaf": "24998051001949/25000000000000", + "reservations": "124990255022342449779498995551/125000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "97459317411097999618605138287111327/2500389799104353013308020088980000000000", + "K_dominates_log": "974497756010044392550224398995551/12501948995521765066540100444900000000", + "K_geometry": "974622765755022147550220501004449/12501948995521765066540100444900000000", + "alpha_below_one": "125004871863877499998051004449/125019489955217650665401004449", + "alpha_below_one_fourth": "124961017589857047996001004449/500077959820870602661604017796", + "alpha_positive": "14618091340150667350000000/125019489955217650665401004449", + "artificial_boundary": "700128635079475474301789581367398995551/100015591964174120532320803559200000000", + "beta_below_one": "999999/1000000", + "beta_positive": "1/1000000", + "bit_positive": "1948995551/25000000000000", + "bulk_exposure_above_kappa": "305551/25000000000000", + "c_below_one": "124990255022342449779498995551/125000000000000000000000000000", + "c_positive": "9744977657550220501004449/125000000000000000000000000000", + "cell_above_band": "124995125636122500001948995551/250038979910435301330802008898", + "compact_leaf": "126948995551/1250000000000000000000", + "compact_phase_layer_above_kappa": "20668543364879972849164027819/312548724888044126663502511122500000000", + "compact_reservations": "97449775601004449/125000000000000000000000000000", + "complex_above_bit": "4449/25000000000000", + "complex_below_one_over32": "779301/25000000", + "coordinate_movement_above_kappa": "305551/25000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "312475634452011916691632483971664027819/312548724888044126663502511122500000000", + "epsilon_below_one": "19491205217650665401004449/125019489955217650665401004449", + "epsilon_positive": "124999998750000000000000000000/125019489955217650665401004449", + "gamma_sublinear": "4873113877499998051004449/125019489955217650665401004449", + "guard_width": "19491205217650665401004449/125019489955217650665401004449", + "lambda_above_internal": "1948995551/2500000000000000000000", + "lambda_above_sigma": "446848995551/2500000000000000000000", + "lambda_above_tau": "1948995551/2500000000000000000000", + "lambda_prime_above_lambda": "1948995551/2500000000000000000000", + "lambda_prime_below_one": "97449775601004449/1250000000000000000000", + "leaf_saving_above_bit": "1/10000000000", + "literal_scalar_guard": "402943837929348086347490890940", + "original_prefix_above_kappa": "786538948061330309871047284761/78137181222011031665875627780625000000", + "phase_boundary": "11694348052630578662349334598995551/100015591964174120532320803559200000000", + "phase_local": "15592839154630577103152893798995551/100015591964174120532320803559200000000", + "prime_interval_packing": "19491205217650665401004449/125019489955217650665401004449", + "q_below_internal": "1948995551/1250000000000000000000", + "q_below_leaf": "126948995551/1250000000000000000000", + "q_below_reservations": "97449775601004449/125000000000000000000000000000", + "q_positive": "97449775601004449/1250000000000000000000", + "record_suffix": "19491205217650665401004449/125019489955217650665401004449", + "row_product_gap": "40024/25", + "scalar_work_above_kappa": "194921594961097960638694118287111327/2500389799104353013308020088980000000000", + "short_record_fallback": "3124756306320288991609616461252697967793601/3125487248880441266635025111225000000000000", + "small_field_exposure": "9746227754999996102008898/125019489955217650665401004449" + } + }, + "base_commit": "56b66d58297deca1d7dd130247d720e960f77a37", + "bit": { + "counts": { + "B1": 68672296, + "B2": 68672296, + "L": 1792252, + "N": 3136441, + "W": 143617474, + "child_multiplicities": { + "1": 139262585, + "10": 11079376, + "11": 5493642, + "12": 10247006, + "13": 6818350, + "14": 10062822, + "15": 8677900, + "16": 8242234, + "17": 10966032, + "18": 8302448, + "19": 12850376, + "2": 115012282, + "20": 33418770, + "21": 7473620, + "22": 12627230, + "3": 31516716, + "4": 34548668, + "484": 6272882, + "5": 7494872, + "506": 137344592, + "6": 20320454, + "7": 6109950, + "8": 14681590, + "9": 5479474 + }, + "copied_histogram": [ + 9840, + 38432, + 32471, + 8898, + 9754, + 2116, + 5737, + 1725, + 4145, + 1547, + 3128, + 1551, + 2893, + 1925, + 2841, + 2450, + 2327, + 3096, + 2344, + 3628, + 9435, + 2110, + 23, + 0 + ], + "deficit": 1344189, + "dimensions": [ + 23, + 23 + ], + "m": 529, + "maxchild": 506, + "total_rank": 75972299557 + }, + "exponent": "49995981/50000000", + "logarithm_upper_bounds": { + "1": "1987355562417364065669439618237/316912650057057350374175801344", + "10": "2515274437229490418617839725263/633825300114114700748351602688", + "11": "4909728867822167960512763283247/1267650600228229401496703205376", + "12": "2399714421777289519579293961239/633825300114114700748351602688", + "13": "4697962657128327885574713503543/1267650600228229401496703205376", + "14": "1151004910436491358992364195459/316912650057057350374175801344", + "15": "2258280393397031167285649759463/633825300114114700748351602688", + "16": "2217374245868088984102352158015/633825300114114700748351602688", + "17": "4357897653501964928993364503311/1267650600228229401496703205376", + "18": "4285440755889660536494207989699/1267650600228229401496703205376", + "19": "1054225602598430741931079593279/316912650057057350374175801344", + "2": "3535376905093068344529747466859/633825300114114700748351602688", + "20": "4151880434975661263617415911297/1267650600228229401496703205376", + "21": "4090031554081046933305076849055/1267650600228229401496703205376", + "22": "4031060428338848386894499744017/1267650600228229401496703205376", + "3": "6556765722521218186395115000937/1267650600228229401496703205376", + "4": "6192085370702817115441231394489/1267650600228229401496703205376", + "484": "28174651752060127777810254067/316912650057057350374175801344", + "5": "1477304328485575102713485747439/316912650057057350374175801344", + "506": "28174651752060127777810254067/633825300114114700748351602688", + "6": "1419524320759474653194212865427/316912650057057350374175801344", + "7": "2741344040614642504793860160533/633825300114114700748351602688", + "8": "5313416931219497541822967855259/1267650600228229401496703205376", + "9": "161378412355405628441014735279/39614081257132168796771975168" + }, + "moment_upper": "13595148934897958234917968842173458707/13595148940731587639987765177686687744", + "rank_moment": "1865129/1865162", + "rounding_denominator": 1267650600228229401496703205376, + "saving": "4019/50000000", + "stopped_adapter": { + "atom_exponent": "1/1000", + "base_ordinary_saving": "384599/10000000000", + "coarse_toll_exponent": "999/1000", + "coarse_toll_subordinate_gap": "45981/50000000", + "effective_saving": "803380799/10000000000000" + }, + "strict_gap": "5833629405069796335513229037/13595148940731587639987765177686687744" + }, + "complex": { + "child_width_multiplicities": [ + [ + 1, + 202715744 + ], + [ + 2, + 124856512 + ], + [ + 3, + 64654656 + ], + [ + 4, + 48102384 + ], + [ + 5, + 33485056 + ], + [ + 6, + 25903152 + ], + [ + 7, + 17633088 + ], + [ + 8, + 27048736 + ], + [ + 9, + 9160624 + ], + [ + 10, + 20681232 + ], + [ + 11, + 7318784 + ], + [ + 12, + 21523216 + ], + [ + 13, + 7015184 + ], + [ + 14, + 21822768 + ], + [ + 15, + 7112336 + ], + [ + 16, + 19867584 + ], + [ + 17, + 13317920 + ], + [ + 18, + 25231184 + ], + [ + 19, + 17661424 + ], + [ + 20, + 16418688 + ], + [ + 21, + 1068672 + ], + [ + 22, + 2283072 + ], + [ + 23, + 16483456 + ], + [ + 529, + 8193152 + ], + [ + 552, + 181828064 + ] + ], + "counts": { + "B1": 90914032, + "B2": 90914032, + "L": 2234496, + "N": 4096576, + "W": 190021216, + "child_multiplicities": { + "1": 202715744, + "10": 20681232, + "11": 7318784, + "12": 21523216, + "13": 7015184, + "14": 21822768, + "15": 7112336, + "16": 19867584, + "17": 13317920, + "18": 25231184, + "19": 17661424, + "2": 124856512, + "20": 16418688, + "21": 1068672, + "22": 2283072, + "23": 16483456, + "3": 64654656, + "4": 48102384, + "5": 33485056, + "529": 8193152, + "552": 181828064, + "6": 25903152, + "7": 17633088, + "8": 27048736, + "9": 9160624 + }, + "copied_histogram": [ + 8930, + 49066, + 30844, + 15972, + 11883, + 8272, + 6399, + 4356, + 6682, + 2263, + 5109, + 1808, + 5317, + 1733, + 5391, + 1757, + 4908, + 3290, + 6233, + 4363, + 4056, + 264, + 564, + 24, + 0 + ], + "deficit": 1862080, + "dimensions": [ + 24, + 24 + ], + "m": 576, + "maxchild": 552, + "total_rank": 109450358336 + }, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "24998051/25000000", + "logarithm_upper_bounds": { + "1": "794513457587/125000000000", + "10": "2026761283851/500000000000", + "11": "1979106193949/500000000000", + "12": "967800252727/250000000000", + "13": "758231660647/200000000000", + "14": "3717050331081/1000000000000", + "15": "1824028729797/500000000000", + "16": "3583518938457/1000000000000", + "17": "22018089479/6250000000", + "18": "8664339757/2500000000", + "19": "341166868153/100000000000", + "2": "707870060017/125000000000", + "20": "1680187693571/500000000000", + "21": "3311585222973/1000000000000", + "22": "1632532603669/500000000000", + "23": "3220613444767/1000000000000", + "3": "1314373843007/250000000000", + "4": "4969813299577/1000000000000", + "5": "2373334874131/500000000000", + "529": "42559614419/500000000000", + "552": "42559614419/1000000000000", + "6": "1141087047867/250000000000", + "7": "4410197511641/1000000000000", + "8": "4276666119017/1000000000000", + "9": "25993019271/6250000000" + }, + "moment_upper": "41230077320013845459152415842612504916449972317779967842837944583272706002177588093256498518568839623389146470329890309678443980458066680615361744505592038651174861744542401102403592424925296971746286402424010119299112624797225649619266545697664266076849080896788535940832502860162094344867655371553013651660399752909560467757989922417605273672796323363623700061058579975817444548637803205602124178954687673277011931480796079125892239408265588698477703420233284596413474059387592867592309701/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000", + "saving": "1949/25000000", + "strict_gap": "5499421901694541095908997425024101371546537414283732387206104389099738183215366564793192567257041780652609318673168302647523216560182242981533611801155442603608986943408777543208667066118724847925169249370145237707441178592436788856344246441565482324551821454604550454953780270300756671351666361036963486701477553679079126088067165335949185500960812006586245961913848693714754073033035419679174118868763905107326417918471742975833959733450001524553321932789312500612407132407690299/41230077325513267360846956938521502341474073689326505257121676970478810391277326276471865083362032190646188250982499628351612283105589897175543987487125650452330304348151388045812369968133964037865011250349179368669257862504666828211703334554008512518414563221340357395437053315115874615168412042904680012697363239611038021437069048505672439008745508864584512067644825937731293242352557278635159598633861792145775836588122497044363982384099548431927704944786606529202786560000000000000000000" + }, + "finite_bridge": { + "bit_coarse": { + "W": 143617474, + "halving_degree": 16, + "m": 529, + "maxchild": 506, + "wire_bits": 28 + }, + "complex": { + "W": 190021216, + "halving_degree": 17, + "m": 576, + "maxchild": 552, + "s": 109450358336, + "scalar_group_upper": 1656684480, + "scalar_terms": [ + { + "c": 45764, + "copied_center_extra_groups": 48, + "h": 24, + "invocations": 2024, + "local_group_upper": 408200, + "v": 2024 + }, + { + "c": 45764, + "copied_center_extra_groups": 48, + "h": 24, + "invocations": 2024, + "local_group_upper": 408200, + "v": 2024 + } + ], + "wire_bits": 28 + }, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 1176, + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse", + "degree": 4000, + "degree_gap": "40024/25", + "suffix_slope": 16000 + }, + "semantic": { + "B": 403063477262941121553211537024, + "C0": 2994465792675104952757349965746759652008778122322142627817848832, + "C1": 1, + "E": 403063477262941121443761178688, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 21, + "induction_gap": 18943983431358232713000942240128, + "literal_charge": 119639333593035096270287748, + "strict_literal_gap": 402943837929348086347490890940 + } + }, + "kappa": "194869/2500000000", + "proof_predecessor_commit": "11817ccacb564bb7f98789c20dc11d3fece207e3", + "scope": "Exact finite moments, stopped savings and assembly; the new complex producer is checked separately. Opposite-bank factorization, atom streaming, ordinary conversion, common exact grid and retained analytic/tape interfaces are written proof dependencies.", + "source_sha256": { + "certificates/copied-centers-bit-axes.json": "ed307cef595091b11ba8f8e6ff11302ad8db190227a2fbf34c232fd680206254", + "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf", + "certificates/stopped-product-bit-axis.json": "52f493a0019b7e4ce69a4c26bd3d35af5d3397461126abc4be44d1430ae8930d", + "certificates/stopped-product-complex-input.json": "5bcf00402bbfb768bd2fc0935f32ad329ee0780a3dfe5827bb010831d7909c4d", + "certificates/stopped-product-input.json": "8185c7bf8c307728f32484c5972af9a1b948ac5d0838e02f85c86cb438060417", + "notes/stopped-product-assembly.tex": "1c3c7147851f30f1ff97679cfcda157b1cbe2655b8766e34f1345f20c630eaec", + "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "notes/stopped-product-factorization.tex": "70d5a4405e1be9c7b6cfb326bb4ffdf88e5585d1fb3d16c7bb5ad62ac421fae3", + "notes/stopped-product-interface.tex": "454a8f3924afc26e575b2a8cec6d0860397cb7f2dc431f3ba63fb8a7142cc96b", + "notes/stopped-product-note.tex": "486d14c599f4c2551c019f3358898f72e6ecafeb04ad590726ea69ed987fe025", + "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d", + "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9", + "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782", + "scripts/stopped_product/README.md": "6c1805dda45b01ed0ef420c674ec2cd0048fb9d7a1b015ab6cd837067fe66176", + "scripts/stopped_product/__init__.py": "7b794c22bccc00bb6ae8ba4d3379f469570565bbcb1a86090699133b8cf1b7d3", + "scripts/stopped_product/complex.py": "407650d56dceb5cb09d74928658cebed1bb42f4d7e28ca9e3fd36eea075f1ad0", + "scripts/stopped_product_network.py": "a8baaa87dd7679db4f2dd1a18a720397ee6f443262ad04fa26cf51b39909b74c", + "scripts/stopped_product_producer.py": "2c5c71399136ebcfebb8e5277317d5f334eb8df5716ad287391d0996fcc1492c", + "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d" + }, + "status": "Conditional stopped product-ring multiplication witness" +} diff --git a/certificates/three-stage-cover-bit-input.json b/certificates/three-stage-cover-bit-input.json new file mode 100644 index 0000000000..1956ae0e06 --- /dev/null +++ b/certificates/three-stage-cover-bit-input.json @@ -0,0 +1,84 @@ +{ + "R": 28866, + "center_loss": 506, + "description": "Unchanged exact physical local ranks from the previously adopted PR97 bit producer; the new construction changes ambient geometry, finite cover, and recursive weighted routing only.", + "exit_nullity_histogram": { + "1": 1760, + "10": 96, + "11": 335, + "12": 28, + "13": 116, + "14": 36, + "15": 319, + "16": 5, + "17": 91, + "18": 4, + "19": 164, + "2": 1596, + "20": 83, + "21": 49, + "22": 154, + "23": 17301, + "3": 1307, + "4": 3871, + "5": 806, + "6": 177, + "7": 447, + "8": 30, + "9": 91 + }, + "h": 23, + "local_rank_histograms": { + "aux": { + "1": 55349, + "10": 162, + "11": 299, + "12": 208, + "13": 202, + "14": 38, + "15": 649, + "16": 208, + "17": 1309, + "18": 599, + "19": 533, + "2": 64873, + "20": 2310, + "21": 413, + "3": 13926, + "4": 11248, + "5": 6151, + "6": 1617, + "7": 883, + "8": 1243, + "9": 458 + }, + "center": { + "22": 23 + }, + "data": { + "1": 11386, + "10": 86, + "11": 93, + "12": 97, + "13": 65, + "14": 26, + "15": 43, + "16": 218, + "17": 38, + "18": 8, + "19": 1547, + "2": 2402, + "21": 1, + "22": 2, + "3": 1144, + "4": 2013, + "5": 521, + "6": 475, + "7": 276, + "8": 382, + "9": 130 + } + }, + "source": "PR97 e15350b66e4bf796153a68c240a6cc1b788abe3e; matched to source-bound physical paths by partial_gauge_bit.reconstruct.", + "v": 1771 +} diff --git a/certificates/three-stage-cover-complex-input.json b/certificates/three-stage-cover-complex-input.json new file mode 100644 index 0000000000..d1b89bcb71 --- /dev/null +++ b/certificates/three-stage-cover-complex-input.json @@ -0,0 +1,115 @@ +{ + "h": 24, + "v": 2024, + "R": 28705, + "q": 8120, + "c": 91770, + "matched": 71185, + "loss": 552, + "selected_roles": 4599, + "selected_rank_histogram": { + "22": 120, + "21": 359, + "20": 794, + "19": 174, + "18": 381, + "17": 147, + "16": 409, + "15": 57, + "14": 157, + "12": 218, + "13": 57, + "11": 131, + "10": 190, + "7": 100, + "8": 187, + "9": 113, + "5": 126, + "6": 137, + "4": 126, + "3": 181, + "2": 184, + "1": 251 + }, + "remaining_internal_histogram": [ + 26680, + 69592, + 67235, + 29094, + 30564, + 11421, + 4563, + 2083, + 2592, + 1678, + 937, + 710, + 794, + 435, + 479, + 172, + 281, + 197, + 755, + 540, + 85, + 0, + 183, + 24, + 0 + ], + "source_data_histogram": { + "23": 2024 + }, + "target_data_histogram": { + "1": 1907, + "3": 1772, + "18": 23, + "4": 1500, + "15": 36, + "13": 70, + "2": 3107, + "11": 148, + "6": 695, + "5": 876, + "12": 168, + "19": 20, + "14": 81, + "9": 235, + "7": 426, + "10": 202, + "23": 14, + "8": 269, + "17": 14, + "16": 79, + "22": 4, + "21": 2, + "20": 16 + }, + "copied_centers_already": true, + "phase1_operations": 30251, + "total_M_operations": 118451, + "untouched_non_source_roles": 6401, + "selection": "Full unrestricted intersections and source gauges; descending first-frame rank, then reached-target count, then role index; general_clifford_subspace_frames.txt proves all required ranks", + "partial_first_transition_histogram": { + "0": 1425, + "1": 572, + "2": 536, + "3": 176, + "4": 274, + "6": 214, + "5": 205, + "7": 150, + "9": 244, + "8": 170, + "11": 185, + "10": 178, + "12": 157, + "13": 109, + "14": 4 + }, + "distinct_caps": 1792, + "repaired_caps": 0, + "scalar_readout": "Exact rational C=J M; Boolean support is a safe superset only", + "chronological_contract": "Nondeferred reads at0; source V; center-closed M phase1; copied centers at0; selected partial-gauge reads in reverse selection order; remaining M; side scatter; inverse M/V atfull F" +} \ No newline at end of file diff --git a/certificates/three-stage-cover-input.json b/certificates/three-stage-cover-input.json new file mode 100644 index 0000000000..4277c8ee2c --- /dev/null +++ b/certificates/three-stage-cover-input.json @@ -0,0 +1,105 @@ +{ + "absorption_gap": "427438661618132345110228739011/125078699795119603047628520369990000000000", + "assembly_minimum": "3934989696955306336847963001/12507869979511960304762852036999", + "bit_child_multiplicities": { + "1": 200205, + "10": 744, + "11": 1176, + "12": 915, + "13": 801, + "14": 192, + "15": 2076, + "16": 1278, + "17": 4041, + "18": 1821, + "19": 6240, + "2": 201825, + "20": 6930, + "21": 1242, + "22": 75, + "3": 45210, + "4": 39783, + "44": 51903, + "45": 462, + "46": 147, + "47": 249, + "48": 492, + "49": 12, + "5": 20016, + "50": 273, + "51": 15, + "52": 957, + "53": 108, + "54": 348, + "55": 84, + "56": 1005, + "57": 288, + "58": 273, + "59": 90, + "6": 6276, + "60": 1341, + "61": 531, + "62": 2418, + "63": 11613, + "64": 3921, + "65": 4788, + "66": 5280, + "7": 3477, + "8": 4875, + "9": 1764 + }, + "bit_moment_gap": "9940153528978648563021016615239768808198774866649/15679126900749033641597254460382631690240000000000000000", + "complex_child_multiplicities": { + "1": 214497, + "10": 3417, + "11": 2574, + "12": 2886, + "13": 1515, + "14": 1680, + "15": 624, + "16": 1080, + "17": 633, + "18": 2334, + "19": 1680, + "2": 211026, + "20": 303, + "21": 6, + "22": 561, + "23": 6186, + "3": 92598, + "4": 96192, + "46": 72318, + "47": 753, + "48": 552, + "49": 543, + "5": 36891, + "50": 378, + "51": 378, + "52": 411, + "53": 300, + "54": 561, + "55": 339, + "56": 570, + "57": 393, + "58": 654, + "59": 171, + "6": 15774, + "60": 471, + "61": 171, + "62": 1227, + "63": 441, + "64": 1143, + "65": 522, + "66": 2382, + "67": 1077, + "68": 360, + "7": 7527, + "8": 8583, + "9": 5739 + }, + "complex_group_order": 6689091708829555045758824829998182442380949567092062603242444969909078551334138157882363702009196947404919488369449744746991926866237084072342349052621959272314109341860982597079245951051060915136612492730495464103716652777049004952774932308881916158490684984763171132527532852346752575317647723807415492585356459791712931903073469266911277499226776278127225601421860692008492054366318924455033501842970829052238301059912292523870500029776308231873343329850749563566739947724729692531852159045336304497880188189155544256335559916592125266647930688623519281982850918244666405377532274750402883540845161453986633761588402168669904233211290018920284019914861652664495645151328501875434571709289695239534437990400000000000000000000, + "complex_moment_gap": "59660505965587856912406691094331138186546269153644104866458597552665571068577116382634727949704110939016528739306556665498819711235700737563102396203975205221339133504724694432491851145335328474764447111340057237370263560869716809394705046078151888885896465104252464291177722544058434227599509153650009184180706030887062493946461013321850105545236094560014790613346572797863224674797577418235580531379991780630697040554957397988009682182045601295362730851922874373402414598770202370029517008428953007230108852814349067642665708147118783306275789878773811811445256495511373788061555564732214081272243700795208443535449470081033281653673439322265496376162021685578206559390236098486450856162033470234056213985410270945906907471137066433711096177567495215981265605045461916455727272303712611652753551670063284645382934158696277492599602169286405620938102814288075749650451212554459344538961569338671639261965819931295434033557288521941097120781270873/258864312882296500031055289607308876918948194191739080393665208773437327950361705506204269262727624369607191381066070736950721387722343455305319397218060826215806055566676458467985854943815840460405474061110154037491708121904679791617548836252416330123113259519318454367469789088759143697885963048633822970601575393057295335974413285977207878402333467407939617985467006958820688402850530703846606121734476356557987835722081138227469842662438908972992927393171772790668096312894309081073575846448722623251554492048017857602287936132027784462360677641358992824901206117953947391105954258456029157280133485124255285284951748169636791141814335580522461373398332705279009190357387940809475590086743023351702184232232736981858998991300824787343216349598086601789879924718839538480440090437137911672142043373939595769029469714536428078367503524111596722215987131151839686520104495974436734700813521784031923667417309936799035132679343460868275000000000000000000000", + "kappa": "3146011/10000000000", + "row_coefficient": 68505, + "row_degree": 160000 +} diff --git a/certificates/three-stage-cover-network.json b/certificates/three-stage-cover-network.json new file mode 100644 index 0000000000..5fcdaf7420 --- /dev/null +++ b/certificates/three-stage-cover-network.json @@ -0,0 +1,592 @@ +{ + "assembly": { + "absorption_gap": "427438661618132345110228739011/125078699795119603047628520369990000000000", + "margins": { + "Gaussian_arithmetic": "4722025175696264927919695237147963001/10006295983609568243810281629599200000000", + "bulk_exposure": "786997963001/2500000000000000", + "compact_phase_layer": "3934989696955306336847963001/12507869979511960304762852036999", + "coordinate_movement": "786997963001/2500000000000000", + "dimension": "12499999875000000000000000000000/12507869979511960304762852036999", + "original_prefix": "393511477565510145645101062952036999/1250786997951196030476285203699900000000", + "scalar_work": "6296071101698264298321324836347963001/10006295983609568243810281629599200000000" + }, + "minimum_margin": "3934989696955306336847963001/12507869979511960304762852036999", + "parameters": { + "C0": 3069616589847390661646422921084421742076791020252975349036054045022876868816325360016884006766783194275238402685467560897379979538095659339914153411228923909333095982797289674916529618429267783546451504270618482414638463624294728177966618130024107087751376653321734853189117093266202030762618889547070961502205714597092709896013907425368392094475384221634319478984386904866724573994626804450216944973924004715129813965761596933326115776509943340157943174129272539823538050701622535963394690012758192847459689849972234337123874693385824686036508296575317079188160243598118725757652458188392322022844952575356424395442848095001566387040343856569269189917395657957736197073257203779373376889188640167448301868942509481176151204589988645494367063387585216101009063950625330703064826114491278166377864559802175046525033303468905874332453558086400872719885643863720883286117067041921620953698342288655741970429273531809582230991868701944130291351470030436263467358890906695434168397182790713738221001251836143805627527705706423299121278974890542200636743526283452050476661223881388407442978243431669478604808233403509060869050122348252528508652514546190870356725140776540043842433519776101118663309008418821694162806975376395055996154862940347526503831995965890962095517246160505917385844418501289372312929895261433044238853159640873178296074691588108407208060312941030713075650949796819720623617274671433189514444530605570317109481285852874851994767235546746412816105225612917279997364398814260806978260442672433634877529433763342817839622416123929066317965684395720963995844612459772496852858136114495501553052875918890493437720817467401959927795563460985161443838370327267773319262197676970128601037750371606747882081864991899478768652753719460664740703974322244254178850702689621313279552404919356570149678532057847416870830584864207747262934507734636621850863249283092432101857929907404597235734821317451725043998173780050102022316333191629802847635970200654831305961679321884238323949323545700727495913214847967853940828265964698218756505631346237825273777434498391411473506381159325514613731928748097685882747312386889119756084378600903991571078005055042046094316492423199198926541204285844748101819694175439766391894760923482807755851157024426217957400485561625345998966386010259637345603116709342194670474158578691919955704515843909721332395326584625955397922042204666852937101704587600533643647978023445793085383805879506200290001133205268542865652521678471024305612952671381449711629060543192466777247816868331366012703319698246037145296320423161788616663091652318823857575904196794797964398167338610177904877137492559370005420422792916547825887244857506972903189722341454322372425992499266566928072634528989945774494027467883853578920359196688045291344841920146816451269469235508593645730320230041166006942477439187092034202141157249063205216148696106347944143180271913682251003020961975747460268264152990294154845602977001034546573868730840030306106083066615893411507070172306418205365347514388388797818280149907416885905694557490327243356351213517064048360368083743926444159596486796654971962837266376087696736036630821397057759265435399001034219784548534301293246968481718896940728916586643216813696276995906818516031447282486976508491296289704612599444701418962843899412141286241116524383330689501164812645733598962642697378754768940828667023559332287032297181065740336402086342631379249524918280111183002518810569745674270883218352487398164117312518791310058222635531090696166659589283706956329197255219124344464109810607181914334024182373262741496913565784599455831294271786971532656044956865808927363230230333221117048299138478722770262564293401048323295690290576665049283594774564952983008328199450553465438747989935270451017153656365432531286748212897865565389174479692626368044817794835214853612348369456354164208860180288069919602131366281198492282525758164785175498335196238660843356185405464740133677928165863349772663124722360548211575171143108705321242747390208190455654032110752116075685358288616340116422198197003816643938163895854910801612506007028467740158364494675391779674117452943972234067245950780672757641835401762457813591085466472610760081694796364038455190850128858452726179344290731902979976155980178379086308794363749154375086244054353599953429957191632533404966135293427500650680626153605182642974405654605481434633806516552904430515471895807265037937668023677087429584949287059182611670560401700700017559374074319372739896109330961864733696592468618981296359696294503303358287423679181319508447833826703479290840941996672425175155521850976626815339256699939699024495134291200127894497828867785423243804361641141890614907969840399371178577763175489888290853519406409284426091492125845694430414786261517542690667830803552935505127879841490640594516473577535926907627698561130284717948267721725142670780954498243227867071651455284864010313916190216822966036405047107841054379533193963821395300030937635313039095961018619372045254622793379697689190925399960112892996991372336228690526514452230046164243049324160650581489248498500222753929695227387754386736440672728913118007774421009513295474455754364427533757831243295844710153706155070205909786228273972241529724104831779415023593765443975150793497820325243216093304681631402883418607554772638433704245678459883754743033745471774652338069116962895044695078686700345123049398507532493117764465922346580451143760984511302902981585134883827184510924906168237887159079675861767203290544665283031999497569196460493279382670817562203517598895210872352131152416726458789284102791986449492927809839090958584834275931170340360223550461701875498695258246098405728247328299409849521530984187679500797631982947884322803334600336640944451479355279962252221365803036612322834250440378838042973627611346346410854820147081053422165287359392144428924191577141110190356684154737790356559946358034320252924025437779851896882413629999493544862285292894044387815136197600402988751484543814749942284135745572486194981299872333341135624996173257514734626282063753231786816608227234776158060632003953104843780400337333260255864971865777127469201460859296674057408680269498549354590278046876148727941310202872912455674670533789863533029022169344424734365284287718190320177071534495772894370418338875123924491939556994692699881062472213584470276688679269148693894614969512596832727697762383836323100635728643771561802166985245437719618051192366607811242236996441689783585111902921696218444327698412739754761822433880837714238306908525912988329448663035458632195302481700045036959155396196236372066787792484509384384116474295222519883964470607396091587053756737832709585568331499654462614637079446418700364557528774701544907496792566061820917895585315031000913645970862233845370066562511481435508765949780756683491741750164653540069286344097126924143802863871779902290652059933085944629227727379408610025190800441296391906569513444994575126455593618267089467077827689732185269985079250319050076679453958934753744707007843823199510595879943330589299764820420085432240331515162141898514877775243105544504151899071862772251461445672747157367616055221204376870984757008164127865557093758931769160076096215883956485086634736788461990450409274051424488467778490841549841838379565387168414889221154325025923132489877617360674665439019065069536737526647995524603455961995829657709671871770971415869698449901037548861523639788538732019202410821869045247466022119269396873591901406501589466809011902113955944725931364985630260453207476044034314004728636469219193474412319169770242296001006322755471886187578722990029593301923214086469716417189708220507257480840631914486428036131029664266274054070774371908752523409123144852155288278515225447523155701970783062233545883414442554327153746583643906023363416916232392701827354121176877492838992440456164956179679443358539411221388963087058808445177118325775350312048733693358445116287887906606192536786225381289786497145312046361460760019755194835609268558177972799557297732412590508021286017552247345369421374698764558857788409156279929776872019178670914575258679644397927621365061627875356309930460839454975253784491950036961236504090374835903791529034088939005854961632766099386794358822295032891931730751727882738952839441412450491375781893151942344499288563967508918805392482653859015539304277916411077179137787165223790825601340401865299032334835346931478942739645108890462644437264408838886181985653244650945322080486048022815520910895177446529767723794159272835895952498245955570160616918096072192578199775204360236370243324892515167436333710103460833047971241733773567733079897717161610311543709521110070348559091682672244048258383086829662723791604182578271717814290366206438124002127827311226746288432087162447106404908864366021832107425929452521322690566872310257132832850634488314703996264159602039324672001175325228986531840, + "C1": 1, + "a_bit": "786997963001/2500000000000000", + "a_complex": "786999/2500000000", + "actual_bit_saving": "3731649599/10000000000000", + "alpha_squared_power": "5902547104457805549850000000/12507869979511960304762852036999", + "beta": "1/1000000", + "c": "3934989775655101062952036999/12500000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "12499999875000000000000000000000/12507869979511960304762852036999", + "eta": "1/100000000", + "kappa": "3146011/10000000000", + "lambda_": "249921300204486897963001/250000000000000000000000", + "lambda_prime": "124960650102636947963001/125000000000000000000000", + "q": "39349897363052036999/125000000000000000000000", + "sigma": "2499213001/2500000000", + "tau": "2499213002036999/2500000000000000" + }, + "recurrence": { + "internal": "2499213002036999/2500000000000000", + "leaf": "2499213001786999/2500000000000000", + "reservations": "12496065010224344898937047963001/12500000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "39350836308177819697297811129156553047/250157399590239206095257040739980000000000", + "K_dominates_log": "393498973630520330640102636947963001/1250786997951196030476285203699900000000", + "K_geometry": "393511477565510145645101062952036999/1250786997951196030476285203699900000000", + "alpha_below_one": "12501967432407502499213002036999/12507869979511960304762852036999", + "alpha_below_one_fourth": "12484259791094129082563452036999/50031479918047841219051408147996", + "alpha_positive": "5902547104457805549850000000/12507869979511960304762852036999", + "artificial_boundary": "70051942002294677970340694361629947963001/10006295983609568243810281629599200000000", + "beta_below_one": "999999/1000000", + "beta_positive": "1/1000000", + "bit_positive": "786997963001/2500000000000000", + "bulk_exposure_above_kappa": "495213001/2500000000000000", + "c_below_one": "12496065010224344898937047963001/12500000000000000000000000000000", + "c_positive": "3934989775655101062952036999/12500000000000000000000000000000", + "cell_above_band": "12498032317592497500786997963001/25015739959023920609525704073998", + "compact_leaf": "13286997963001/125000000000000000000000", + "compact_phase_layer_above_kappa": "427438661618132345110228739011/125078699795119603047628520369990000000000", + "compact_reservations": "39349897363052036999/12500000000000000000000000000000", + "complex_above_bit": "1036999/2500000000000000", + "complex_below_one_over32": "77338001/2500000000", + "coordinate_movement_above_kappa": "495213001/2500000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "124960648853457885598249652715100228739011/125078699795119603047628520369990000000000", + "epsilon_below_one": "7870104511960304762852036999/12507869979511960304762852036999", + "epsilon_positive": "12499999875000000000000000000000/12507869979511960304762852036999", + "gamma_sublinear": "1967557407502499213002036999/12507869979511960304762852036999", + "guard_width": "7870104511960304762852036999/12507869979511960304762852036999", + "lambda_above_internal": "786997963001/250000000000000000000000", + "lambda_above_sigma": "104486897963001/250000000000000000000000", + "lambda_above_tau": "786997963001/250000000000000000000000", + "lambda_prime_above_lambda": "786997963001/250000000000000000000000", + "lambda_prime_below_one": "39349897363052036999/125000000000000000000000", + "leaf_saving_above_bit": "1/10000000000", + "literal_scalar_guard": "37018435259192327026444362697176328284448078188231769953782205265560458994954198528128522271608574408355202540032255075117064968824327990197877830058875685381240368807405458918509373120982313431379572812796500814090858418296308982119821986030880818153842771889364723831622819356875189083770091903009992093953323267345008324543448535299659232847137164228817520156965454222496076346048075753934240004585336040743460323739361513753754219231885274556219650061408475985021071528358092463203549452302568664686135139295765432027153560598461589972523219970876048764263605385072846558138979410695263283436723795819749936298869629733885754380405293552951554248018338523862933278110049131111792477888007451534133694519797648709286837681549558235135639856222074605338489634655222341780048039966324013624302401090391595011077462555282587702669950720510047572110720022355583945737902393191417530355904864684514686083589233558409810569331377416983922386607960310165879036875161816637415611719601268127301986956088110556032607981930143972637860354756134494817601720717816880540330187822876112155436889663728626881438010883134476724020941093051927869881849985320024654243039856782905204990852015879595315962469380186943323565847050823297875741422603094472816484242240290243785520650512759964482686389175876608814679832488395605198592550183523227695326324405319213918836405829163433288721516691592464401780426918678712678566359382403598736803437089218194416547260565798719016237368522780663398147465400130525366093703741153740730666672158438685624352457229021962356229991191971318250920523218185693476105896703551775079542651896161265452199617211795522315929907395646527332413263943754129801436466974319834702834072148919264322454081750459895475104477616536838609829420698827304059941887830596458619634732807170576059221246507964888591019719797977539125941493193476568826575828467201554976985703195363813249443799091278368748023122746507243838701185788551895097555187799176505405330217221523438858770052561823484243062349027928194253313455936658290883075034994234670841334101876830842757559875559785336960995294225025590711035228135715921835886479635214597044456866850641935907674619887709756631997146089910706105350614066107662518278864879078188609934306561154439203820186577007063758335054868208097470677896322479230149468893532920886668062046508519338037367702546481906692666534263700579701097157684099440794072091751714916491351936398854188449078419239417576461940728251552665219271320031154864381081914286291446246407441412171120042675281401724510399879895551454109193833265775908426675338096712656946983397691325305991205325165437456433627793426115761717609823074027689024003258169697020781485149270323046705251108133559317163509160494936490719880315622808741104659691804694263424745347948804844535684592161072178886408741907438665899219084153326729659784189422120582613568611407111418747440942411997716486816008687947347765812981882029770967649609304814257180276768416178149729458451330956062884565286164625455908958003442623533507241840102403093505521093700581039327710259936108131519905723542645029376329370971230633299970846618310572688589209680410651838061589834725176701167511666867782761633723916061554499683831056078563875792795993435548942675754189912394664546776145094572633171346066631085860271623253147163049507137690906363879067117671882203031623686095154460524172675004074207470453267380396304129512273194827030030553734150726595395015555596412449195293143373754000470998909453484271698682840929769299525446336900245904959922214867236693272916644266224842367646165671888546176391688697464242473480563119282532994914118560530044282929092777092289297295282886335522645860631236865508320125629737964467760319515557023637159161157301387534028123269363779244538560277100181942752370716193293888169754073184110973259752294932453668403358688600730922141150108767150340928525165073926854276429979916485628800415665926169988981061363234930325828138070417399219948170895555129622235117039401738040897247746225923679766664907900266384520468299067019747580712810728628432960448834345005454492941970202466561765659601064228062077859526397359437870185538206495440555186683148867174514513090379560552113499628023502305380137970381434473232515469000739928340840152530854649249707331641656360534463623845195463365225831801928618554924169669604478814293979582949094281155555515219454524350384922556101029789696000000000000022904060", + "original_prefix_above_kappa": "1251214436612814162821395432438911/125078699795119603047628520369990000000000", + "phase_boundary": "4722025175696264927919695237147963001/10006295983609568243810281629599200000000", + "phase_local": "6296071101698264298321324836347963001/10006295983609568243810281629599200000000", + "prime_interval_packing": "7870104511960304762852036999/12507869979511960304762852036999", + "q_below_internal": "786997963001/125000000000000000000000", + "q_below_leaf": "13286997963001/125000000000000000000000", + "q_below_reservations": "39349897363052036999/12500000000000000000000000000000", + "q_positive": "39349897363052036999/125000000000000000000000", + "record_suffix": "7870104511960304762852036999/12507869979511960304762852036999", + "row_product_gap": "101249/5", + "scalar_work_above_kappa": "78701984458227803957338551109156553047/250157399590239206095257040739980000000000", + "short_record_fallback": "31240156019304642727636035264288506623514926001/31269674948779900761907130092497500000000000000", + "small_field_exposure": "3935114815004998426004073998/12507869979511960304762852036999" + } + }, + "bit": { + "added_bad_moment_upper": "355432716356049790883708977386812098509453/234016819414164681217869469557949726720000000000000000", + "atom_exponent": "1/1000", + "bad_fraction": "1/10000000000000000", + "coarse_saving": "747/2000000", + "edge_count_per_vertex": 637560, + "effective_saving": "3731649599/10000000000000", + "fallback_children_per_edge": 143648, + "good_moment_upper": "8027707883812705623527852084928925669880973/8027712973183505224497794283715907425402880", + "ideal_child_multiplicities": { + "1": 200205, + "10": 744, + "11": 1176, + "12": 915, + "13": 801, + "14": 192, + "15": 2076, + "16": 1278, + "17": 4041, + "18": 1821, + "19": 6240, + "2": 201825, + "20": 6930, + "21": 1242, + "22": 75, + "3": 45210, + "4": 39783, + "44": 51903, + "45": 462, + "46": 147, + "47": 249, + "48": 492, + "49": 12, + "5": 20016, + "50": 273, + "51": 15, + "52": 957, + "53": 108, + "54": 348, + "55": 84, + "56": 1005, + "57": 288, + "58": 273, + "59": 90, + "6": 6276, + "60": 1341, + "61": 531, + "62": 2418, + "63": 11613, + "64": 3921, + "65": 4788, + "66": 5280, + "7": 3477, + "8": 4875, + "9": 1764 + }, + "ideal_deficit": 2024, + "ideal_rank_mass_per_vertex": 6037356, + "local_dimension": 23, + "log_upper_bounds": { + "1": "2794497571682340957124877635297373985/664613997892457936451903530140172288", + "10": "2528334575079982434541401822534406615/1329227995784915872903807060280344576", + "11": "600411403950194933879698319878376963/332306998946228968225951765070086144", + "12": "1142993828777184207360458748209913419/664613997892457936451903530140172288", + "13": "2179592649656275685100552793710472639/1329227995784915872903807060280344576", + "14": "2081086258358699597143271121490202409/1329227995784915872903807060280344576", + "15": "1989379002068652850691596971376920913/1329227995784915872903807060280344576", + "16": "1903592592966036693344378039904834085/1329227995784915872903807060280344576", + "17": "56969020262929953798134630797130693/41538374868278621028243970633760768", + "18": "1747032084543038830871112645262341119/1329227995784915872903807060280344576", + "19": "1675164420376290598760656870667111071/1329227995784915872903807060280344576", + "2": "4667644505765020609023410962922269499/1329227995784915872903807060280344576", + "20": "100436496092520070582191094678870509/83076749736557242056487941267521536", + "21": "771065342673685006646733135166358345/664613997892457936451903530140172288", + "22": "370073744550279607573112242960257345/332306998946228968225951765070086144", + "3": "1032172233188422756293401527941195945/332306998946228968225951765070086144", + "4": "936573467041339825949266663812447757/332306998946228968225951765070086144", + "44": "558944340601457125066104664168550909/1329227995784915872903807060280344576", + "45": "529072791457661961615447812546956723/1329227995784915872903807060280344576", + "46": "62482226666290090497076791778946085/166153499473114484112975882535043072", + "47": "471271163267520201952459675426933081/1329227995784915872903807060280344576", + "48": "443286382355045804268228881074869895/1329227995784915872903807060280344576", + "49": "207939324276019945244737793865306895/664613997892457936451903530140172288", + "5": "3449685212679643739767746130206885087/1329227995784915872903807060280344576", + "50": "97256161098736065014848170536635937/332306998946228968225951765070086144", + "51": "362702437802767632464159026678217999/1329227995784915872903807060280344576", + "52": "21055710903559567165491511147844731/83076749736557242056487941267521536", + "53": "311571980432736537645489826843664601/1329227995784915872903807060280344576", + "54": "143362936966023970897481743216188473/664613997892457936451903530140172288", + "55": "32791960639467695129598017390705623/166153499473114484112975882535043072", + "56": "238384983159376986690582506145245467/1329227995784915872903807060280344576", + "57": "214858209765299709684507711837146897/1329227995784915872903807060280344576", + "58": "191740618457194915031832027360022815/1329227995784915872903807060280344576", + "59": "84509109531966808896832559394598335/664613997892457936451903530140172288", + "6": "3207338295154029719947261804092305309/1329227995784915872903807060280344576", + "60": "146677726869330240238908356031963971/1329227995784915872903807060280344576", + "61": "31176628991249730766489774720145975/332306998946228968225951765070086144", + "62": "51546288198091796558124099394123827/664613997892457936451903530140172288", + "63": "81824474736379124217317111502752517/1329227995784915872903807060280344576", + "64": "60891317766714082891689424559877143/1329227995784915872903807060280344576", + "65": "10070679742809377654635913330652443/332306998946228968225951765070086144", + "66": "19988767590127541216299813011065207/1329227995784915872903807060280344576", + "7": "187652305997397556398100964322667555/83076749736557242056487941267521536", + "8": "706235807641424499642680586894328139/332306998946228968225951765070086144", + "9": "2668382722142700136097456952934819591/1329227995784915872903807060280344576" + }, + "m": 67, + "maxchild": 66, + "ordinary_leaf_saving": "384599/10000000000", + "prime_choice": "Fixed odd q > 2^80 avoiding the finite rational denominator and rank-witness primes", + "rank_mass_upper_per_vertex": "47166843750071550171/7812500000000", + "roles_per_vertex": 90140, + "rounding_denominator": 1329227995784915872903807060280344576, + "row_stock": "O(w log e) internally borrowed radix-q digits, restored at the outer boundary", + "strict_gap": "9940153528978648563021016615239768808198774866649/15679126900749033641597254460382631690240000000000000000" + }, + "complex": { + "N": 13538721618671019412615861455916321263379041923794334708962708619095974987900295631553904132866614621547557044459766283367911659977263858162420914482506845567163757307926628776488393804927347292236503685286522819345922505220747186024416462993176998304785146409160658372235726493149827212442918992986208956992761474618426974171820701796228425658434995186929504617277846040625187918037429503096987807730172958001730321345262480068313892060267247861311646899617917116659081654194852897684468769907760680303709500894850821574823173271182461539695411713774003026733290258527204804484125324094815436286670606782868946733454925989387886168019650998294654856307679984992939185786288887795879573139602343164817702492569600000000000000000000, + "W": 603108575743199171590752923147126123552393555817721640496148565821912249423939898729147558464255224368869755829854697335623033102040534211214603217631553713869657040590211773900456052684616805291462392182059662529983404564337069433557046221765720206597995630281201798822079944566140252448365071721648003057973494484200213079176813209512521513162783829564785041900999225573561669097830413185639185626667778859836961938464872030829735894184721279110396254649333132899867973906704803267749386216004657222442371407698831336783983088759695790416777374678362369021419787341693857108054442488320575188693222292175796859846095104733784575379029541975909568087583671189188920853779231714594807289024686791882143532528435200000000000000000000, + "child_width_multiplicities": [ + [ + 1, + 214497 + ], + [ + 2, + 211026 + ], + [ + 3, + 92598 + ], + [ + 4, + 96192 + ], + [ + 5, + 36891 + ], + [ + 6, + 15774 + ], + [ + 7, + 7527 + ], + [ + 8, + 8583 + ], + [ + 9, + 5739 + ], + [ + 10, + 3417 + ], + [ + 11, + 2574 + ], + [ + 12, + 2886 + ], + [ + 13, + 1515 + ], + [ + 14, + 1680 + ], + [ + 15, + 624 + ], + [ + 16, + 1080 + ], + [ + 17, + 633 + ], + [ + 18, + 2334 + ], + [ + 19, + 1680 + ], + [ + 20, + 303 + ], + [ + 21, + 6 + ], + [ + 22, + 561 + ], + [ + 23, + 6186 + ], + [ + 46, + 72318 + ], + [ + 47, + 753 + ], + [ + 48, + 552 + ], + [ + 49, + 543 + ], + [ + 50, + 378 + ], + [ + 51, + 378 + ], + [ + 52, + 411 + ], + [ + 53, + 300 + ], + [ + 54, + 561 + ], + [ + 55, + 339 + ], + [ + 56, + 570 + ], + [ + 57, + 393 + ], + [ + 58, + 654 + ], + [ + 59, + 171 + ], + [ + 60, + 471 + ], + [ + 61, + 171 + ], + [ + 62, + 1227 + ], + [ + 63, + 441 + ], + [ + 64, + 1143 + ], + [ + 65, + 522 + ], + [ + 66, + 2382 + ], + [ + 67, + 1077 + ], + [ + 68, + 360 + ] + ], + "deficit": 16000307367520295669455108993355652402175231364484213746955928368022515894791258473654613975205999098192567416179723789434804689064039105101042898933871726579375349545731470372213556314914137709006777082611345150136090233442701219847037638082845543451109718483553505349005858582813432160159813355347337858264172651821777333112151738486451775778150448857280323638601090775284312994044234867296440136408386223092954016135310203717098236071224929290641037245002992956051641954957553424536190364436444440358929410148460061861154659320488363637821850207187458122502979396441242041663057201202963697429701626197936027957719457987458410925841405725257319375636349073173473583201977776486039495528620951012966375673036800000000000000000000, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "2499213001/2500000000", + "group_order_bits": 2415, + "logarithm_upper_bounds": { + "1": "84969904841/20000000000", + "10": "30404846079/15625000000", + "11": "1850599969251/1000000000000", + "12": "881794296131/500000000000", + "13": "420886471147/250000000000", + "14": "321887582487/200000000000", + "15": "385111260237/250000000000", + "16": "147590651981/100000000000", + "17": "707640948997/500000000000", + "18": "679061742077/500000000000", + "19": "1304056262883/1000000000000", + "2": "355534806149/100000000000", + "20": "78297685531/62500000000", + "21": "601986402163/500000000000", + "22": "289363197173/250000000000", + "23": "1113001026121/1000000000000", + "3": "1574941476691/500000000000", + "4": "286220088093/100000000000", + "46": "419853845561/1000000000000", + "47": "19917382017/50000000000", + "48": "188647115571/500000000000", + "49": "356674943939/1000000000000", + "5": "164941083101/62500000000", + "50": "168236118311/500000000000", + "51": "158334804663/500000000000", + "52": "74312880867/250000000000", + "53": "139101664249/500000000000", + "54": "129755597743/500000000000", + "55": "241162056817/1000000000000", + "56": "44628710263/200000000000", + "57": "41088794843/200000000000", + "58": "188052231503/1000000000000", + "59": "667803899/3906250000", + "6": "1228367886411/500000000000", + "60": "38537669957/250000000000", + "61": "137621377877/1000000000000", + "62": "24272171401/200000000000", + "63": "52680257829/500000000000", + "64": "8961215869/100000000000", + "65": "37053986077/500000000000", + "66": "58840500023/1000000000000", + "67": "43802622659/1000000000000", + "68": "14493768437/500000000000", + "7": "460517018599/200000000000", + "8": "216905370037/100000000000", + "9": "1025635332357/500000000000" + }, + "m": 70, + "maxchild": 68, + "moment_upper": "258864312822635994065467432694902185824617056005192811240021103906978730397696134437627152880092896419903080442049541997644164722223523744069618659654958430011830850345337324963261160511323989315070145586345706926151650884534416230747832026857711284044961370633421989263217324797581421153827528821034313816951566208876589305087350792030746865080483361862703523425452216345474115604987306029049028703498895825177996055091384097672512444674429226790947326097809041938745221939491894482303373476419205614822601484817909004787938868489362076315241894335083202946127394306508690895594580470394473592547919403852011584489743304634187321060781053926849022051132836329116987504779181381419239491600292167189668713998176522996448728045393917316206149915886990424222384708737573933434978173981410639368429431721186044098966185069153493919671226031511994552929581510213736872232028746323985522146354177245070354328745670674833215201383909427310986478058902879218729127/258864312882296500031055289607308876918948194191739080393665208773437327950361705506204269262727624369607191381066070736950721387722343455305319397218060826215806055566676458467985854943815840460405474061110154037491708121904679791617548836252416330123113259519318454367469789088759143697885963048633822970601575393057295335974413285977207878402333467407939617985467006958820688402850530703846606121734476356557987835722081138227469842662438908972992927393171772790668096312894309081073575846448722623251554492048017857602287936132027784462360677641358992824901206117953947391105954258456029157280133485124255285284951748169636791141814335580522461373398332705279009190357387940809475590086743023351702184232232736981858998991300824787343216349598086601789879924718839538480440090437137911672142043373939595769029469714536428078367503524111596722215987131151839686520104495974436734700813521784031923667417309936799035132679343460868275000000000000000000000", + "per_vertex": { + "W": 90163, + "child_multiplicities": { + "1": 214497, + "10": 3417, + "11": 2574, + "12": 2886, + "13": 1515, + "14": 1680, + "15": 624, + "16": 1080, + "17": 633, + "18": 2334, + "19": 1680, + "2": 211026, + "20": 303, + "21": 6, + "22": 561, + "23": 6186, + "3": 92598, + "4": 96192, + "46": 72318, + "47": 753, + "48": 552, + "49": 543, + "5": 36891, + "50": 378, + "51": 378, + "52": 411, + "53": 300, + "54": 561, + "55": 339, + "56": 570, + "57": 393, + "58": 654, + "59": 171, + "6": 15774, + "60": 471, + "61": 171, + "62": 1227, + "63": 441, + "64": 1143, + "65": 522, + "66": 2382, + "67": 1077, + "68": 360, + "7": 7527, + "8": 8583, + "9": 5739 + }, + "deficit": 2392, + "rank": 6309018 + }, + "saving": "786999/2500000000", + "strict_gap": "59660505965587856912406691094331138186546269153644104866458597552665571068577116382634727949704110939016528739306556665498819711235700737563102396203975205221339133504724694432491851145335328474764447111340057237370263560869716809394705046078151888885896465104252464291177722544058434227599509153650009184180706030887062493946461013321850105545236094560014790613346572797863224674797577418235580531379991780630697040554957397988009682182045601295362730851922874373402414598770202370029517008428953007230108852814349067642665708147118783306275789878773811811445256495511373788061555564732214081272243700795208443535449470081033281653673439322265496376162021685578206559390236098486450856162033470234056213985410270945906907471137066433711096177567495215981265605045461916455727272303712611652753551670063284645382934158696277492599602169286405620938102814288075749650451212554459344538961569338671639261965819931295434033557288521941097120781270873/258864312882296500031055289607308876918948194191739080393665208773437327950361705506204269262727624369607191381066070736950721387722343455305319397218060826215806055566676458467985854943815840460405474061110154037491708121904679791617548836252416330123113259519318454367469789088759143697885963048633822970601575393057295335974413285977207878402333467407939617985467006958820688402850530703846606121734476356557987835722081138227469842662438908972992927393171772790668096312894309081073575846448722623251554492048017857602287936132027784462360677641358992824901206117953947391105954258456029157280133485124255285284951748169636791141814335580522461373398332705279009190357387940809475590086743023351702184232232736981858998991300824787343216349598086601789879924718839538480440090437137911672142043373939595769029469714536428078367503524111596722215987131151839686520104495974436734700813521784031923667417309936799035132679343460868275000000000000000000000", + "total_rank": 42201599994656421715683249511305472996265373675876030620983443679165834943781001652566674478522659706722690340673649089704177512453773355679921182335274888244296617491769092702659710131608262232693360675661565031948702229270152159129146197885517568918408584401200572412196590261047004239225395207160012876199880441242193138209264772927390054145616717620677672609431344699374032523854084688127446553730336133965494381676405731954364414356859264608437096788208316310034706531514378675317920844755889561130607069128769733513017661553858216965536594377278178373376882134522128755522147916981237299511095858826107844161268937873377461865606226532588412446755220634170050986181344242245150470736199454480737080901317427200000000000000000000, + "vertices_per_stage": 6689091708829555045758824829998182442380949567092062603242444969909078551334138157882363702009196947404919488369449744746991926866237084072342349052621959272314109341860982597079245951051060915136612492730495464103716652777049004952774932308881916158490684984763171132527532852346752575317647723807415492585356459791712931903073469266911277499226776278127225601421860692008492054366318924455033501842970829052238301059912292523870500029776308231873343329850749563566739947724729692531852159045336304497880188189155544256335559916592125266647930688623519281982850918244666405377532274750402883540845161453986633761588402168669904233211290018920284019914861652664495645151328501875434571709289695239534437990400000000000000000000 + }, + "finite_bridge": { + "bit_uniform": { + "atom_beta": "1/1000", + "coarse_saving": "747/2000000", + "external_stock": "No q-adic group-size factor is inserted into the external polynomial row stock", + "old_atom_saving": "384599/10000000000", + "ordinary_saving": "3731649599/10000000000000", + "selector_stock": "O(w log e) internal borrowed rows; restored by the uniform old-supplier wrapper" + }, + "complex": { + "N": 13538721618671019412615861455916321263379041923794334708962708619095974987900295631553904132866614621547557044459766283367911659977263858162420914482506845567163757307926628776488393804927347292236503685286522819345922505220747186024416462993176998304785146409160658372235726493149827212442918992986208956992761474618426974171820701796228425658434995186929504617277846040625187918037429503096987807730172958001730321345262480068313892060267247861311646899617917116659081654194852897684468769907760680303709500894850821574823173271182461539695411713774003026733290258527204804484125324094815436286670606782868946733454925989387886168019650998294654856307679984992939185786288887795879573139602343164817702492569600000000000000000000, + "W": 603108575743199171590752923147126123552393555817721640496148565821912249423939898729147558464255224368869755829854697335623033102040534211214603217631553713869657040590211773900456052684616805291462392182059662529983404564337069433557046221765720206597995630281201798822079944566140252448365071721648003057973494484200213079176813209512521513162783829564785041900999225573561669097830413185639185626667778859836961938464872030829735894184721279110396254649333132899867973906704803267749386216004657222442371407698831336783983088759695790416777374678362369021419787341693857108054442488320575188693222292175796859846095104733784575379029541975909568087583671189188920853779231714594807289024686791882143532528435200000000000000000000, + "coefficient_bound": 28, + "coefficient_denominator_divides": 42, + "finite_group_router_upper": 8331937966362142837469352279220030133647888688980039156181868875970232503770055710232664076515320301779070840687208708907877768434194450291773616323813450028207597595056380392181797744959838155981123580976290547490582874424242900417504391560675395758714331771072219691443675011548689712991796380033940322563804170759104462188040515147572247328536148268221300086684328655153181799979902670624839573095865950690891448461620344241538856726234094021396707694738001865781489939750833184712577948426044052007183538224384875418436165513267525063842522635703676193098523683534457639244273576970432751377741451959202109973313026260819615165583229463000176015007691411864854000841667680552860662260367153953521484451296005040756341027392125111377121693889355377294709675922433764122822727575590517988519713121391437639243919405081652733496336484304353702140273537410399427750130176824911380240639834015188843628057194629120734920665943414328311580037623858286808828983472490080084850623947846689395823852131194363044209310241356129379046222903993703988856016803468215649620763866295846177003428832516279528691754742359666527360792834485120446124501821634741362076672805325003218625804795259538195553058152557083984230647468708605304456161988839457480884590766899046784867314033572329875603962920454824316168548120381408594053547604250532306778568824963123590324901463438248680779358099674733376062203705110198748669552019499867872036032348160000000000000000000000000000000000000000, + "halving_degree": 24, + "invocations_per_stage": 6689091708829555045758824829998182442380949567092062603242444969909078551334138157882363702009196947404919488369449744746991926866237084072342349052621959272314109341860982597079245951051060915136612492730495464103716652777049004952774932308881916158490684984763171132527532852346752575317647723807415492585356459791712931903073469266911277499226776278127225601421860692008492054366318924455033501842970829052238301059912292523870500029776308231873343329850749563566739947724729692531852159045336304497880188189155544256335559916592125266647930688623519281982850918244666405377532274750402883540845161453986633761588402168669904233211290018920284019914861652664495645151328501875434571709289695239534437990400000000000000000000, + "local_group_upper": 55062438637392, + "m": 70, + "maxchild": 68, + "s": 42201599994656421715683249511305472996265373675876030620983443679165834943781001652566674478522659706722690340673649089704177512453773355679921182335274888244296617491769092702659710131608262232693360675661565031948702229270152159129146197885517568918408584401200572412196590261047004239225395207160012876199880441242193138209264772927390054145616717620677672609431344699374032523854084688127446553730336133965494381676405731954364414356859264608437096788208316310034706531514378675317920844755889561130607069128769733513017661553858216965536594377278178373376882134522128755522147916981237299511095858826107844161268937873377461865606226532588412446755220634170050986181344242245150470736199454480737080901317427200000000000000000000, + "scalar_group_upper": 8331937966362142837469352279220030133647888688980039156181868875970232503770055710232664076515320301779070840687208708907877768434194450291773616323813450028207597595056380392181797744959838155981123580976290547490582874424242900417504391560675395758714331771072219691443675011548689712991796380033940322563804170759104462188040515147572247328536148268221300086684328655153181799979902670624839573095865950690891448461620344241538856726234094021396707694738001865781489939750833184712577948426044052007183538224384875418436165513267525063842522635703676193098523683534457639244273576970432751377741451959202109973313026260819615165583229463000176015007691411864854000841667680552860662260367153953521484451296005040756341027392126216330226979372986242876343731371305885512477690589863995081930211901062947494805688707931377149741761307021746202667903079317772837837742630265571111031305973931914391619635997186891863513494867154092799078742813049075485474766192838873280088421446902727853059880494532586409019432281857588083013224995408020674088448197481646158602489724172973652642711481015241575686591532163960297046458938068261725654761128806353166897239289884136167205339452315528505368201445123930264832764688768700346727473200113158531507975282492788225652760032262081515133321352035920662987391386415698739641548957327720527962935019641323309199128339302438014055271601926317442238209982264516371312257139517641226846802767775049650554986823680000000000000000000000, + "stages": 3, + "wire_bits": 2431 + }, + "conservative_old_coarse_row_reserve": 9909, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 68505, + "complex_coefficient": 58344, + "contract": "Finite complex group role stock plus conservative fixed legacy bit reserves; q-adic selectors borrowed internally and restored; one prefix and one padding; sequential reuse", + "degree": 160000, + "degree_gap": "101249/5", + "suffix_slope": 640000 + }, + "semantic": { + "B": 37018435259192327026444362697176328284448078188231769953782205265560458994954198528128522271608574408355202540032255075117064968824327990197877830058875685381240368807405458918509373120982313431379572812796500814090858418296308982119821986030880818153842771889364723831622819356875189083770091903009992093953323267345008324543448535299659232847137164228817520156965454222496076346048075753934240004585336040743460323739361513753754219231885274556219650061408475985021071528358092463203549452302568664686135139295765432027153560598461589972523219970876048764263605385072846558138979410695263283436723795819749936298869629733885754380405293552951554248018338523862933278110049131111792477888007451534133694519797648709286837681549558235135639856222074605338489634655222341780048039966324013624302401090391595011077462555282587702669950720510047572110720022355583945737902393191417530355904864684514686083589233558409810569331377416983922386607960310165879036875161816637415611719601268127301986956088110556032607981930143972637860354756134494817601720717816880540330187822876112155436889663728626881438010883134476724020941093051927869881849985320024654243039856782905204990852015879595315962469380186943323565847050823297875741422603094472816484242240290243785520650512759964482686389175876608814679832488395605198592550183523227695326324405319213918836405829163433288721516691592464401780426918678712678566359382403598736803437089218194416547260565798719016237368522780663398147471461447992846392617907566154366175707359264010265815033757522880616735188240500326586332116696419823686932953799566753222197486024561126186118343330587296238474139022833112265020444781192115498584792420933489474961630771687480286735456874855985661630110620019360347490277815884544440349945973897618015379741099514620546558532451665283502953310770385985494853827457952302380875704737283118931474575490442149207374784396721122337873721980447068204001471750774918685802568848862629144032190483132135512623692833119464674000061792103319557785695071892746425113146809416686514828600589614810756078133714080807393331689586136443874929160777745718251043099404230653067658292748193187300798217981433692598352097048615718524126487019458671337811169879492556087604675369999022896229620975252138963830278036923601043947482905899333261058990133592251960623541853762891294615000811468263211044449094921381202115109117335785946382498736014749017072230007514656134881364722930245487243635379824275198249782732298014985902773285627599866793825306640063333217950461082689841180144628015777720287339218784144353254423233037785326137389276418599473239903930128769785343454398786831571315781154093223257396440957705880274830618348534345024533000802236323615617001162025065300575996127993849940752960710120324216532541775112017396953323423450627982369974049596590379116692860898445454836250852853303025015830671119921653823000015513115046384705622638557606356875890362371915075761494905355931582474893276262116659468701517803832334453389407705282122188617354057227599038434185170662256090429963179552058995691237203307999893582029286652718459240152739777714785639499663290436519523987093942398584911721632632813255021682655336323585929420685705087825676508526577022032739617765599016754123576842327367511961218995296221951512081377941279472669829052210191027257723770554770539329378349643039072243734347421817323301137284090740656814691256709885378560768416696455996352754626053880893286649822565717679941966400457769587389810482991845944695307344101493718734851409047013331336619029648120092823292143936250876465820745470666739744553348685324612709960192902985497317753607106208192781856394963271023397485958898513952710680376925769328043163209444862286546497894980858084664032434530948238303005298765494224918834677139533052851073924396011642208465619086967753959435968457624870949449180227998445053181709439294201108632062848407411992911669005620297785903094596054485027637456994133475447120900669624133517093608474089699188817904176252998168315216846749739166023641277281532755806584114036763275240984118414603436117777693065223307493806186047945090438303066144919411289609662205472686739546949946337036430883392584922597316966922402870966595858247060560686612522943086254909933373114074580541047496904755619574063966171327587823657376669850262383030910965982786263717300688718481858967862770662579952920306244222416718403271760281600000000000022906304, + "C0": 3069616589847390661646422921084421742076791020252975349036054045022876868816325360016884006766783194275238402685467560897379979538095659339914153411228923909333095982797289674916529618429267783546451504270618482414638463624294728177966618130024107087751376653321734853189117093266202030762618889547070961502205714597092709896013907425368392094475384221634319478984386904866724573994626804450216944973924004715129813965761596933326115776509943340157943174129272539823538050701622535963394690012758192847459689849972234337123874693385824686036508296575317079188160243598118725757652458188392322022844952575356424395442848095001566387040343856569269189917395657957736197073257203779373376889188640167448301868942509481176151204589988645494367063387585216101009063950625330703064826114491278166377864559802175046525033303468905874332453558086400872719885643863720883286117067041921620953698342288655741970429273531809582230991868701944130291351470030436263467358890906695434168397182790713738221001251836143805627527705706423299121278974890542200636743526283452050476661223881388407442978243431669478604808233403509060869050122348252528508652514546190870356725140776540043842433519776101118663309008418821694162806975376395055996154862940347526503831995965890962095517246160505917385844418501289372312929895261433044238853159640873178296074691588108407208060312941030713075650949796819720623617274671433189514444530605570317109481285852874851994767235546746412816105225612917279997364398814260806978260442672433634877529433763342817839622416123929066317965684395720963995844612459772496852858136114495501553052875918890493437720817467401959927795563460985161443838370327267773319262197676970128601037750371606747882081864991899478768652753719460664740703974322244254178850702689621313279552404919356570149678532057847416870830584864207747262934507734636621850863249283092432101857929907404597235734821317451725043998173780050102022316333191629802847635970200654831305961679321884238323949323545700727495913214847967853940828265964698218756505631346237825273777434498391411473506381159325514613731928748097685882747312386889119756084378600903991571078005055042046094316492423199198926541204285844748101819694175439766391894760923482807755851157024426217957400485561625345998966386010259637345603116709342194670474158578691919955704515843909721332395326584625955397922042204666852937101704587600533643647978023445793085383805879506200290001133205268542865652521678471024305612952671381449711629060543192466777247816868331366012703319698246037145296320423161788616663091652318823857575904196794797964398167338610177904877137492559370005420422792916547825887244857506972903189722341454322372425992499266566928072634528989945774494027467883853578920359196688045291344841920146816451269469235508593645730320230041166006942477439187092034202141157249063205216148696106347944143180271913682251003020961975747460268264152990294154845602977001034546573868730840030306106083066615893411507070172306418205365347514388388797818280149907416885905694557490327243356351213517064048360368083743926444159596486796654971962837266376087696736036630821397057759265435399001034219784548534301293246968481718896940728916586643216813696276995906818516031447282486976508491296289704612599444701418962843899412141286241116524383330689501164812645733598962642697378754768940828667023559332287032297181065740336402086342631379249524918280111183002518810569745674270883218352487398164117312518791310058222635531090696166659589283706956329197255219124344464109810607181914334024182373262741496913565784599455831294271786971532656044956865808927363230230333221117048299138478722770262564293401048323295690290576665049283594774564952983008328199450553465438747989935270451017153656365432531286748212897865565389174479692626368044817794835214853612348369456354164208860180288069919602131366281198492282525758164785175498335196238660843356185405464740133677928165863349772663124722360548211575171143108705321242747390208190455654032110752116075685358288616340116422198197003816643938163895854910801612506007028467740158364494675391779674117452943972234067245950780672757641835401762457813591085466472610760081694796364038455190850128858452726179344290731902979976155980178379086308794363749154375086244054353599953429957191632533404966135293427500650680626153605182642974405654605481434633806516552904430515471895807265037937668023677087429584949287059182611670560401700700017559374074319372739896109330961864733696592468618981296359696294503303358287423679181319508447833826703479290840941996672425175155521850976626815339256699939699024495134291200127894497828867785423243804361641141890614907969840399371178577763175489888290853519406409284426091492125845694430414786261517542690667830803552935505127879841490640594516473577535926907627698561130284717948267721725142670780954498243227867071651455284864010313916190216822966036405047107841054379533193963821395300030937635313039095961018619372045254622793379697689190925399960112892996991372336228690526514452230046164243049324160650581489248498500222753929695227387754386736440672728913118007774421009513295474455754364427533757831243295844710153706155070205909786228273972241529724104831779415023593765443975150793497820325243216093304681631402883418607554772638433704245678459883754743033745471774652338069116962895044695078686700345123049398507532493117764465922346580451143760984511302902981585134883827184510924906168237887159079675861767203290544665283031999497569196460493279382670817562203517598895210872352131152416726458789284102791986449492927809839090958584834275931170340360223550461701875498695258246098405728247328299409849521530984187679500797631982947884322803334600336640944451479355279962252221365803036612322834250440378838042973627611346346410854820147081053422165287359392144428924191577141110190356684154737790356559946358034320252924025437779851896882413629999493544862285292894044387815136197600402988751484543814749942284135745572486194981299872333341135624996173257514734626282063753231786816608227234776158060632003953104843780400337333260255864971865777127469201460859296674057408680269498549354590278046876148727941310202872912455674670533789863533029022169344424734365284287718190320177071534495772894370418338875123924491939556994692699881062472213584470276688679269148693894614969512596832727697762383836323100635728643771561802166985245437719618051192366607811242236996441689783585111902921696218444327698412739754761822433880837714238306908525912988329448663035458632195302481700045036959155396196236372066787792484509384384116474295222519883964470607396091587053756737832709585568331499654462614637079446418700364557528774701544907496792566061820917895585315031000913645970862233845370066562511481435508765949780756683491741750164653540069286344097126924143802863871779902290652059933085944629227727379408610025190800441296391906569513444994575126455593618267089467077827689732185269985079250319050076679453958934753744707007843823199510595879943330589299764820420085432240331515162141898514877775243105544504151899071862772251461445672747157367616055221204376870984757008164127865557093758931769160076096215883956485086634736788461990450409274051424488467778490841549841838379565387168414889221154325025923132489877617360674665439019065069536737526647995524603455961995829657709671871770971415869698449901037548861523639788538732019202410821869045247466022119269396873591901406501589466809011902113955944725931364985630260453207476044034314004728636469219193474412319169770242296001006322755471886187578722990029593301923214086469716417189708220507257480840631914486428036131029664266274054070774371908752523409123144852155288278515225447523155701970783062233545883414442554327153746583643906023363416916232392701827354121176877492838992440456164956179679443358539411221388963087058808445177118325775350312048733693358445116287887906606192536786225381289786497145312046361460760019755194835609268558177972799557297732412590508021286017552247345369421374698764558857788409156279929776872019178670914575258679644397927621365061627875356309930460839454975253784491950036961236504090374835903791529034088939005854961632766099386794358822295032891931730751727882738952839441412450491375781893151942344499288563967508918805392482653859015539304277916411077179137787165223790825601340401865299032334835346931478942739645108890462644437264408838886181985653244650945322080486048022815520910895177446529767723794159272835895952498245955570160616918096072192578199775204360236370243324892515167436333710103460833047971241733773567733079897717161610311543709521110070348559091682672244048258383086829662723791604182578271717814290366206438124002127827311226746288432087162447106404908864366021832107425929452521322690566872310257132832850634488314703996264159602039324672001175325228986531840, + "C1": 1, + "E": 37018435259192327026444362697176328284448078188231769953782205265560458994954198528128522271608574408355202540032255075117064968824327990197877830058875685381240368807405458918509373120982313431379572812796500814090858418296308982119821986030880818153842771889364723831622819356875189083770091903009992093953323267345008324543448535299659232847137164228817520156965454222496076346048075753934240004585336040743460323739361513753754219231885274556219650061408475985021071528358092463203549452302568664686135139295765432027153560598461589972523219970876048764263605385072846558138979410695263283436723795819749936298869629733885754380405293552951554248018338523862933278110049131111792477888007451534133694519797648709286837681549558235135639856222074605338489634655222341780048039966324013624302401090391595011077462555282587702669950720510047572110720022355583945737902393191417530355904864684514686083589233558409810569331377416983922386607960310165879036875161816637415611719601268127301986956088110556032607981930143972637860354756134494817601720717816880540330187822876112155436889663728626881438010883134476724020941093051927869881849985320024654243039856782905204990852015879595315962469380186943323565847050823297875741422603094472816484242240290243785520650512759964482686389175876608814679832488395605198592550183523227695326324405319213918836405829163433288721516691592464401780426918678712678566359382403598736803437089218194416547260565798719016237368522780663398147471461447992846392617907566154366175707359264010265815033757522880616735188240500326586332116696419823686932953799566753222197486024561126186118343330587296238474139022833112265020444781192115498584792420933489474961630771687480286735456874855985661630110620019360347490277815884544440349945973897618015379741099514620546558532451665283502953310770385985494853827457952302380875704737283118931474575490442149207374784396721122337873721980447068204001471750774918685802568848862629144032190483132135512623692833119464674000061792103319557785695071892746425113146809416686514828600589614810756078133714080807393331689586136443874929160777745718251043099404230653067658292748193187300798217981433692598352097048615718524126487019458671337811169879492556087604675369999022896229620975252138963830278036923601043947482905899333261058990133592251960623541853762891294615000811468263211044449094921381202115109117335785946382498736014749017072230007514656134881364722930245487243635379824275198249782732298014985902773285627599866793825306640063333217950461082689841180144628015777720287339218784144353254423233037785326137389276418599473239903930128769785343454398786831571315781154093223257396440957705880274830618348534345024533000802236323615617001162025065300575996127993849940752960710120324216532541775112017396953323423450627982369974049596590379116692860898445454836250852853303025015830671119921653823000015513115046384705622638557606356875890362371915075761494905355931582474893276262116659468701517803832334453389407705282122188617354057227599038434185170662256090429963179552058995691237203307999893582029286652718459240152739777714785639499663290436519523987093942398584911721632632813255021682655336323585929420685705087825676508526577022032739617765599016754123576842327367511961218995296221951512081377941279472669829052210191027257723770554770539329378349643039072243734347421817323301137284090740656814691256709885378560768416696455996352754626053880893286649822565717679941966400457769587389810482991845944695307344101493718734851409047013331336619029648120092823292143936250876465820745470666739744553348685324612709960192902985497317753607106208192781856394963271023397485958898513952710638175325774671621447526195350981073501629607182208633411451087269072468061517763841658244356154479826330160733250746921938030953165313612074038253633182736626652831688458905742393471577831031968415271387186842380044209439735468138656756896710536916109228872592932903034924310408577129277868213266929686312618023735010805030105952073822349111878024559660855083197152769337389242717130033726475989564047356931257813112129780315990726023946206880310974192821453889162652033015435567661718510038636695361466709897793633137453578196693202343721075928565808076536556490979552451785525348987774382274552870312501479979496107731976884921165304739450197851270545468084311807981681426420334802449570044767935981322370442854400000000000022906304, + "exact_grid": "One common dyadic grid times 21^(-K), K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 21, + "induction_gap": 111055305777576981079333088091528984853344234564695309861346615796681376984862595584385566814825723225065607620096765225351194906472983970593633490176627056143721106422216376755528119362946940294138718438389502442272575254888926946359465958092642454461528315668094171494868458070625567251310275709029976281859969802035024973630345605898977698541411492686452560470896362667488229038144227261802720013756008122230380971218084541261262657695655823668658950184225427955063214585074277389610648356907705994058405417887296296081460681795384769917569659912628146292790816155218539674416938232085789850310171387459249808896608889201657263141215880658854662744055015571588799834330147393335377433664022354602401083559392946127860513044648674705406919568666223816015468903965667025340144119898972040872907203271174785033232387665847763108009852161530142716332160067066751837213707179574252591067714594053544058250767700675229431707994132250951767159823880930497637110625485449912246835158803804381905960868264331668097823945790431917913581064268403484452805162153450641620990563468628336466310668991185880644314032649403430172062823279155783609645549955960073962729119570348715614972556047638785947887408140560829970697541152469893627224267809283418449452726720870731356561951538279893448059167527629826444039497465186815595777650550569683085978973215957641756509217487490299866164550074777393205341280756036138035699078147210796210410311267654583249641781697396157048712105568341990194442414384343978539177853722698463098527122077792030797445101272568641850205564721500979758996350089259471060798861398700259666592458073683378558355029991761888715422417068499336795061334343576346495754377262800468424884892315062440860206370624567956984890331860058081042470833447653633321049837921692854046139223298543861639675597354995850508859932311157956484561482373856907142627114211849356794423726471326447622124353190163367013621165941341204612004415252324756057407706546587887432096571449396406537871078499358394022000185376309958673357085215678239275339440428250059544485801768844432268234401142242422179995068758409331624787482333237154753129298212691959202974878244579561902394653944301077795056291145847155572379461058376014013433509638477668262814026109997068688688862925756416891490834110770803131842448717697999783176970400776755881870625561288673883845002434404789633133347284764143606345327352007357839147496208044247051216690022543968404644094168790736461730906139472825594749348196894044957708319856882799600381475919920189999653851383248069523540433884047333160862017656352433059763269699113355978412167829255798419719711790386309356030363196360494713947343462279669772189322873117640824491855045603035073599002406708970846851003486075195901727988383981549822258882130360972649597625325336052190859970270351883947109922148789771137350078582695336364508752558559909075047492013359764961469000046539345139154116867915672819070627671087115745227284484716067794747424679828786349978406104553411497003360168223115846366565852062171682797115302555511986768271289889538656176987073711609923999680746087859958155377720458219333144356918498989871309558571961281827195754735164897898439765065047966008970757788262057115263477029525579731066098218853296797050262370730526982102535883656985888665854536244133823838418009487156630573081773171311664311617988135048929117216731203042265451969903411852272221970444073770129656135682305250089367989058263878161642679859949467697153039825899201373308762169431448975537834085922032304481156204554227141039994009857088944360278469876431808752629397462236412000219233660046055973838129880578708956491953260821318624578345569184889813070192457876695541858132041130777307984129489628334586859639493684942574253992097303592844714909015896296482674756504031418599158553221773188034926625396857260903261878307905372874612848347540683995335159545128317882603325896188545222235978735007016860893357709283788163455082912370982400426341362702008872400551280825422269097566453712528758994504945650540249217498070923831844598267419752342110289825722952355243810308353333079195669922481418558143835271314909198434758233868828986616418060218640849839011109292650177754767791950900767208612899787574741181682059837568829258764729800119342223741623142490714266858722191898513982763470972130009550787149092732897948358791151902066155445576903588311987739858760918732667250155209815280844800000000000068718912, + "literal_charge": 6061317467480298914166412413635509035200825324641462576528500918260505197048529008335411593478234130210827057096014978142654834128399860733918726118791773922544231627186584932607180837437985697148325446613654772127558622768215964281375124396090186525633003482521737660857117057240380408058143301159395745008292344044487337285943700394911933590972408446368912334264475733554299876270081563954488872295078335957930985305442753589850599233939824365300285962223023588247381049686123738701973261608696653853640271295980430937712764175125304472239135234455542038111815182015673494498712783967998518258154295470432336395361110853163893932642029796415156619769016056023201425897551251393123598093723935966354950958705012418775872953351008819532305000414367477670368808844583692409434398245075205495223168715503573269586583420103111590096600671365292561495345243553257247298264986356518377914831220801501017951433236345152310406984299832525720293608660467685802945483512669025302907128271609978978462701143150604820858999336153620386383894468943290542669059358179441300249076561668526454073442875717677916326520380838342739697951112608267914738492672336157550028283025113961492707126404199254138271260685098789681348025487639773424867242919160106456506225534345420260373319252745281061156015856899471184592970267481712361162351271741573628066610930691160032539534168785670646828732270689456404423559701174212880588017796628230376017675290791793374993860591404265466456680648175654814058715126532658208137745454919267048288763951796324118745993820549985758936031091665141162389848923851841799059583105683402276350936999910323347488009519439806868167328926974701226839113335255880808750186544931465301588153899893702599669867866186021256769597944650784226039304068822923262564211182177780591366866646362124875884880995517669656219522666002703053336351359891487652867447175318019352977089273823249142319226929813637473276418387127197612183733738386142721845626159231038325296874200627272574306187965929458860133905538784309005014926007818655156818488946449124798464099925756731475826598449776290085204577274569078978042280310875204761493427427197988866936787709324177115415689567097667988137061963313037882715845129855200144933656979765875835424049864470446024907245877422963999708688816979203564558062413402109110136866845080992848753919979905561317141584585229824048025921909547308796975243130649305866894488417110756862463558580639319802212486767915649173681178903044454862485635704362237681574148245978149890284574577126487264579106426185408914448845493504091361788063449572056526660614284169584892130984109554414961055346550364120714926497961868347353913614754951268350956156592460248884512851335524123604981906157784294005113951272816555231962286602696050339075796628150139399920930876099280442740618192335848877634784032742506145082992546749815280528246791731174104728858887400270864819582995045694383013425221340653158400000000000000002244, + "strict_literal_gap": 37018435259192327026444362697176328284448078188231769953782205265560458994954198528128522271608574408355202540032255075117064968824327990197877830058875685381240368807405458918509373120982313431379572812796500814090858418296308982119821986030880818153842771889364723831622819356875189083770091903009992093953323267345008324543448535299659232847137164228817520156965454222496076346048075753934240004585336040743460323739361513753754219231885274556219650061408475985021071528358092463203549452302568664686135139295765432027153560598461589972523219970876048764263605385072846558138979410695263283436723795819749936298869629733885754380405293552951554248018338523862933278110049131111792477888007451534133694519797648709286837681549558235135639856222074605338489634655222341780048039966324013624302401090391595011077462555282587702669950720510047572110720022355583945737902393191417530355904864684514686083589233558409810569331377416983922386607960310165879036875161816637415611719601268127301986956088110556032607981930143972637860354756134494817601720717816880540330187822876112155436889663728626881438010883134476724020941093051927869881849985320024654243039856782905204990852015879595315962469380186943323565847050823297875741422603094472816484242240290243785520650512759964482686389175876608814679832488395605198592550183523227695326324405319213918836405829163433288721516691592464401780426918678712678566359382403598736803437089218194416547260565798719016237368522780663398147465400130525366093703741153740730666672158438685624352457229021962356229991191971318250920523218185693476105896703551775079542651896161265452199617211795522315929907395646527332413263943754129801436466974319834702834072148919264322454081750459895475104477616536838609829420698827304059941887830596458619634732807170576059221246507964888591019719797977539125941493193476568826575828467201554976985703195363813249443799091278368748023122746507243838701185788551895097555187799176505405330217221523438858770052561823484243062349027928194253313455936658290883075034994234670841334101876830842757559875559785336960995294225025590711035228135715921835886479635214597044456866850641935907674619887709756631997146089910706105350614066107662518278864879078188609934306561154439203820186577007063758335054868208097470677896322479230149468893532920886668062046508519338037367702546481906692666534263700579701097157684099440794072091751714916491351936398854188449078419239417576461940728251552665219271320031154864381081914286291446246407441412171120042675281401724510399879895551454109193833265775908426675338096712656946983397691325305991205325165437456433627793426115761717609823074027689024003258169697020781485149270323046705251108133559317163509160494936490719880315622808741104659691804694263424745347948804844535684592161072178886408741907438665899219084153326729659784189422120582613568611407111418747440942411997716486816008687947347765812981882029770967649609304814257180276768416178149729458451330956062884565286164625455908958003442623533507241840102403093505521093700581039327710259936108131519905723542645029376329370971230633299970846618310572688589209680410651838061589834725176701167511666867782761633723916061554499683831056078563875792795993435548942675754189912394664546776145094572633171346066631085860271623253147163049507137690906363879067117671882203031623686095154460524172675004074207470453267380396304129512273194827030030553734150726595395015555596412449195293143373754000470998909453484271698682840929769299525446336900245904959922214867236693272916644266224842367646165671888546176391688697464242473480563119282532994914118560530044282929092777092289297295282886335522645860631236865508320125629737964467760319515557023637159161157301387534028123269363779244538560277100181942752370716193293888169754073184110973259752294932453668403358688600730922141150108767150340928525165073926854276429979916485628800415665926169988981061363234930325828138070417399219948170895555129622235117039401738040897247746225923679766664907900266384520468299067019747580712810728628432960448834345005454492941970202466561765659601064228062077859526397359437870185538206495440555186683148867174514513090379560552113499628023502305380137970381434473232515469000739928340840152530854649249707331641656360534463623845195463365225831801928618554924169669604478814293979582949094281155555515219454524350384922556101029789696000000000000022904060 + } + }, + "kappa": "3146011/10000000000", + "predecessor_commit": "cf60442983c153a3a0f5272ea4713f99eba13c86", + "scope": "Exact local inventories, strict moments, contaminated fallback charge and semantic assembly. Local finite reconstruction is checked separately; group geometry, uniform weighted routing, borrowed rows and inherited analytic/tape contracts are written proof dependencies.", + "source_sha256": { + "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf", + "certificates/partial-gauge-bit-input.json": "367b9844db23f8fa64002637903bcc5ce28ffc8879d274b5c54c0390fb0234e4", + "certificates/partial-gauge-network.json": "e2e6c48bc283b1417c13adaa35c36d782191e21a33f7279a4ed1558ca60518be", + "certificates/stopped-product-network.json": "43ddb7ee033d316375102cf2d97bb2cf47f879f36a005d3726fa6647a2cbecc5", + "certificates/three-stage-cover-bit-input.json": "d0d496b64d45408d6e0773ebbcd4d5dcca918a596073a51e5fc186b82c3b8520", + "certificates/three-stage-cover-complex-input.json": "afecf8ce2d8eb259074e61cd0c386b464ca2f57c61b00979eac808fa26e0b770", + "certificates/three-stage-cover-input.json": "633e108352d3a880c3dc05e265f40270698ea7ebbe655706f5f8675070c86bd2", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/three-stage-cover-assembly.tex": "ccf34a6d37c4af14bebeab15be50ab204eb1caebe546385520050ec30089441d", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-complex.tex": "1c5b638aa9b75365b8addec9c8eeee6bc5e499722901079b94c65fce033fde8a", + "notes/three-stage-cover-note.tex": "db8078687825bcd43c6cc2fb69712ebb12840057b77cd5af8f67f53e4ffffa92", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/partial-gauge/pr97/SOURCE.json": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "references/three-stage-cover/pr117/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "references/three-stage-cover/pr117/NOTICE": "a0030510cd3b5334fb113eae759aadd2c25951bd353dfb69ad9cb780ae5adf30", + "references/three-stage-cover/pr117/SOURCE.json": "74e9f4b4ae0529d21d19c159b2b50ee0923e93e0d7eb22cf208ad41dd5992275", + "references/three-stage-cover/pr117/dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "references/three-stage-cover/pr117/replayed.py": "99c1e3694ae06a7ce7a370b04ecb45ea3fcfe69a6e6e7f4c4606e0a6c74c3184", + "scripts/partial_gauge/binary.py": "b29e2f37d7f32a959a378190d7f1da3c2da534fbdaf878044800301957bffc03", + "scripts/partial_gauge/lift.py": "895874399113faa090d168d6168f0664136df6e21205671e7f7f9239cad93d1d", + "scripts/partial_gauge/match.cpp": "12b8b7c93bb78324e7328e624b166be2067ae8861540531c024040220d86f368", + "scripts/partial_gauge/word.py": "96015b7b08a261673ab8be1ea47f89302f8a1d62a822d657a09f6a1fcfb51e58", + "scripts/partial_gauge_bit.py": "7d58e86061da2d73991531e9bc431589019359391adea866c61c7dd1f99ac855", + "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782", + "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d", + "scripts/three_stage_cover/README.md": "b39a28fa8da5d7d3188dfed4c0e0af1e2397f0f5c8f69cfb69671ed27ddca4bb", + "scripts/three_stage_cover/__init__.py": "b964b59af038e70cc15af655a22bcf6aaafc9c842b213765781bc8bea7166430", + "scripts/three_stage_cover/lift.py": "ae5f4c56cd32b5232d6dcdcaed1e24efb81fe20467a2d915ee51479bced06cfc", + "scripts/three_stage_cover/select.py": "457e636ced9bbd368198f78e015660a929ba1aaccbe34122d18da09ebb488f33", + "scripts/three_stage_cover/verify.py": "4bd2347e87e4edb699968bc31dfb94f2ab89bf1227576e59f43c779ba74e4e06", + "scripts/three_stage_cover_network.py": "7e0ad6fd1921b6905a53ce1eeaa03d3bb3a8a8bbaa0382516ea98b636f46335e", + "scripts/three_stage_cover_producer.py": "ea6dd4f06173304bbcb74b8e5bcc02357b7bb162a6d26b4a6f7a9e886158123f" + }, + "status": "Conditional three-stage cover multiplication witness" +} diff --git a/docs/partial-gauge.md b/docs/partial-gauge.md new file mode 100644 index 0000000000..dd5c670a51 --- /dev/null +++ b/docs/partial-gauge.md @@ -0,0 +1,65 @@ +# Partial-gauge reproduction + +This extension inherits PR #104 at +`948ce1510df750f4c18b96bdaef436a86f8bf834` and gives the conditional saving +`7237/78125000 = 9.26336e-5`. Proofs are supplied as LaTeX source. + +From the repository root, with Python 3.11+ and a C++17 compiler: + +```sh +make partial-gauge-verify +``` + +CI runs this extension in its own `partial-gauge` matrix group. The +incremental target performs three checks: + +- `partial_gauge_bit.py` checks pinned PR #97 source hashes, reconstructs + auxiliary and data ranks from its actual frozen paths, matches the physical + ledger receipt, and rebuilds the whole-projector child list. The unchanged + upstream complete-basis scalar and rational frame audits are inherited. +- `partial_gauge_producer.py` rebuilds the selected h24 interval/cube DAG, + compatible matching, backward enlarged frames, physical word and partial + source gauges. Independent checks cover exact supports and signed decoder, + frame nondegeneracy and nesting, center closure, untouched source roles, + reverse readout order and every positive-rank transition. The deterministic + construction also reproduces the complete histogram, including zero-rank + no-ops; see [the producer guide](../scripts/partial_gauge/README.md). +- `partial_gauge_network.py` certifies both strict moments, the stopped + ordinary-bit saving, denominator-21 semantic charge, product row stock, + all 47 strict constraints and seven assembly margins. It writes the + deterministic, source-bound `certificates/partial-gauge-network.json`. + +For arithmetic and the pinned bit profile alone: + +```sh +make partial-gauge-certificate +``` + +Generated complex graphs are temporary by default. To retain them and a +compact report outside the repository: + +```sh +python3 scripts/partial_gauge_producer.py --work-dir /tmp/partial-gauge-work --output /tmp/partial-gauge-verification.json +``` + +The selected proof is [partial-gauge-note.tex](../notes/partial-gauge-note.tex). +The source notices and compact PR #97 witness remain under +`references/partial-gauge/`. Unselected experiments, large generated graphs, +recursive handoff copies and PDFs are excluded. + +## Shared source bindings + +The joint-dual manifest also binds `Makefile`, `README.md` and `NOTICE`. +This round refreshes those three digests and the two derived certificate +digests. Its producer, physical words, frame profiles and mathematical +certificate fields are unchanged from PR #104's successful local replay. +Incremental validation checks that equality and reruns the joint arithmetic; +it does not repeat the unchanged graph and complete-basis suites. + +After reviewing changes to those shared files, the explicit manifest refresh +is `python3 scripts/experiments/pin_joint_dual_sources.py`. Its derived +`joint-dual-kappa.json` and `joint-dual-validation.json` must also be updated. +The full affected replay command, when needed, is `make verify-joint`. +CI checks the committed source bindings and requires deterministic output; +it never silently repins sources. Stage the final artifacts before the +reproducibility check and require `git diff --exit-code` to remain clean. diff --git a/docs/reproducibility.md b/docs/reproducibility.md index e48f4190cd..8f70a8f12b 100644 --- a/docs/reproducibility.md +++ b/docs/reproducibility.md @@ -1,5 +1,18 @@ # Reproducing the result +For the three-stage cover extension, run `make three-stage-cover-verify`. +The [incremental guide](three-stage-cover.md) covers the new PR #117 local +word, cover moments and exact assembly. + +For the partial-gauge extension, run `make partial-gauge-verify`. Its +[incremental guide](partial-gauge.md) separates the pinned PR #97 bit input, +new complex producer and exact assembly. + +For the new stopped product-ring extension, run `make stopped-product-verify`. +Its [incremental reproduction guide](stopped-product.md) covers the h24 +rational-center producer, new moments, stopping parameters and assembly. +The community checkpoint and historical targets below retain their own scope. + The selected release is documented in the [joint-frame community review](research/community-round2-review.md) and [current status](research/current-status.md), with the [selected parameter certificate](../research/matrix-exponent-synthesis/candidate/arithmetic.json). diff --git a/docs/stopped-product.md b/docs/stopped-product.md new file mode 100644 index 0000000000..5bc1cbc88e --- /dev/null +++ b/docs/stopped-product.md @@ -0,0 +1,67 @@ +# Stopped product-ring reproduction + +The extension gives the conditional saving `194869/2500000000 = 7.79476e-5`. +It starts from merged PR #36 and is submitted on upstream main at +`56b66d58297deca1d7dd130247d720e960f77a37`. + +From the repository root, with Python 3.11+, Make and a C++17 compiler: + +```sh +make stopped-product-verify +``` + +The incremental checks: + +- Match the unchanged positive-label h23 bit producer to its verified + copied-center input, preserving the same matching and histogram. +- Rebuild only the new h24 all-disjoint complex producer with aligned pair + stars, exact rational center decoding, support and binary-frame checks, + then reproduce every matching count and histogram entry. +- Reconstruct both child lists and strict rational moments; derive the + stopped ordinary-bit saving and check that the atom-adapter toll is lower. +- Check the denominator-21 semantic charge, product row stock `p^4000`, + seven assembly margins and all 47 strict constraints. + +Intermediate DAGs and the matcher executable are temporary. To retain them: + +```sh +python3 scripts/stopped_product_producer.py --work-dir /tmp/stopped-product-producers +``` + +For arithmetic alone, use `make stopped-product-certificate`. The inherited +`make verify-producers` also includes this target; the full `make verify` +retains the community and historical checks. Those unchanged suites are +not part of this round's local incremental validation. + +The [proof](../notes/stopped-product-note.tex) is supplied as LaTeX source; +no PDF is generated. Its common-basis factorization, atom streaming and +stopping argument, outer ordinary conversion and shared exact rational +grid are written proofs. Finite checks verify the selected scalar data and +arithmetic, not the complete all-size theorem. + +[SOURCES.json](../SOURCES.json) and [NOTICE](../NOTICE) preserve contribution +credits and source pins. Existing two-stage, ordinary-leaf and semantic +proof dependencies remain in `references/copied-centers/` and +`references/semantic-bulk/`. Research alternatives, raw binary DAGs and +recursive predecessor copies are excluded from this submission. + +## Shared source bindings before submission + +The inherited `research/joint-dual/SOURCE.json` also binds the repository's +`Makefile`, `README.md` and `NOTICE`. Adding a verification target or editing +those documents therefore affects the joint-frame check even when its +mathematical construction is unchanged. + +After reviewing such source changes, refresh the manifest and regenerate +its dependent certificate and validation receipt: + +```sh +python3 scripts/experiments/pin_joint_dual_sources.py +make verify-joint +``` + +Include `research/joint-dual/SOURCE.json`, `certificates/joint-dual-kappa.json` +and `certificates/joint-dual-validation.json` in the same submission. Check +that their changes are the expected source bindings, then rerun the affected +check against the staged artifacts and require a clean diff. CI verifies +the committed bindings; it does not refresh them automatically. diff --git a/docs/three-stage-cover.md b/docs/three-stage-cover.md new file mode 100644 index 0000000000..38554e1fb3 --- /dev/null +++ b/docs/three-stage-cover.md @@ -0,0 +1,74 @@ +# Three-stage cover reproduction + +The extension inherits PR #115 at +`cf60442983c153a3a0f5272ea4713f99eba13c86` and gives the conditional saving +`3146011/10000000000 = 3.146011e-4`. + +From the repository root, using Python 3.11+ and a C++17 compiler: + +```sh +make three-stage-cover-verify +``` + +CI runs this target in its own `three-stage-cover` matrix group. Its +incremental scope is: + +- Rebuild the new pinned PR #117 local DAG, compatible matching, full backward + subspace intersections, actual scalar word and partial source gauges. + Independently check scalar supports, signed coefficients, divisor 21, + carrier containment, center closure, untouched source roles, actual frame + transitions and reverse target chains. Intermediate frames can be + degenerate; their validity follows from the new general Clifford proof. +- Reconstruct the unchanged PR #97 local physical ranks from its pinned + paths, then compose the new three-stage bit inventory. The unchanged + upstream complete-basis and rational-frame suites are inherited checks. +- Certify the bit moment with the full rare-class local-ring fallback, + stopped ordinary saving, complex moment, full finite group order and + router charge, exact semantic guard, row reserve, 47 strict inequalities + and seven assembly margins. + +For the moments and arithmetic alone: + +```sh +make three-stage-cover-certificate +``` + +The group is specified by a written construction; verification does not +materialize its vertices. The complex group size and finite routing allowance +remain in the certificate. The bit group depends on atom width; its uniform +batching, weighted children and internally borrowed rows are proved in +`notes/three-stage-cover-bit.tex` and `notes/three-stage-cover-rows.tex`. +Finite arithmetic does not by itself verify those all-size interfaces. + +To retain regenerated local files outside the repository: + +```sh +python3 scripts/three_stage_cover_producer.py --work-dir /tmp/three-stage-cover-work --output /tmp/three-stage-cover-verification.json +``` + +The [main proof](../notes/three-stage-cover-note.tex) includes +[general Clifford frames](../notes/general-clifford-frames.tex), exact data +chronology and phases, complete dirty cleanup, weighted factorization, +fallback, row restoration and final composition. Sources are included +without a PDF. `SOURCES.json`, `NOTICE` and `references/three-stage-cover/` +retain the adopted author's source pins and original legal notices. + +The previous submitted production code and certificates remain unchanged. +Unselected round7/round8 research and large generated graphs are excluded. +Only the new selected local construction and changed cover/assembly are +verified this round. + +## Shared source digests + +Changes to `Makefile`, `README.md` and `NOTICE` also affect the inherited +joint-dual source manifest. After reviewing their final content, explicitly +run `scripts/experiments/pin_joint_dual_sources.py`, regenerate the joint +arithmetic certificate, and update its validation receipt's certificate +digest. The unchanged mathematical fields and prior replay payload must +match the preceding submission. A full producer replay is required when +those producer or verifier inputs change; the full command is +`make verify-joint`. + +The final reproducibility check runs against staged artifacts and requires +`git diff --exit-code` to remain clean. CI verifies committed hashes and +does not silently refresh source pins. diff --git a/notes/general-clifford-frames.tex b/notes/general-clifford-frames.tex new file mode 100644 index 0000000000..0367eeb005 --- /dev/null +++ b/notes/general-clifford-frames.tex @@ -0,0 +1,102 @@ +\subsection{Preimage frames for arbitrary binary subspaces} +This frame construction is due to icekylinx with OpenAI GPT-6 Astra assistance; +the present exposition and integration use Codex. +Let $H=\mathbb F_2^h$ with the standard dot product. In the binary +symplectic space $H\oplus H$ put +\[ + L_0=\{(0,z)\},\qquad + F=\begin{pmatrix}I&I\\0&I\end{pmatrix},\qquad + L_F=FL_0=\{(z,z)\}. +\] +We also write $F$ for the exact Gaussian-dyadic operator $C^{\otimes h}$. +Its exact square is a Pauli translation; only its binary symplectic square +is the identity. For an exact Clifford operator $T$ the frame label is +$L(T)=T^{-1}L_0$. The physical transition from $T$ to $S$ is $ST^{-1}$, +and its Fourier rank is +$d(L(S),L(T))$, where $d(L,L')=h-\dim(L\cap L')$. +This follows by transporting the intersection by $S$: the intersection +with $L_0$ computes the kernel dimension of the $B$ block of $ST^{-1}$. + +\begin{lemma} +For every subspace $U\subseteq H$, including degenerate subspaces, +\[ + L_U=\{(u,u+v):u\in U,\ v\in U^\perp\} +\] +is Lagrangian, and +\[ + d(L_U,L_V)=\dim U+\dim V-2\dim(U\cap V),\qquad + FL_U=L_{U^\perp}. +\] +\end{lemma} +\begin{proof} +The displayed parametrization is injective and has dimension $h$. +Its symplectic pairing is $u\cdot v'+v\cdot u'=0$. +In an intersection, $u$ belongs to $U\cap V$ and $v$ to +$(U+V)^\perp$, giving the asserted dimension and distance. +Finally $F(u,u+v)=(v,u+v)$ proves the complement identity. +\end{proof} + +\subsection{Exact representatives and nested children} +Choose a deterministic invertible binary matrix $G$ carrying the first +$r=\dim U$ coordinate space $E_r$ to $U$, and set +\[ + K_G=\begin{pmatrix}G&0\\G+G^{-T}&G^{-T}\end{pmatrix},\qquad + T_U=K_G T_{E_r}K_G^{-1}. +\] +Here $T_{E_r}$ is the exact coordinate $C$ operator, and the $K_G$ are +exact Gaussian-dyadic Clifford lifts. The matrix $K_G$ is symplectic +because $G^TG+I$ is symmetric. It fixes both $L_0,L_F$ and maps $L_V$ +to $L_{GV}$. Thus both $K_G$ and $FK_GF^{-1}$ have Fourier rank zero; +their lifts are fixed binary address permutations with unit quadratic +phases. In particular, +\[ + L(T_U)=L_U,\quad \operatorname{rank}B(T_U)=r,\quad + \operatorname{rank}B(FT_UF^{-1})=r,\quad T_U^2\text{ is Pauli}. +\] +Set $V_U=GE_r^\perp$, a direct complement of $U$. The binary action gives +$T_U^{-1}L_F=L_{V_U}$ and hence +$\operatorname{rank}B(FT_U^{-1})=h-r$. +No assertion $V_U=U^\perp$ is needed. +For the norm-one source lines and their orthogonal target hyperplanes, +retain the inherited exact representatives; set $T_0=I,T_H=F$. +At every common scalar gate use one identical exact representative on all +incident registers. If separately transported representatives have the +same preimage, their physical ratio has rank zero and is implemented as +an actual left adapter before the gate. + +For $U\subseteq V$, the exact transition $T_VT_U^{-1}$ has rank +$\dim V-\dim U$. Clifford elimination expresses it as two rank-zero +adapters surrounding that many coordinate Fourier factors. These factors +are a single $C^{\otimes r}$ child: the scaled Hadamard satisfies +\[ + \frac{1+i}{2}\begin{pmatrix}1&1\\1&-1\end{pmatrix} + =SCS,\qquad S=\operatorname{diag}(1,i). +\] +Thus no new irrational field is introduced. All adapters are charged +finite movement and scalar operations. Exact transitions telescope; +commutativity between distinct $T_U$ is unnecessary. + +\subsection{Dirty tails and reverse/complement words} +A dirty role entering with gauge $T_\sigma$ and whose last active frame +is $T_U$, with $\sigma\subseteq U$, is assigned terminal gauge +$FT_\sigma$. Its logical value is restored by the complete transparent +scalar word, so its physical action is exactly $F$. The tail is +$FT_\sigma T_U^{-1}$. Its rank is +\[ + d(L_U,L_{V_\sigma})=h-\dim U+\dim\sigma. +\] +Indeed $H=\sigma\oplus V_\sigma$ and $U\supseteq\sigma$ imply +$\dim(U\cap V_\sigma)=\dim U-\dim\sigma$. +An inactive exterior adds $m-h$, giving $m-\dim U+\dim\sigma$. + +For the complete time-reversed word use +\[ + D_U=T_UF^{-1},\qquad L(D_U)=L_{U^\perp},\qquad + D_UD_V^{-1}=T_UT_V^{-1}. +\] +The last equality is exact, so reversal preserves every inverse transition +rank. Reverse the scalar signs and the whole transparent word, including +old-value corrections and final cleanup. The endpoints $D_0=F^{-1}$ +and $F$ differ by a Pauli, and the inherited norm-one endpoints are +reconciled by actual rank-zero adapters. Neither equality of binary +matrices nor equality of frame cosets substitutes for these operators. diff --git a/notes/partial-gauge-assembly.tex b/notes/partial-gauge-assembly.tex new file mode 100644 index 0000000000..4a09f324a3 --- /dev/null +++ b/notes/partial-gauge-assembly.tex @@ -0,0 +1,101 @@ +\subsection{Literal two-stage inventory and semantic precision} +Let $B_a$ count selected gauges of dimension $a$, and $H_r$ the remaining +internal histogram, including each residual first transition. Let $D_r^x$ +and $D_r^y$ be the source and target data-chain histograms. Put +\[ + m=h^2=576,\quad N=v^2=4096576,\quad + W=2N+2vR=147067888. +\] +The child inventory consists of $2v(R-\sum_aB_a)$ exteriors of width +$m-h$, $2vB_a$ exteriors of width $m-h+a$, $2vH_r$ internal children, +$2v(D_r^x+D_r^y)$ data-chain children, $2N$ connectors of width +$(h-1)^2$, and $N$ paid correction children of width one. Zero-width +transitions require no recursive call. Per-role telescoping gives +\[ + s=\sum_r rn_r=Wm-N+2v\ell=84709241408, + \qquad r_{\max}=574. +\] +Writing $F$ for the full transform and $T$ for the source-line transform, +the retained signed endpoint is +$X'=-Fy$, $Y'=FT^{-2}x+FT^{-1}y$. +Pretranslate the initial $x$ bank by the fixed Pauli translation $T^2$, +then add $T^{-1}X'$ to $Y'$ using the paid rank-one copy. Sign and bank +corrections yield both $F$ outputs. The translation $T^2$ is retained. + +The rational logarithm and exponential enclosures in +\path{scripts/partial_gauge_network.py} prove, for $b=92651/10^9$, +\[ + \frac1W\sum_r n_r(r/m)^{1-b} + <1-4.1393037848\times10^{-11}. +\] +The finite receipt supplies a scalar-operation bound +$G=401572403009697216$, including direct rational dirty reads and the +signed correction. Set +\[ + E=64(W+m+G+1)^3,\quad B=s+E,\quad C_0=32mB^2. +\] +It verifies $2GW^2+8s+4W+4+32ms+E$. Thus the inherited completed-child induction applies +with semantic $C_1=1$. On one exact grid $2^{-P}21^{-K}$, +$K=G(D_c+1)$, unfinished calls can accumulate at most $K$ odd-denominator +factors. Completed children are Gaussian-dyadic $C^{\otimes u}$ and add +none. The root dyadic-input divisibility invariant makes each local +21-division exact; only the outer boundary scales and unscales, at cost +$O(V_{\rm bits}\log d)$. No recursive boundary rounds or re-encodes values. + +\subsection{Joint rows and conditional transfer} +The coarse bit, ordinary leaf and complex families have respective +halving-degree and wire-bit pairs $(367,27),(9,28),(200,28)$. +Their product stock has coefficient +\[ + 367\cdot27+9\cdot28+200\cdot28=15761, + \qquad40000-\frac{51}{25}\,15761=\frac{196189}{25}>0. +\] +One $p^{40000}$ reserve, one preceding prefix and one final padding suffice +under the retained eventual row contract. Sequential calls reuse restored +rows and preserve complete spectators. + +Choose +\[ + \eta=10^{-8},\quad\beta=10^{-6},\quad + a=(1-\beta)b-10^{-10}=\frac{92650807349}{10^{15}}, + \quad\tau=1-a,\quad\sigma=1-b, +\] +\[ + q_0=a(1-2\eta),\quad c=q_0(1+\eta),\quad + \epsilon=\frac{1-\eta}{1+c+q_0},\quad + \lambda'=1-q_0,\quad\lambda=(\tau+\lambda')/2, +\] +\[ + g=\epsilon q_0,\qquad r=(g+1-\epsilon)/2,\qquad\delta=\eta/8. +\] +Here $a0. +\] +\begin{theorem} +Under the retained analytic, semantic-precision, exact-recovery and +fixed-tape interfaces, the selected construction gives +\[ + T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad + \boxed{\kappa=\frac{7237}{78125000}=9.26336\times10^{-5}}. +\] +\end{theorem} +\begin{proof} +The stopped word supplies the required ordinary interchange contract; +the signed framed program supplies the exact completed complex tensor +contract. The common grid and product reserve meet the retained precision +and row requirements. Substitution of the displayed parameters into the +unchanged semantic/bulk transfer yields its seven savings. Their strict +excess over $\kappa$ absorbs the fixed logarithmic overheads, including +outer grid conversions, and proves the stated conditional bound. +\end{proof} diff --git a/notes/partial-gauge-construction.tex b/notes/partial-gauge-construction.tex new file mode 100644 index 0000000000..147fc5ab91 --- /dev/null +++ b/notes/partial-gauge-construction.tex @@ -0,0 +1,60 @@ +\subsection{Stopped opposite-bank bit word} +Apply the factorization in \path{notes/stopped-product-factorization.tex} +to each rank increment of PR97's literal deferred word: a rank-$r$ +projector increment is one recursive rank-$r$ reversed child, with the +fixed atom adapters charged as in \path{notes/stopped-product-interface.tex}. +The selected finite profile has +\[ + m_b=529,\quad W_b=108516254,\quad s_b=57403754177, + \qquad r_{\max,b}=528. +\] +Its rational moment certificate proves coarse saving +$15513/125000000$, with normalized gap exceeding $1.1417\times10^{-10}$. +The atom exponent $10^{-3}$ and retained ordinary leaf saving +$384599/10^{10}$ give the stopped ordinary saving +\[ + a_b=(1-10^{-3})\frac{15513}{125000000} + +10^{-3}\frac{384599}{10^{10}} + =\frac{1240183559}{10^{13}}. +\] +The exact inputs and calculation are +\path{certificates/partial-gauge-bit-input.json}, checked by +\path{scripts/partial_gauge_bit.py}. + +\subsection{Interval and pair-first cube producer} +For disjoint strip values $v_0,\ldots,v_{k-1}$ construct cyclic intervals +$I(a,1)=v_a$ and $I(a,l)=I(a,l-1)+v_{a+l-1\bmod k}$ for $2\le l2r_j^{t_j}$ gives depth at most +$t_j\lceil\log_2\max(2,e)\rceil$ plus a fixed constant. +The new coarse bit family has $(t_j,\operatorname{bitlength}W_j)=(16,28)$, +the ordinary leaf family $(9,28)$, and the complex family $(17,28)$. +The required reserve is the product of all three stocks: +\[ + Q=W_c^{D_c}W_b^{D_b}W_{\rm old}^{D_{\rm old}}. +\] +After the complex and coarse divisions, the old stock remains available +to every peeled-atom or stopped-leaf call. Sequential copies and outer +ordinary wrappers reuse restored rows; they introduce no independent +row factor. The combined coefficient is +\[ + 16\cdot28+9\cdot28+17\cdot28=1176, + \qquad4000-\frac{51}{25}\,1176=\frac{40024}{25}>0. +\] +Thus the retained logarithmic comparison, for eventual $e\le Cp$, +supplies a sufficient $p^{4000}$ stock including the fixed constants. +Use one physically preceding transformed prefix and one complete-row +padding, as in \path{notes/structured-bulk-assembly.tex}. Complete +spectators and parked fields are preserved by every descendant. +The suffix condition +$b_{\rm in}^{1-\epsilon}>16000(\log_2b_{\rm in}+8)$ is eventual +for every fixed $\epsilon<1$. + +\subsection{Analytic transfer and selected parameters} +The retained analytic proof map in +\path{notes/structured-bulk-assembly.tex} supplies the active-masked +arbitrary-source router with paid repair scans, the rounded phase-cell +inverse, persistent bulk halos with original period cuts, sequential +overlap tapes and factor pages, prime packing and exact recovery. +The new ordinary bit primitive has precisely the arbitrary-width, +complete-spectator and restored-row contract consumed by that router. +The new complex primitive supplies the exact completed tensor contract +on one common grid. Its outer grid conversions add only logarithmic +work. The changed finite implementations therefore meet the same +analytic interfaces, including the full bulk bound +\[ + O\!\left(Tp\left[p^\tau\operatorname{polylog}p+ + d\operatorname{polylog}p+dp^\delta+w_G^2p^\delta+ + dw_G^2p^\delta/L\right]\right)+n^{o(1)}, +\] +where $L=2^{\lceil8\log_2p\rceil}$, Gaussian band width +$w_G^2=O(p^{1-r})$, and normalization retains $\epsilon+r<1$. +Here $w_G$ is unrelated to the address atom width. + +Use the proved ordinary bit saving $a_b=803380799/10^{13}$ and complex +saving $b=1949/25000000$. To instantiate the retained assembly, weaken +the bit parameter explicitly to +\[ + \beta=10^{-6},\qquad + a=(1-\beta)b-10^{-10}=\frac{1948995551}{25000000000000}6.6129027953\times10^{-11}>0. +\] +The strict gaps absorb fixed logarithms, including the common-grid +conversions. The stopped atom recurrence supplies the ordinary +interchange interface, the rational-center construction supplies the +exact complex interface, and the product stock supports all nested +recursions. The unchanged analytic transfer then proves the stated +bound, with its constructive setup, descriptor and catalogue domination, +prime-existence and exact-recovery thresholds retained as eventual +conditions. +\end{proof} diff --git a/notes/stopped-product-complex.tex b/notes/stopped-product-complex.tex new file mode 100644 index 0000000000..4a9037137c --- /dev/null +++ b/notes/stopped-product-complex.tex @@ -0,0 +1,137 @@ +\subsection{All-disjoint retained centers} +Use two factors $h=24$. For triple inputs write $G=\sum_TX_T$, +$T_i=\sum_{T\ni i}X_T$, and retain all $A_i=G-T_i$. +Each input triple avoids exactly 21 points, so +\[ + \sum_{i=1}^{24}A_i=21G,\qquad G=\frac1{21}\sum_i A_i. +\] +For a target triple $S$ the central correction is +\[ + G-\frac12\sum_{i\in S}A_i + =\frac{\sum_{i\in S}T_i-G}{2}. +\] +An input triple meeting $S$ in $j$ points has central coefficient +$(j-1)/2$. Adding half the disjoint sum and subtracting half the +intersection-two sum leaves coefficient one exactly when $j=3$. +The scalar source-to-scatter transfer is therefore the identity. +The transparent old-value subtraction and new-value addition use this +identity only on fresh contributions and restore arbitrary old values. + +The base-two paired exclusion and aligned pair-star producer retains +nested binary labels: common-pair supports have their orthonormal triple +span, other ordinary sums have their coordinate cover. Each retained +$A_i$ has the nondegenerate coordinate hyperplane excluding $i$, +of dimension 23. Hence all copied-center arguments and general +nondegenerate binary residuals of the preceding proof apply. The +selected local counts are +\[ + v=2024,\quad c_h=45764,\quad q_h=8120,\quad + |\mathcal M|=8966,\quad R=44918,\quad\ell=552. +\] +The old internal histogram, starting at rank zero, is +\begin{small}\begin{align*} +[&8930,49042,30844,15972,11883,8272,6399,4356,6682,2263,\\ + &5109,1808,5317,1733,5391,1757,4908,3290,6233,4363,\\ + &4056,264,564,24,24]. +\end{align*}\end{small} +It has rank mass $24R+2\ell$. Replace 24 rank-24 original transitions +by 24 rank-one transitions; all rank-23 copied transforms remain. +The new mass is $24R+\ell$. + +\subsection{Physical endpoints and strict complex moment} +The copied-center two-stage complex contract in +\path{notes/copied-centers-complex.tex} is unchanged by the scalar +center decoding. For the tensor triple line $U$, let +$T=C_U$, $F=C_I$, $E=C_{U^\perp}=FT^{-1}$. +The two data outputs are $A=-Fy$ and $B=FT^{-2}x+Ey$. +Add $T^{-1}$ applied to a copy of $A$ into $B$, paying one rank-one +child per data pair. The inherited input/output $Z$ phases and +$i^{9f}$ scalar normalize $FT^{-2}$ to $F$; sign and bank corrections +complete the exact tensor $C$. Auxiliary source/sink operators remain +$C_{D_0}$ and $FC_{D_0}$ in the second stage. Every original role +therefore returns the exact selected-axis tensor operation on arbitrary +inputs. This algebraic statement holds over $\mathbb Q(i)$ as well as +over Gaussian dyadics. + +With $m_c=576$, $N_c=v^2=4096576$, $B_c=vR=90914032$, put +\[ + W_c=2N_c+2B_c=190021216,\quad L_c=2v\ell=2234496, +\] +\[ + s_c=W_cm_c-N_c+L_c=109450358336,\qquad N_c-L_c=1862080. +\] +The complete list is $2B_c$ width-552 auxiliary exteriors, +$2N_c$ width-529 data macros, $2vH'_r$ width-$r$ internal children, +$4N_c$ width-23 data fronts, and $N_c$ width-one endpoint copies. +These disjoint classes include both kinds of paid copies and sum to +$s_c$. All binary residuals, including alternating forms, use the retained +one-child Gauss normal form with paid bit adapters and unit phases. +At $a_c=1949/25000000$ the exact rational enclosure gives +\[ + \sum_r\frac{n_r}{W_c}(r/m_c)^{1-a_c} + <1-1.3338373969\times10^{-10}. +\] + +\subsection{One exact odd-denominator grid} +The only new odd divisor is 21. Let $d$ bound the root axis count, +$D$ bound its maximum complex recursion depth, and $G_0$ bound the +number of grouped scalar operations per node. Choose +\[ + K=G_0(D+1),\qquad \text{common grid }2^{-P}21^{-K}. +\] +Root inputs and arbitrary dirty auxiliaries start Gaussian dyadic. +Multiply their integer numerators by $21^K$ once at the outer boundary. +Every local coefficient contains at most one factor 21 in its denominator, +so a local finite program adds at most $G_0$ to the odd-denominator +exponent. A completed $u$-axis child has Gaussian-dyadic coefficients +and therefore preserves its input's existing odd-denominator exponent; +it adds no new odd factor. Only the active chain of unfinished calls +can accumulate new factors. Its length is at most $D+1$, proving that +all intermediates lie on the common grid and every local division by +21 is an exact integer division of its encoded numerator. + +This divisibility claim uses the root dyadic-input invariant, not an +assumption about arbitrary numerators on the finest grid. Internal values +may have odd denominators. They are neither rounded nor re-encoded when +a child returns. At the completed outer return the operator is the exact +Gaussian-dyadic tensor on root dyadic inputs, so the final numerators +are divisible by $21^K$; exact unscaling restores dyadic encoding. + +Since the largest child is $552<576$, $D=O(\log d)$ and +$K=O(\log d)$ with fixed constants. Constant-divisor long division +is linear in numerator length. Initial and final scaling by $K$ +successive constant multiplications/divisions cost $O(V\log d)$ and +occur only at the outer boundary. The extra numerator length is +$O(\log d)$, preserving the retained $O(p)$ word bound. This overhead +is subordinate to the positive-power complex layer bound. + +For explicit semantic constants use +\[ + g_h=4(c_h+v)+10v+4hv+4h^2+8h+8=408200, +\] +\[ + G_0=N_c+2v(g_h+2h)=1656684480, +\] +where endpoint additions and copied-center scalar work are included. +The complete child contributes at most $u$ binary denominator bits +and row-norm factor $2^u$, with no additional odd exponent. A local +21-division contributes fewer than five denominator-height bits, +covered by the fixed scalar charge. Set +\[ +\begin{aligned} + E_0&=64(W_c+m_c+G_0+1)^3=403063477262941121443761178688,\\ + \mathcal E&=2G_0W_c^2+8s_c+4W_c+4+32m_c\\ + &=1196393335930350962702877484.2909639537\times10^{-10}. +\] +It uses the retained 24-term positive atanh-series logarithm enclosure, +its geometric tail, range reduction and upward rational exponential +bound. Also $\mu_1=s_b/(W_bm_b)<1$. These are the two gaps used below. diff --git a/notes/stopped-product-interface.tex b/notes/stopped-product-interface.tex new file mode 100644 index 0000000000..20c44ce486 --- /dev/null +++ b/notes/stopped-product-interface.tex @@ -0,0 +1,95 @@ +\subsection{Paid atom adapters and remainders} +Expand each fixed lower-triangular formal factor into unit scalings and +additions from earlier to later formal fields. Execute intrabank targets +in descending formal-field order, so earlier controls still have their +required original values. Every atom update reads only physically earlier +controls. In a cross-bank shear the update is +\[ + D_{i,t}\leftarrow D_{i,t}+k_{ij}H_{j,f-1-t}. +\] +Even with the reversed source index, the source lies in the earlier head +bank. The retained ordered-affine streaming primitive applies to each +ordinary width-$w$ atom update, costing $O(V)$ per pass. +There are $O(f)$ passes per fixed matrix and thus $O(Vn)$ per finite +node. The reversed control is an indexed earlier atom, not a reversed +field operation. Atom loops use binary descriptors on a fixed tape set; +all inactive digits remain complete spectators. The inherited parking +schedule never scans through parked ancestors, and polynomial descriptor +work is absorbed by the complete stream volume. + +For $n=m_bf+\delta$, $0\le\deltaa_b$, the paid adapter term is strictly lower order. +All bounded widths use the old interface. Numerical padding of a binary +chunk range to the least suitable radix-$q$ range has volume factor +below $q^2$; it preserves numerical order and is removed after the +completed ordinary wrapper, whose endpoint is ordinary interchange. + +If external rows are unavailable, use the inherited ordinary high-digit +borrowing construction from \path{notes/batched-bit-rows.tex}. +Borrow $O(\log e)$ high digits, exchange and join them into a preceding +row field, pad that field once, act on the body, and separate the high +parts. It applies literally to the completed ordinary wrapper; no claim +about borrowed high positions is made for an unwrapped reversed call. +Single-digit moves cost $O(V\log e)$, and small widths use the old +algorithm. Atom indices and rational coefficients are finitely specified; +the algorithm uses the same fixed tape set and complete spectator ranges. diff --git a/notes/stopped-product-note.tex b/notes/stopped-product-note.tex new file mode 100644 index 0000000000..a8b23254c8 --- /dev/null +++ b/notes/stopped-product-note.tex @@ -0,0 +1,76 @@ +\documentclass[11pt]{article} +\usepackage[margin=1in]{geometry} +\usepackage[T1]{fontenc} +\usepackage{lmodern,amsmath,amssymb,amsthm,mathtools,booktabs,longtable,microtype} +\usepackage[hidelinks]{hyperref} +\setlength{\emergencystretch}{3em} +\allowdisplaybreaks +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\title{A conditional integer-multiplication saving of $194869/2500000000$\\ +\large Stopped product-ring interchange and rational retained centers} +\author{icekylinx\\\small With substantial OpenAI GPT-6 Astra and Codex assistance} +\date{9 October 2026} +\begin{document}\maketitle +\begin{abstract} +A common rational basis and opposite bank orders reduce each projector +residual to one contiguous reversed child over a fixed atom product ring. +Ordered atom adapters are paid explicitly; stopping at a growing atom +width and using the retained ordinary primitive supplies an ordinary +bit interface. An independent 24-dimensional complex producer uses +rational retained-center decoding on one exact common grid. The selected +interfaces and retained semantic/bulk assembly give the conditional bound +$T(n)=O(n(\log n)^{1-\kappa})$, where +$\kappa=194869/2500000000=0.0000779476$. +\end{abstract} + +\section{Scope and retained dependencies} +The model is the retained fixed finite-alphabet multitape Turing machine. +Finite graphs, rational bases, address primes, coefficient tables and tape +counts are fixed independently of input length. Bit payload arithmetic is +binary, while its address geometry is rational and then evaluated on atom +rings. Complex payloads use exact Gaussian rational arithmetic with the +specified common grid; their address labels remain binary. + +The proof predecessor is icekylinx's merged copied-center PR36, +\texttt{11817ccacb564bb7f98789c20dc11d3fece207e3}, whose proof is +\path{notes/copied-centers-note.tex}. Its ordinary interchange saving +$a_{\rm old}=384599/10^{10}$, copied-center schedule in both orientations, +two-stage data and auxiliary endpoint identities, general binary residual +normal form, and fixed-tape complete-row contracts are retained. +The present opposite-bank factorization, stopped product-ring interface, +rational-center specialization and exact composition are by icekylinx, +with substantial OpenAI GPT-6 Astra assistance and Codex integration. +Earlier own contributions include PR10 batching, PR18 partial swaps, +PR24 endpoint gauges and PR32 structured blocks and semantic composition. + +Aurel Prosz (Paureel) supplies the two-stage topology and paid endpoint +copy, with Swapnil Jain's linked development credited by Zhihao Chen's +PR29. The retained leaf proof also credits Rohan Arun's PR31 corner method +and Dominik Scholz's PR33 parameterization. Zhihao Chen's PR21/23 and the +RaD/hipotures PR20 source provide the phase endpoints, semantic guard, +arbitrary-source routing, phase-cell inverse and bulk locality/tape +interfaces. Their pinned proof map remains in +\path{notes/structured-bulk-assembly.tex}; adopted sources and notices are +in \path{references/semantic-bulk/} and \path{references/copied-centers/}. +The underlying Douglas Colkitt framework, OpenAI manuscript, eumemic, +Bortlesboat, dleen, earlier finite contributions and Harvey--van der Hoeven +analytic work retain their credits and recorded AI assistance in +\texttt{NOTICE} and \texttt{SOURCES.json}. + +The conclusion remains conditional on those analytic, ordered-affine, +exact-recovery and machine interfaces and their eventual setup and +prime-existence thresholds. The new algebraic and tape constructions +below establish the changed finite interfaces; exact arithmetic certifies +their selected counts and margins. + +\section{One reversed child for each projector} +\input{notes/stopped-product-factorization.tex} +\section{Stopped atom recursion and ordinary interchange} +\input{notes/stopped-product-interface.tex} +\section{Rational centers and exact semantic precision} +\input{notes/stopped-product-complex.tex} +\section{Product rows and exact assembly} +\input{notes/stopped-product-assembly.tex} +\end{document} diff --git a/notes/three-stage-cover-assembly.tex b/notes/three-stage-cover-assembly.tex new file mode 100644 index 0000000000..983ffb6ac8 --- /dev/null +++ b/notes/three-stage-cover-assembly.tex @@ -0,0 +1,117 @@ +\subsection{Local inventory and strict supplier moments} +The selected complex local word has +\[ + h=24,\quad v=2024,\quad c=91770,\quad q_{\rm roots}=8120, + \quad |\mathcal M|=71185,\quad R=28705,\quad\ell=552. +\] +Its complete scalar word, full backward subspace intersections and 4,599 +partial source gauges are regenerated from the pinned compressed DAG by +\path{scripts/three_stage_cover_producer.py}. The source and target chains, +remaining first transitions, inverse cleanup and copied centers remain in +\path{certificates/three-stage-cover-complex-input.json}. +At each cover vertex its child inventory is exactly the three-stage table +proved above. Thus $m_c=70$, $w_c=90163$, $s_c=6309018$ and +$w_cm_c-s_c=2392$; the largest child is 68. + +For $a_c=786999/2500000000$, the rational enclosure proves +\[ + \frac1{w_c}\sum_r n_r(r/70)^{1-a_c} + <1-2.3047018455\times10^{-10}. +\] +The bit local ledger has $h=23,v=1771,R=28866,\ell=506$. +Three copies of its physical local increments and exteriors give +$m_b=67,w_b=90140,s_b=6037356$, with deficit 2024. +The contaminated moment includes the entire $32\cdot67^2$-child fallback +on a fraction $10^{-16}$ of every ideal edge. At $a_0=747/2000000$ its +strict gap exceeds $6.3397366396\times10^{-7}$, and its rank moment also +contracts. The stopped ordinary saving is +\[ + a_b=(1-10^{-3})a_0+10^{-3}\frac{384599}{10^{10}} + =\frac{3731649599}{10^{13}}. +\] +These are exact rational certificates; the lower tolerances displayed +here do not substitute for their saved fractions. + +\subsection{Full finite router and completed-child guard} +Let $V_0=|O(70,2)|$, $N=V_0v$, $W=V_0(2v+3R)$ and $s=V_0s_c$. +All these finite counts appear in the certificate. Define +\[ + L=4(c+v)+10v+4hv+4h^2+8h+8+2h + +8Rv(M+16), +\] +where $M$ is the number of actual local mixer operations. +The source-witness bound for the positive DAG gives dirty-readout +coefficients of magnitude at most $h+4$, with denominators dividing +$2(h-3)$. The last term conservatively pays their binary-addition +implementation. Include the finite group and fixed Clifford routers by +\[ + G=N+3V_0L+64(m_c+1)^3W^2. +\] +A fixed role permutation has at most $W^2$ elementary exchanges; the +polynomial factor also covers the binary matrix and quadratic-phase +adapters. These finite costs retain their ordinary movement charge. +Set +\[ + E=64(W+m_c+G+1)^3,\quad B=s+E,\quad C_0=32m_cB^2. +\] +The exact calculation checks +\[ + 2GW^2+8s+4W+4+32m_c0. +\] +Thus the fixed external reserve $p^{160000}$ meets the inherited product +stock contract. The width-dependent q-adic selectors are supplied by +the separate internal borrowing proof, rather than multiplied into this +external polynomial stock. One preceding prefix and one final padding +suffice, and sequential completed calls reuse restored rows. + +Put $b=a_c$, $\eta=10^{-8}$, $\beta=10^{-6}$ and +\[ + a=(1-\beta)b-10^{-10}2^{80}$ avoiding all fixed rational denominators and rank witnesses. +At atom width $w$ use the finite cover $\operatorname{GL}_m(R_w)$ and its +right-multiplication edges $g\mapsto gR_s$. Every vertex has the unique chart +\[ + g=g_0+qG_1,\quad g_0\in\operatorname{GL}_m(\mathbb F_q), + \quad G_1\in(\mathbb Z/q^{w-1}\mathbb Z)^{m^2}, +\] +using fixed representatives for $g_0$. Right multiplication permutes $g_0$ +and acts affinely on $G_1$, with a carry determined by $g_0$. Its fixed +dimensional rational linear part factors into fixed scalings, ordered +shifts and a constant number of old width-$O(w)$ interchanges. Thus each +fixed port routing costs $O(Vw^{1-a_{\rm old}})$. + +Let $W_0=|\operatorname{GL}_m(\mathbb F_q)|(2v+3R_{\rm loc})$. +The full role count is $W(w)=W_0q^{m^2(w-1)}$. Split preceding rows into +low role type, high matrix and unused stock. Batch \emph{all} high matrices +for each low type in one stream. A frame edge is one child on this whole +batch, of volume $V/W_0$, and routing is executed once per fixed operation +type. Consequently neither the number of tapes nor the number of child +programs grows with $w$. High cardinality cancels in the normalized moment, +but its $m^2(w-1)$ digits are charged in the row reserve. + +For each fixed projector require the leading minors of sizes $1$ through +$r$ to be units. Each cleared minor polynomial in $g_0$ is nonzero: +similarity to $\operatorname{diag}(I_r,0)$ supplies a witness after the +fixed rank is preserved modulo $q$. Their total degree is at most $m^3$. +The polynomial zero bound and conditioning on invertibility (a factor at +most two) give bad fraction at most $2m^3/q<10^{-16}$ for each edge type. +No simultaneous union bound over edge types is needed, since their moments +are averaged separately. Good classes use the whole-rank child; bad +classes use the full $32m^2$-child fallback just proved. + +Let $H_r$ be the three-stage histogram described above and +$W=2v+3R_{\rm loc}=90140$. The retained ledger gives +\[ + \sum_r rH_r=6037356,\qquad Wm-\sum_r rH_r=2024=2v-3\ell, + \qquad \max\{r:H_r>0\}=66. +\] +For $a=747/2000000$, $\tau=1-a$, and $b=10^{-16}$ the conservative moment is +\[ + \mu_\tau\le + \sum_r\frac{H_r}{W}(r/m)^\tau+ + b\frac{32m^2\sum_rH_r}{W}(1/m)^\tau<1. +\] +The entire fallback is added; no displaced good contribution is subtracted. +The exact script \path{scripts/three_stage_cover_network.py} and certificate +\path{certificates/three-stage-cover-network.json}, from the retained axis +\path{certificates/three-stage-cover-bit-input.json}, give +$1-\mu_\tau>6.3397366396\cdot10^{-7}$. +The certificate uses the 32-term positive atanh logarithm series with its +geometric tail, $\exp(u)\le1+u+u^2/(2(1-u/3))$, and upward rounding to +the grid $2^{-120}$. All inputs have $0\le u<3$; these are rational upper +bounds, not floating-point root estimates. Since every child ratio is at +most one and $\tau<1$, this same strict bound implies $\mu_1<1$. + +With $T(n,w)$ denoting time divided by logical volume, the fixed low-type +profile $\{c_r\}$, including fallback classes, satisfies +\[ + T(n,w)\le\sum_rc_rT(r\lfloor n/m\rfloor,w)+Cn+Cw^{1-a_{\rm old}} + \quad(n\ge m),\qquad + T(n,w)\le Cw^{1-a_{\rm old}}\quad(n2\,68^d$ is 24, so the complex row coefficient is +$24\cdot2431=58344$. These full finite role counts are retained in the +scalar guard and row stock. Group elements and involutions are specified +by their binary matrices; the definition needs no numerical enumeration. +All fixed address adapters, endpoint Paulis and invocation permutations +are implemented inside the finite scalar/router guard of the assembly. diff --git a/notes/three-stage-cover-note.tex b/notes/three-stage-cover-note.tex new file mode 100644 index 0000000000..f5ad09a450 --- /dev/null +++ b/notes/three-stage-cover-note.tex @@ -0,0 +1,63 @@ +\documentclass[11pt]{article} +\usepackage[margin=1in]{geometry} +\usepackage[T1]{fontenc} +\usepackage{lmodern,amsmath,amssymb,amsthm,mathtools,microtype} +\usepackage[hidelinks]{hyperref} +\setlength{\emergencystretch}{3em} +\allowdisplaybreaks +\newtheorem{theorem}{Theorem}[section] +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\title{Three-stage covers for a conditional integer-multiplication saving\\ +\large $\kappa=3146011/10000000000$} +\author{icekylinx\\\small Construction with OpenAI GPT-6 Astra assistance; +integration with Codex assistance} +\date{9 October 2026} +\begin{document}\maketitle +\begin{abstract} +Three signed shears on a regular Cayley cover align all interstage data +frames. Arbitrary-subspace Clifford frames support the selected complex +word; weighted reversed interchanges on a batched finite local-ring cover +support the bit word. Exact rational moments and the retained semantic/bulk +assembly give the conditional saving $\kappa=3.146011\times10^{-4}$. +\end{abstract} + +\section{Scope and source continuity} +This extends icekylinx's +\href{https://github.com/CrocSwap/integer-mult-bounds/pull/115}{PR115}, +\texttt{cf60442983c153a3a0f5272ea4713f99eba13c86}, retaining +\path{notes/stopped-product-note.tex}, \path{notes/partial-gauge-note.tex} +and the semantic/analytic proof map in +\path{notes/structured-bulk-assembly.tex}. +The analytic reduction, exact recovery, ordered-affine streaming, +prime-packing, ordinary leaves and eventual fixed-tape setup remain +inherited hypotheses. The new group geometry, weighted compiler and +row-borrowing arguments are supplied below, rather than counted as free +operations. Finite arithmetic does not formalize the all-size theorem. + +The complex local DAG is eumemic's +\href{https://github.com/CrocSwap/integer-mult-bounds/pull/117}{PR117}, +\texttt{cbb05ce504d571546d9b7794c186a613c659c3bf}, with its original +Apache-2.0 notice and Claude assistance disclosure preserved. +The bit physical word is Zhihao Chen's +\href{https://github.com/CrocSwap/integer-mult-bounds/pull/97}{PR97}, +\texttt{e15350b66e4bf796153a68c240a6cc1b788abe3e}, based on Swapnil Jain's +\texttt{741e7aa078392553815df7926ee17ac5e25a8c38} witness. +The generalized Clifford theorem, cover construction, weighted interface +and composition are contributed by icekylinx with OpenAI GPT-6 Astra assistance; +this repository integration uses Codex assistance. +Prior Aurel Prosz/Paureel, Zhihao Chen, RaD/hipotures, Rohan Arun, +Dominik Scholz and framework credits remain recorded in +\texttt{NOTICE} and \texttt{SOURCES.json}. + +\section{Frames for every binary subspace} +\input{notes/general-clifford-frames.tex} +\section{Three-stage complex cover} +\input{notes/three-stage-cover-complex.tex} +\section{Weighted local-ring bit interface} +\input{notes/three-stage-cover-bit.tex} +\section{Uniform stock and ordinary output} +\input{notes/three-stage-cover-rows.tex} +\section{Finite precision and strict assembly} +\input{notes/three-stage-cover-assembly.tex} +\end{document} diff --git a/notes/three-stage-cover-rows.tex b/notes/three-stage-cover-rows.tex new file mode 100644 index 0000000000..590da4b892 --- /dev/null +++ b/notes/three-stage-cover-rows.tex @@ -0,0 +1,95 @@ +\subsection{Internal row reserve and ordinary conversion} +The finite cover requires a row divisor $W(w)$ at each coarse level. +All children have ratio at most $66/67$ and depth +$D(n)\le47\lceil\log_2\max(2,n)\rceil+O(1)$. +A sufficient common divisor is $W(w)^{D(n)}$ times the inherited old-leaf +reserve. The old supplier has its retained complete-row contract and +logarithmic reserve. Therefore a sufficient integer $S(e,w)$ satisfies +\[ + \log_qS(e,w)=O(w\log e). +\] +Unused stock is divided only into fresh descendant role fields; exposed +parent low/high fields are spectator prefixes. Their weights cannot depend +on those fresh roles. Every completed call restores its row coordinate, +so successive residuals and the outer wrapper reuse one reserve instead +of multiplying reserves for sequential calls. + +The unweighted reversed endpoint $F_n(H,D)=(C_nD,C_nH)$ converts to an +ordinary interchange by the chronological sequence +\[ + D\leftarrow D-H;\quad F_n;\quad D\leftarrow D+H;\quad + F_n;\quad D\leftarrow H-D. +\] +Indeed the successive values are $(H,D-H)$, $(C_n(D-H),C_nH)$, +$(C_n(D-H),C_nD)$, $(D,D-H)$, and $(D,H)$. +The three additive maps cost $O(Vn)$ in the atom model. The two calls +reuse restored rows; their constant multiplicity is outside the recursion +and does not multiply its characteristic moment. + +\subsection{Borrowing and restoring the stock} +Set $\beta=1/1000$, $w=\lceil e^\beta\rceil$, and +$k=\lceil\log_qS(e,w)\rceil=O(w\log e)$, using the depth bound for the +original width $e$. For sufficiently large $e$, $ka_{\rm bit}$ and $\beta<1-a_{\rm bit}$ make both +the atom-adapter and borrowing terms lower order. The remainder cost +$O(Vw^{1-a_{\rm old}})$ is also covered. Thus the ordinary radix-$q$ +interchange has cost $O(Ve^{1-a_{\rm bit}})$, without an externally supplied +superpolynomial stock of rows. + +For an original binary chunk range $[2^e]$, let +$t=\lceil e/\log_2q\rceil$ and embed it numerically into $[q^t]$. +Pad both exchanged ranges while retaining every spectator. The total +logical-volume increase is below $q^2$. Execute the completed ordinary +radix-$q$ interchange, then remove the padding. Its endpoint preserves the +rectangular genuine set $[2^e]\times[2^e]$; intermediate maps may mix genuine +and padded addresses, which does not affect this endpoint justification. +As $q$ is fixed and $t=\Theta(e)$, the binary interchange has the same +saving exponent. All schedules use a fixed number of finite-alphabet +tapes; low residue tables and port types are fixed independently of $w$. + +The conclusion retains the original local-producer, ordered-affine, +ordinary-leaf and multiplication-framework hypotheses. It adds no free +unit-scaling, dense chart transformation, or external row-stock primitive. diff --git a/references/partial-gauge/pr62/LICENSE b/references/partial-gauge/pr62/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/references/partial-gauge/pr62/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/references/partial-gauge/pr62/NOTICE b/references/partial-gauge/pr62/NOTICE new file mode 100644 index 0000000000..fd30e610b0 --- /dev/null +++ b/references/partial-gauge/pr62/NOTICE @@ -0,0 +1,185 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The new research note, scripts, certificates, patches, and documentation +were prepared by Douglas Colkitt with assistance from OpenAI Codex. +This project is not an official OpenAI release or an OpenAI endorsement. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. diff --git a/references/partial-gauge/pr62/PROOF.md b/references/partial-gauge/pr62/PROOF.md new file mode 100644 index 0000000000..26e1166562 --- /dev/null +++ b/references/partial-gauge/pr62/PROOF.md @@ -0,0 +1,221 @@ +# Interval strips and core-aware pair assembly: conditional saving 4.986133 × 10^-5 + +Under OpenAI's base theorem and the retained analytic, fixed finite-alphabet +and fixed multitape interfaces, the construction below gives + +\[ +T(n)=O\bigl(n(\log n)^{1-\kappa}\bigr),\qquad +\boxed{\kappa=\frac{4986133}{10^{11}}=4.986133\times10^{-5}>2^{-15}.} +\] + +The exact bit saving is 4986382/10^11. The next grid value of the bit saving +fails the exact moment test, and the next κ grid value fails the assembly. + +This is **6.782% above PR #57** (4669442391/10^14), **10.092% above PR #54** +(141532521/3125000000000) and **10.849% above PR #53** (4498144/10^11). It +does not use PR #57's compiler or PR #54's clones. These compare asymptotic +exponent savings, not running times. They are conditional research claims +without independent mathematical review or formal verification. + +Section "Stacking with PR #57's frame compiler" below gives a second, larger +witness, κ = 5101691/10^11, that also uses PR #57's compiler. + +## What changes + +Only the scalar producer DAG changes, in `pair_graph.py`, together with its +pinned carrier matching, `links-{23,25}.uses`. Everything else is PR #53's +`research/skip-strips` pipeline, which is PR #48's `research/copied-fixed` +pipeline, with constants recomputed for the new DAG. + +A role is a physical scratch wire. With c additions, q designated outputs and +μ retained carrier links, the role count is R = c + q − μ. A link lets a +donor addition x = u + w continue its carrier into a later consumer t of u, +when the original envelope of x lies inside the envelope of t: the common core +of t lies inside the core of x, and the cover of x lies inside the cover of t. +So R counts the additions that cannot continue a carrier, plus q. + +### 1. Interval strips + +The paired-exclusion recursion (icekylinx PR #18/#36) needs, for each vertex, +every leave-one-out sum of its k strip values v_1, …, v_k. PR #53 used the +skip-prefix layout s_j = A_(j−2) + (v_(j−1) + B_(j+1)). We build every cyclic +interval of the values instead, each from an interval one item shorter: + + I(a, m) = I(a, m−1) + v_(a+m−1), 2 ≤ m ≤ k−1, + +and output s_j = I(j+1, k−1), with the total I(0, k−1) + v_(k−1). The interval +I(a, m) with m < k−1 has the later consumer I(a−1, m+1) of its last item +v_(a+m−1), and its cover lies inside that consumer's cover, so it can continue +a carrier. Only the k outputs and the total stay unmatched. + +This costs k(k−2)+1 additions instead of about 4k. The role count still falls, +because R counts unmatched additions. In a model of one strip, an exact integer +program over every leave-one-out circuit shows that k−1 unmatched additions is +the minimum for k ≤ 8. Skip-prefix leaves 2k−3 unmatched; intervals leave k−1 +or k. Intervals are used for every strip with k ≥ 3 nonzero values; smaller +strips keep PR #53's layout. Value orders are PR #53's: reversed at the top +level, sorted by (support size, ±support) below it. + +### 2. Core-aware pair assembly + +For groups i < j with members (a, a2) and (b, b2), let F = far[i,j] and let +Sa, Sa2, Sb, Sb2 be the strip outputs that omit the other group. Each of the +four outputs is a sum of four pieces, for example +out[a,b] = F + Sa + Sb + e(a2,b2). PR #53 computes left(a,j) = F + Sa, +then out[a,b] = left(a,j) + (Sb + e(a2,b2)). None of those ten additions can +continue a carrier. We compute + + F+Sa, F+Sa2, F+Sb, F+Sb2, + Y1 = (F+Sb) + Sa, Y2 = (F+Sa) + Sb2, + Y3 = (F+Sa2) + e(a,b2), Y4 = (F+Sb2) + e(a,b), + out[a,b] = e(a2,b2) + Y1, out[a,b2] = e(a2,b) + Y2, + out[a2,b] = Y3 + Sb, out[a2,b2] = Y4 + Sa2. + +Each F+S node then has a later consumer of its strip operand whose envelope +contains its own: the same common core and a larger cover. An exact integer +program over every assembly of these nine pieces, with their actual cores and +covers, shows that 8 unmatched additions per group pair is optimal. The cores +matter: a node such as Sa + e(a2,b2) has the two-point core {c, a2}, so a +one-point-core donor cannot continue into it. Each output needs its own +addition and at least one more addition that serves only that output, and +neither can continue a carrier, so 8 is also a lower bound for this +decomposition. + +### Counts + +| h | v | additions c | outputs q | matched μ | roles R | loss | +|---|---|---|---|---|---|---| +| 23 | 1771 | 62294 | 5336 | 38911 | 28719 | 506 | +| 25 | 2300 | 86595 | 6925 | 55844 | 37676 | 600 | + +PR #53 had R23 = 32946 and R25 = 43409. The physical constants are +m = 575, N = 4,073,300, W = 140,924,496 (PR #53: 160,799,739) and +L = 2,226,400. The complete rank is Wm − N + L = 81,029,738,300. The deficit +N − L is unchanged. + +The weighted matching is pinned in `links-{h}.uses`. `optimize_matching.py` +regenerates it from Rohan Arun's PR #44 optimizer with only the graph import +changed. Its output is not trusted: `profiles.cpp` replays every pinned link, +and `producer.py` recounts every link independently. + +## Why the inherited proofs apply + +The new DAG enters the inherited proofs only through properties and +quantities that `producer.py` recomputes, as for PR #41, #43, #47, #48 and #53: + +- **Scalar outputs.** Every addition joins disjoint supports, every node has a + common point, and every output is the exact leave-two-out sum or retained + total, checked on dense global supports. +- **Carrier links.** Every pinned link lies in the admissible adjacency + (causal order and envelope inclusion), with distinct donors and uses. +- **Physical timeline.** The full physical timeline and every dirty basis + vector are checked in both orientations at h = 23 and 25. +- **Fixed-basis profiles.** These are recomputed from the new DAGs and pinned + matchings: 37,728 and 51,927 distinct transition matrices; 6,026 and 7,981 + of them CRT-checked; zero modular disagreements. Exactly h full center + cleanups appear, so the copied-center replacement applies unchanged. +- **Data corners.** These do not depend on the producer. All 4,073,300 pairs + are replayed, and the ten primary-prime failures are recovered by exact + rational elimination. + +The integer programs explain why the links exist; correctness does not depend +on them. + +## Exact arithmetic + +`verify.py` uses PR #43/#48's exact logarithm and exponential enclosures: + +- The moment at a_b = 4986382/10^11 is below 1; at 4986383/10^11 its exact + lower bound exceeds 1. +- Each of the following is excluded at the new bit saving by an exact lower + bound: the complete child lists of PR #57, #54, #53, #48, #47, #46, #44, + #43, #42, #41 and #40, and the PR #36 baseline. +- The inherited balanced assembly passes all 47 strict conditions and seven + margins at κ = 4986133/10^11 and fails at the next grid value. Its + parameters are β = 1/20, h = 10^-12, a_c = 717/10^7, C1 = 1 and row stock + p^2000. + +## Stacking with PR #57's frame compiler + +PR #57 (eumemic, with OpenAI Codex assistance) compiles each set of nodes that +share one original envelope as a single invertible binary map, matches +retained signals to later uses, and reclaims retired roles with paid XOR +clearing. Its compiler, `scripts/experiments/binary_frame_compiler.py`, is +included unchanged through PR #57's own commit on this branch. +`frame/frame_compile.py` feeds it the hash-pinned `pair_graph.py` instead of +PR #53's graph, exactly as PR #57's driver feeds it PR #53's graph. + +The compiled words give the following role counts: + +| h | roles R, this graph | roles R, compiled | shared-frame regions | retained signals | reclaimed roles | +|---|---|---|---|---|---| +| 23 | 28719 | 27918 | 52473 | 37025 | 801 | +| 25 | 37676 | 36586 | 73695 | 53194 | 1090 | + +With W = 137,151,806 the stacked witness gives + +\[ +\kappa=\frac{5101691}{10^{11}}=5.101691\times10^{-5}, +\] + +with exact bit saving 5101952/10^11. This is **9.257% above PR #57** and +2.318% above the plain witness above. PR #57's own result on PR #53's graph +is 4669442391/10^14. + +`frame/frame_verify.py` checks, as PR #57's verifier does: + +- both serialized XOR words, replayed independently on every input and dirty + basis vector in both orientations; +- every frame transition, reconstructed from the actual XOR word; +- all fixed-basis profiles, with bounded-minor and CRT checks; +- the exact moment, the rejection of the next bit-saving grid value, the + exclusion of PR #53's and PR #57's networks at the new saving, all 47 + strict assembly inequalities, seven margins, and the rejection of the next + κ grid value. + +This stacked witness also depends on PR #57's compiler argument, which has +the same review status as PR #57. + +## Reproduce + +```sh +python3 research/pair-assembly/producer.py --work-dir /tmp/pair-assembly +python3 research/pair-assembly/verify.py +python3 research/pair-assembly/frame/frame_verify.py +python3 research/pair-assembly/optimize_matching.py --work-dir /tmp/pair-opt # optional, needs scipy +python3 research/pair-assembly/frame/frame_compile.py # optional, rewrites the words +``` + +`producer.py --record` rewrites the JSON records. Without `--record` it checks +them against fresh regeneration. `make pair-assembly-verify` runs the first +three commands and the tests. + +## Scope and attribution + +This is a conditional finite certificate. It covers the same written proof +obligations as PR #43–#53: the base theorem, the residual compiler, fixed-tape +recursion, the physical meaning of carrier continuations and copied centers, +the analytic/semantic/routing/recovery interfaces and eventual thresholds. +None of these are re-proved here. There is no formal verification or claim of +global optimality. The stacked witness additionally depends on PR #57's +compiler mechanism and its written argument. + +The interval strips and core-aware pair assembly are new here, by Avi +Eisenberg with assistance from Claude (Anthropic). Everything else is +inherited, with all original notices: + +- Avi Eisenberg PR #53: skip-prefix strips and this pipeline's adaptation. +- eumemic PR #57: the joint frame compiler, used unchanged for the stacked + witness. +- Chafik Boukhalfa PR #43/#46/#48: pipeline, recovery, the sorting idea and + verification code. +- Rohan Arun PR #44: weighted matching; also PR #37/#39/#40/#42/#47. +- RaD / hipotures PR #41: alternating order and changed DAGs. +- Dominik Scholz PR #35/#38. +- James Chang PR #34. +- icekylinx PR #18/#24/#32/#36. +- Zhihao Chen PR #21/#23/#29. +- Paureel / Aurel Prosz, Swapnil Jain, Douglas Colkitt, OpenAI, and + Harvey–van der Hoeven. + +Apache-2.0. diff --git a/references/partial-gauge/pr62/SOURCE.json b/references/partial-gauge/pr62/SOURCE.json new file mode 100644 index 0000000000..c4a7d407e0 --- /dev/null +++ b/references/partial-gauge/pr62/SOURCE.json @@ -0,0 +1,11 @@ +{ + "repository": "ikeboy/integer-mult-bounds", + "commit": "ad0f25ff7b23cff7f08ad237c2254e6ecf74257e", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/62", + "scope": "Primitive proof and unchanged attribution; implementation adapted in scripts/partial_gauge/interval.py.", + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "95d7dabb54a327216e007f1e0cf37dd2f138ab31527f2cc5ee0de55e87f274ca", + "PROOF.md": "30685624bf922bb9d9f7ed4b0d367a660fe373cc9ee28fec33585bd8c7023e75" + } +} diff --git a/references/partial-gauge/pr97/LICENSE b/references/partial-gauge/pr97/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/references/partial-gauge/pr97/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/references/partial-gauge/pr97/NOTICE b/references/partial-gauge/pr97/NOTICE new file mode 100644 index 0000000000..b565637758 --- /dev/null +++ b/references/partial-gauge/pr97/NOTICE @@ -0,0 +1,304 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. diff --git a/references/partial-gauge/pr97/PROOF.md b/references/partial-gauge/pr97/PROOF.md new file mode 100644 index 0000000000..58824db895 --- /dev/null +++ b/references/partial-gauge/pr97/PROOF.md @@ -0,0 +1,246 @@ +# Deferred bit endpoints and a signed two-stage complex interface + +Under the analytic and fixed finite-alphabet multitape interfaces already +retained by main, the networks in this package give the conditional bound + +\[ +T(n)=O\bigl(n(\log n)^{1-\kappa}\bigr),\qquad +\kappa=63965813/10^{12}>2^{-14}. +\] + +The finite checks do not formalize these inherited interfaces or establish an +unconditional integer-multiplication theorem. Repository integration validation +is recorded separately; mathematical certificates and validation receipts have +different purposes. This is not a current-record or global-priority claim. + +The scalar/frame inputs are Swapnil Jain's round7 bit network and round6 complex +network, pinned at `741e7aa078392553815df7926ee17ac5e25a8c38`. The original source, +notes, licenses and assistance disclosures are preserved in `swapnil-round7/`. +That source reports a slightly larger final number under its own analytic +stack. We instead use main's retained semantic guard and balanced assembly. +Our additions are explicit reflected scheduling, the commuting fan-order +clarification, gauged exits, a signed complex endpoint correction and a bridge +to the existing main interfaces. No separately researched local role saving is +added to these networks without recompilation. + +## Bit word, geometry and common basis + +The pinned producer at h=23 has v=1771 and R=28866. Its frozen supports, links, +deferred readouts, V leaves and rational frames are checked by the original +`check_word.py`, `check_frames.py` and `check_lifted.py`. In particular, the +deferred scratch slots are untouched before their deferred readout; their +entrance frames lie in every required target hyperplane. These are conditions +on the complete physical word, not just its ordinary-input support. + +`round7_literal_frame_ledger.py` expands that word into 1080616 events and +checks the forward shear on all 32408 ordinary/dirty F2 basis vectors. Gates +with several fan recipients are expanded in stable order of their starting +frame dimension. The recipients are distinct targets of the same unchanged +source, so these XORs commute. The separately checked chains prove nesting; +rank order alone is insufficient. This changes the internal order of160 fan +groups and avoids otherwise uncharged frame retreats, preserving their scalar +map and all costs. The imported source is left intact. + +Reverse time, complement the factor frames and exchange the data banks for +stage two. All ordinary gates retain their XOR direction after the exchange. +The new ledger checks continuity and the complete opposite shear; a logical +transpose alone would not prove this statement. A copied-center scatter is a +macro: copy the unchanged center, transport the copy, scatter and discard the +copy. Its reflection creates a new copy at the complemented source and moves +it to the complemented target. No unknown dirty register is erased. + +For an idempotent A write D_A=[[I-A,A],[A,I-A]]. Commuting idempotents satisfy +D_A D_B=D_(A+B-2AB). Let P,Q be the two rank-one triple projectors, sigma the +local auxiliary entrance projector of rank f, m=h², and r=h-f. Stage one's +incoming gauge is A=sigma tensor Q, its last live frame is T=I tensor Q, +and its terminal gauge is I-A. Its exterior is + +\[ +E_1=I-T+A=I-(I-\sigma)\otimes Q,\qquad\operatorname{rank}E_1=m-r. +\] + +Direct multiplication gives D_(I-A)D_T=D_E1 and D_(I-A)D_A=D_I. For stage two +put B=(I-P) tensor I and lift a factor frame K to B+P tensor K. Its entrance +is B, last live frame is I-P tensor sigma, terminal gauge is I-B, and + +\[ +E_2=B+P\otimes\sigma,\qquad\operatorname{rank}E_2=m-r. +\] + +Again D_(I-B)D_(I-P tensor sigma)=D_E2 and D_(I-B)D_B=D_I. These are genuine +commuting-idempotent exits, not an assumption that all endpoint movements are +nested. Scalar dirty restoration and complementary gauges give the full +address swap. Both exteriors are charged as block m-2r and the inner(r,h) +profile of their complementary small residual. + +With U=P tensor Q, stage-one data ends at (I tensor Q,(I-P) tensor Q), while +stage two begins at (B+U,B). Each connector is (I-P) tensor (I-Q), of rank +(h-1)², and both are charged. The final F2 scalar shear pair gives (y,x+y); +the temporary rank-one correction uses D_U D_I=D_(I-U) to remove the extra +term, retaining one paid rank-one child per pair. + +The common rational tensor basis and inner residual profiles use the preserved +`notes/flag-basis.tex`, `notes/partial-swap-batching.tex` and the round7 lifted +checks. The staircase corner adds runs h-2,h-5,1^6, alongside the outer block +m-4h+2. `check_stair.py` checks its finite witnesses and symbolic cut bounds. +The GL_h×GL_h family acts transitively on line pairs; nonzero polynomial +witnesses, together with identically imposed triangular zero conditions, give +a common rational point for the finite family. This is an existence argument, +not a claim that sampled pairs enumerate the family or that one modular basis +is already a common integer basis. Rational enumeration avoiding the finitely +many nonzero determinant polynomials is an effective fixed finite choice. +Its denominators and required minors exclude finitely many odd primes, as in +the retained transfer. All choices are independent of n. The two orientations +and newly gauged residuals occur among the checked inner families. + +The actual event histogram, including exits, connectors and corrections, +matches the pinned one with m=529, W=108516254 and s=57403754177. An independent +rational moment enclosure proves saving a_b=31987/500000000. + +## Complex scalar word and phases + +For the h24 paired triple-exclusion producer, let M be its invertible role +mixer, V the source injection and A the complete signed readout. The retained +totals are T and E_i=sum of triples avoiding i, for i=s+E and direct leaves obey A(e)<=8e. Prefix kernels and +outer normalization add at most18e, below the C0e allowance. Thus the same +fixed fine-grid proof yields C1=1; it does not concatenate temporary internal +excess of already completed children. E and C0 are large but fixed. + +The actual maximum child and width determine each least halving degree d_j +and bitlength w_j. Reserve the product W_c^D_c W_b^D_b, with +D_j=d_j ceil(log2(e)), rather than the maximum of the two stocks. The existing +physically preceding transformed prefix and one complete-row padding supply +the recomputed stock; nested bit stock is restored before another complex +child. Sequential temporary copies use this existing row field and do not +introduce a separately live recursive row reservation. The certificate gives +the exact coefficient and sufficient stock degree. These operations preserve +the fixed alphabet, fixed tape count and polynomial descriptor bounds of the +inherited interfaces; the number of fixed-role streams is not the number of +physical tapes. + +## Final exact combination + +Use beta=1/10 and eta=10^-8. The stopped complex saving (1-beta)a_c exceeds +a_b. Put q=a_b(1-2eta), c=q(1+eta), epsilon=(1-eta)/(1+c+q), lambda'=1-q, +lambda=((1-a_b)+lambda')/2, g=epsilon*q, +r=(g+1-epsilon)/2 and delta=eta/8. The inherited balanced combination now +has all47 strict constraints and all7 margins above63965813/10^12; the +next10^-12 grid point is rejected. This includes the recomputed scalar +charge, product-row gap, compact reservations, phase-cell separation, prime +packing and exact recovery allowances. A second moment implementation +checks both complete recursive histograms with exact rational logarithm and +exponential enclosures. Passing arithmetic does not by itself establish any +of the physical or analytic lemmas above. + +## Attribution and scope + +Zhihao Chen (jacklightChen): explicit reflected event ledgers, commuting +fan-order clarification, nonzero auxiliary endpoint proof, signed complex +phase controls and corrected rank-one endpoint, and integration with the +retained balanced semantic assembly, with Codex assistance. Subsequent work +using these specific contributions should explicitly acknowledge Zhihao Chen. +Historical GPT-6 Astra assistance attribution on PR7/PR23/PR29 remains; +no claim about the current runtime model is made. + +Swapnil Jain supplies deferred readouts, V leaves, lifted frames, the h24 +producer, common flag/staircase family and frozen witnesses, with the original +Claude assistance disclosure. Avi Eisenberg/ikeboy PR62 supplies interval +strips and core-aware pair assembly; RaD/hipotures PR41 supplies alternating +order/links, and Rohan Arun PR44 the weighted-link precedent. Aurel Prosz/ +Paureel supplies two-stage/complement scheduling; icekylinx PR36 supplies +copied-center and bridge precedents; James Chang PR34 supplies balanced +combination and reversed geometry; Zhihao Chen PR23/PR29 and RaD supply +semantic precision, bulk routing and transfer. All earlier author, license +and AI disclosures in the preserved source and main remain in force. + diff --git a/references/partial-gauge/pr97/README.md b/references/partial-gauge/pr97/README.md new file mode 100644 index 0000000000..ce8b472195 --- /dev/null +++ b/references/partial-gauge/pr97/README.md @@ -0,0 +1,35 @@ +This is a compact, unmodified snapshot of the PR97 physical bit ledger and +the underlying frozen round-seven input. `SOURCE.json` pins the commits and +every imported file's SHA-256. Each imported byte sequence also matches the +round-six handoff's original manifest. Original LICENSE and NOTICE are retained. + +Zhihao Chen / jacklightChen supplies the PR97 literal forward/reflected physical +ledger and proof, with the Codex assistance disclosed in those files. Swapnil +Jain supplies the underlying deferred word, frame witnesses and frame/lifted +checking sources. Earlier authors and assistance disclosures remain credited +in NOTICE, PROOF.md, and the original source headers. + +The snapshot preserves `witness_23.json.gz` and `deferred_23.json.gz` (about +2.3 MB together), not the large expanded event/path dumps. The archived +`bit-ledger-result.json` is a validation receipt, not a new test result. Its +historical elapsed time is preserved verbatim. The original scripts retain +their upstream directory assumptions; they are source/proof witnesses here, +not a relocated full-audit harness. + +`scripts/partial_gauge_bit.py` verifies every byte pin, loads the compressed +inputs explicitly, reconstructs auxiliary and data-chain rank increments, +checks them against the actual physical ledger, reconstructs exit nullities +from each physical slot's deferred frame, and composes the new whole-projector +histogram. It compares every coefficient to the round-six input certificate. +It does not repeat the unchanged complete-basis replay or rational geometry +audits; rank differences alone would not establish those geometric hypotheses. + +The whole-projector reconstruction counts two stages of v physical invocations, +with each local rank increment kept whole, each exterior assigned rank +`m-(h-dim sigma)`, two bank-pair entrance projectors of rank `(h-1)^2`, and +one rank-one copy correction per source pair. This replaces the old corner +splitting while preserving the exact physical total rank mass. + +New reconstruction and integration: copyright 2026 icekylinx, Apache-2.0, +prepared with OpenAI Codex assistance. No independent review or endorsement +by the predecessor authors is implied. diff --git a/references/partial-gauge/pr97/SOURCE.json b/references/partial-gauge/pr97/SOURCE.json new file mode 100644 index 0000000000..970000a79f --- /dev/null +++ b/references/partial-gauge/pr97/SOURCE.json @@ -0,0 +1,31 @@ +{ + "archive": "integer-mult-research/pro/round6-20261009", + "archive_manifest_sha256": "b2edf27c7eea66982a75cb224887da8bce25e18ce9b3857ff45c4666ee4b4ea5", + "archive_source_inputs_sha256": "ed58db13eafeb47401c6c962291e1fe760cbd25a563ca2796f5389b03a9714f3", + "pr97": { + "commit": "e15350b66e4bf796153a68c240a6cc1b788abe3e", + "repository": "jacklightChen/integer-mult-bounds", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/97" + }, + "scope": "Unmodified hash-bound physical-ledger receipt, source and compressed witness inputs. Full upstream frame/lifted/scalar audits are inherited, not repeated by the incremental checker.", + "sha256": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f", + "PROOF.md": "f2c95747d9a5858da43932d857be999e6166d4740f25e2c57f99ce05a8902352", + "bit-ledger-result.json": "c3dd79e5e6d72e49d8d1be2d4d9ad808cd7d24b7a725190d24100cbd3644394a", + "check_frames.py": "1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8", + "check_lifted.py": "c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c", + "deferred-readout.tex": "4e848f7f06c975045629da7cca9f79e10f255d08dc17a72629c9bed522565d52", + "deferred.py": "9b2acaeb6f1beb2a53c15e00c027f9ba22397a12071ad0b71131e12012a98036", + "deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c", + "linalg.py": "56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b", + "round7_literal_frame_ledger.py": "02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59", + "witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588" + }, + "snapshot_prefix": "round6_work/references/round6_pr97/", + "underlying": { + "commit": "741e7aa078392553815df7926ee17ac5e25a8c38", + "repository": "Swapnil-jain/integer-mult-kappa", + "url": "https://github.com/Swapnil-jain/integer-mult-kappa/tree/741e7aa078392553815df7926ee17ac5e25a8c38" + } +} diff --git a/references/partial-gauge/pr97/bit-ledger-result.json b/references/partial-gauge/pr97/bit-ledger-result.json new file mode 100644 index 0000000000..708e83ebd4 --- /dev/null +++ b/references/partial-gauge/pr97/bit-ledger-result.json @@ -0,0 +1,272 @@ +{ + "h": 23, + "roles": 28866, + "formal_basis": 32408, + "events": 1080616, + "frame_keys": 90173, + "rank_histograms": { + "aux": { + "1": 55349, + "5": 6151, + "10": 162, + "4": 11248, + "2": 64873, + "3": 13926, + "6": 1617, + "8": 1243, + "9": 458, + "12": 208, + "16": 208, + "18": 599, + "21": 413, + "7": 883, + "11": 299, + "14": 38, + "15": 649, + "13": 202, + "17": 1309, + "19": 533, + "20": 2310 + }, + "data": { + "4": 2013, + "5": 521, + "3": 1144, + "1": 11386, + "2": 2402, + "6": 475, + "7": 276, + "8": 382, + "9": 130, + "10": 86, + "11": 93, + "12": 97, + "13": 65, + "14": 26, + "15": 43, + "16": 218, + "17": 38, + "18": 8, + "19": 1547, + "21": 1, + "22": 2 + }, + "center": { + "22": 23 + } + }, + "fan_groups_reordered_internally": [ + 45859, + 45862, + 46139, + 46142, + 46409, + 46412, + 46681, + 46684, + 46943, + 46946, + 47207, + 47210, + 47461, + 47464, + 47717, + 47720, + 47963, + 47966, + 48211, + 48214, + 48449, + 48452, + 48689, + 48692, + 48919, + 48922, + 49151, + 49154, + 49373, + 49376, + 49597, + 49600, + 49811, + 49814, + 50027, + 50030, + 50233, + 50236, + 50441, + 50444, + 50639, + 50642, + 50839, + 50842, + 51029, + 51032, + 58136, + 58138, + 58140, + 58142, + 58144, + 58572, + 58574, + 58576, + 58578, + 58580, + 58988, + 58990, + 58992, + 58994, + 58996, + 59420, + 59422, + 59424, + 59426, + 59428, + 59832, + 59834, + 59836, + 59838, + 59840, + 60260, + 60262, + 60264, + 60266, + 60268, + 60668, + 60670, + 60672, + 60674, + 60676, + 61092, + 61094, + 61096, + 61098, + 61100, + 61496, + 61498, + 61500, + 61502, + 61504, + 61916, + 61918, + 61920, + 61922, + 61924, + 62316, + 62318, + 62320, + 62322, + 62324, + 62732, + 62734, + 62736, + 62738, + 62740, + 63128, + 63130, + 63132, + 63134, + 63136, + 63540, + 63542, + 63544, + 63546, + 63548, + 63932, + 63934, + 63936, + 63938, + 63940, + 64340, + 64342, + 64344, + 64346, + 64348, + 64728, + 64730, + 64732, + 64734, + 64736, + 65132, + 65134, + 65136, + 65138, + 65140, + 65516, + 65518, + 65520, + 65522, + 65524, + 65916, + 65918, + 65920, + 65922, + 65924, + 66296, + 66298, + 66300, + 66302, + 66304, + 66692, + 66694, + 66696, + 66698, + 66700, + 67068, + 67070, + 67072, + 67074 + ], + "complete_forward_F2": true, + "complete_reflected_F2": true, + "reflected_frame_continuity": true, + "all_scalar_gates_equal_frame_keys": true, + "exterior_formula": "E1=I-I_tensor_Q+sigma_tensor_Q; E2=(I-P)_tensor_I+P_tensor_sigma; rank=m-h+dim(sigma)", + "histogram_matches_external": true, + "histogram": { + "1": 1690297301, + "3": 1356586, + "19": 1639946, + "17": 8476006, + "15": 7948248, + "13": 2164162, + "11": 5093396, + "7": 3580962, + "21": 6906900, + "9": 1526602, + "5": 354200, + "483": 61280142, + "23": 61280142, + "525": 5653032, + "527": 6233920, + "489": 293986, + "521": 13711082, + "523": 4629394, + "491": 580888, + "485": 545468, + "487": 173558, + "493": 14168, + "499": 1129898, + "495": 322322, + "505": 99176, + "503": 410872, + "501": 127512, + "507": 1186570, + "509": 340032, + "497": 17710, + "513": 106260, + "517": 626934, + "515": 1583274, + "511": 322322, + "519": 2854852, + "439": 6272882, + "18": 6272882 + }, + "recursive_rank": 57403754177, + "elapsed": 9.80610633303877, + "limit_seconds": 180, + "exact_chain_geometry": "Relies on separately replayed pinned check_frames and check_lifted. Rank labels alone do not prove geometry.", + "scope": "Explicit one-axis forward/reflected events, scalar complete basis and exact accounting. Tensor endpoint identities proved separately; full complex/tape/precision and final assembly integration not established.", + "new_multiplication_bound": false +} + diff --git a/references/partial-gauge/pr97/check_frames.py b/references/partial-gauge/pr97/check_frames.py new file mode 100644 index 0000000000..f22b6998f9 --- /dev/null +++ b/references/partial-gauge/pr97/check_frames.py @@ -0,0 +1,262 @@ +"""Round-seven check, part 2 (stdlib only): every frame of the reordered word, exactly over Q. + +The base frames (lifted node frames M_n, late-copy intersections, root frames t_T^perp and U_c) are rebuilt from the +witness with check_lifted.py's exact machinery. The design-B frames (deferred readout frames sigma_u, V-leaf starts +s_i) are the primitive integer bases of the data file. Checked: + X. the frame dimensions recorded in the data file (node frames, late-copy intersections) equal the exact ones; every + slot's node list moves along slot successors of the witness (gate uses and links, for which check_lifted.py proves + nesting), its first node is where its start says, its last node reaches its root frame directly; + Q. sigma_u <= F0(u) (the slot's start frame); sigma_u <= t_T^perp for every target of u (Z supports, a superset of + the F2 supports); on every y_T the deferred levels are nested in time order (readout order); t_S <= s_i <= N_i + (the first frame of the use); every X_S chain , early V frames, deferred V frames, F is nested in time order; + G = I - J/9 nondegenerate on every new frame (Gram determinant nonzero mod a prime, so nonzero over Z); + S. side lemma at check_lifted's integer point (U, V of point(h, 1), the point of check_stair.py too): every distinct + high-rank step (2r > h) of the reordered word that check_lifted.py does not already cover (slot starts, gauged + corners sigma_u -> F, y_T and X_S chain steps, base steps that only the new schedule uses) has the generic + north-east pivots under both conjugations, mod 2^31-1; + F. the child-width histogram rebuilt from the exact dimensions (Z and F2 y supports), rank sum s = W m - N + L, + moment certificate and kappa, with the round-six and the staircase entrance corners; + N. negative controls: reversed readout order, readouts at F0(u) instead of sigma_u, perturbed sigma frames, X_S + chains with the deferred V gates first, side lemma with U = V = I. +Usage: python3 check_frames.py [h]""" +import sys, os, time, random +from fractions import Fraction as Fr +from math import gcd +from collections import Counter, defaultdict +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path[:0] = [HERE, os.path.join(HERE, '..', '..', 'scripts'), os.path.join(HERE, '..', 'two-stage-bit')] +import check_lifted as cl +import deferred as dr +from linalg import null_exact, rank_mod, inv_mod_matrix, rightmost_pivots, predicted, Q31, Echelon + +T0 = time.time() +def log(*a): print('[%5.0fs]' % (time.time() - T0), *a, flush=True) +OK = {} +def report(name, ok): + OK[name] = bool(ok); log('%-100s %s' % (name, 'PASS' if ok else 'FAIL')) + + +def prim(r): + r = [Fr(x) for x in r]; den = 1 + for x in r: den = den * x.denominator // gcd(den, x.denominator) + z = [int(x * den) for x in r]; g = 0 + for x in z: g = gcd(g, x) + return [x // g for x in z] if g else z + + +class ModQ7(cl.ModQ): + """check_lifted's mod-q frames, extended by the design-B frames ('sigma', s) and ('v', s) (integer bases).""" + def __init__(self, fr, ld, extra, control=False): + super().__init__(fr, ld, control); self.extra = extra + + def basis(self, key): + if key[0] in ('sigma', 'v') and key not in self.bcache: + E = Echelon(self.q) + for r in self.extra[key]: E.insert([x % self.q for x in r]) + if len(E.rows) != len(self.extra[key]): self.dimfail += 1 + self.bcache[key] = E.rows + return super().basis(key) + + +def main(h=23): + W, D = dr.load(h); S = dr.Schedule(W, D); trip = S.trip; tv = lambda T: [int(q in T) for q in range(h)] + FULL = [[int(i == j) for j in range(h)] for i in range(h)] + pr = cl.Prog(W); bas, dn = cl.spans(pr); users = cl.users_of(pr, dn) + fr = cl.Frames(pr, dn, bas, users); fr.cobases(); d, _ = fr.dims(); ld, _ = cl.late_frames(fr, pr, users) + log('exact base frames: %d node frames (%d lifted), %d late-copy intersections' % (len(d), len(pr.j), len(ld))) + + # ------------------------------------------------------------------ X. recorded dims, slot paths + okd = all(S.node_dims[n] == d[n] for n in pr.act) and len(S.node_dims) == len(pr.act) + okd &= all(S.late_dims[n, lt] == ld[('c', n, lt)] for (n, lt) in S.late_dims) and len(S.late_dims) == len(ld) + report('X. recorded frame dims == exact dims (%d node frames, %d late-copy intersections)' % (len(d), len(ld)), okd) + def ukey(n, k): + u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else cl.root_key(u) + badp = 0 + for s in range(S.R): + hl = S.hold[s] + for a, b in zip(hl, hl[1:]): badp += b not in fr.succ[a] + root = [k for k in S.chain_keys(s) if k[0] in ('out', 'ret')] + if root: badp += fr.rid[root[0]] not in fr.droots[hl[-1]] + st = S.start[s] + if st[0] == 'fresh': # a copy starts at the use it serves + nxt = ('n', hl[1]) if len(hl) > 1 else root[0] + badp += ukey(hl[0], st[2]) != nxt + report('X. every slot moves along slot successors of the witness, starts at its use, ends at its root (%d slots)' % S.R, + badp == 0) + + # ------------------------------------------------------------------ exact frames + _eb = {} + def exact(key): + if key not in _eb: + k = key[0] + if k == 'sigma': B = S.sigma[key[1]] + elif k == 'v': B = S.vstart[key[1]] + elif k == '0': B = [] + elif k == 'F': B = FULL + elif k == 'c': + n, lt = key[1], key[2] + B = exact(ukey(n, lt[-1])) + for kk in reversed(lt[:-1]): B = fr.intersect_exact(exact(ukey(n, kk)), B) + B = [prim(r) for r in B]; assert len(B) == ld[key] + else: B = [prim(r) for r in fr.exact_basis(key)] + _eb[key] = B + return _eb[key] + _nz = {} + def nullZ(B): + kb = tuple(map(tuple, B)) + if kb not in _nz: _nz[kb] = [prim(z) for z in null_exact(B, h)] if B else FULL + return _nz[kb] + def inside(A, B): + if not A or len(B) == h: return True + return all(sum(a * z for a, z in zip(ra, rz)) == 0 for ra in A for rz in nullZ(B)) + def nondeg(B, p=Q31): # det(9 B G B^T) != 0 mod p => != 0 over Z + if not B or len(B) == h: return True + sm = [sum(b) for b in B] + Gr = [[9 * sum(x * y for x, y in zip(a, b)) - sa * sb for b, sb in zip(B, sm)] for a, sa in zip(B, sm)] + return rank_mod(Gr, p) == len(B) + gout = {T: [9 * x - 3 for x in tv(T)] for T in trip} + tperp = lambda T: ('out', T[0], T) # t_T^perp is the root frame of every output (c, T) + + # ------------------------------------------------------------------ Q. exact facts + indep = all(rank_mod(B, Q31) == len(B) for B in list(S.sigma.values()) + list(S.vstart.values())) + report('Q. sigma_u and s_i bases independent (rank mod 2^31-1 == row count; %d + %d frames, max |entry| %d)' % ( + len(S.sigma), len(S.vstart), max(abs(x) for B in list(S.sigma.values()) + list(S.vstart.values()) for r in B for x in r)), indep) + sel = S.readout; F0 = {s: S.start_key(s) for s in range(S.R)} + report('Q. sigma_u <= F0(u) exactly (%d deferred slots)' % len(sel), all(inside(S.sigma[s], exact(F0[s])) for s in sel)) + CZ = S.adjoint(); CF = [{t: 1 for t, x in dd.items() if x % 2} for dd in CZ] + capbad = sum(1 for s in sel for t in CZ[s] if any(sum(a * g for a, g in zip(r, gout[trip[t]])) for r in S.sigma[s])) + report('Q. sigma_u <= t_T^perp exactly for every Z-support target (a superset of the F2 targets)', capbad == 0) + def ychains(co, order, frame=lambda s: S.sigma[s], limit=None): + byT = defaultdict(list) + for s in order: + for t in co[s]: byT[t].append(s) + bad = 0; levels = {} + for t, ss in list(byT.items())[:limit]: + seq = [frame(s) for s in ss] + for A, B in zip(seq, seq[1:]): + if A is B: continue + if len(A) > len(B) or not inside(A, B): bad += 1 + lv = [] + for s in ss: + if not lv or S.f[lv[-1]] != S.f[s]: lv.append(s) + levels[t] = lv + return bad, levels + bZ, levZ = ychains(CZ, sel); bF, levF = ychains(CF, sel) + report('Q. deferred levels on every y_T nested in time order, exactly (Z targets %d bad, F2 targets %d bad)' % (bZ, bF), + bZ == 0 and bF == 0) + nd = sum(1 for B in list(S.sigma.values()) + list(S.vstart.values()) if not nondeg(B)) + report('Q. G nondegenerate on every sigma_u and s_i (Gram det != 0 mod 2^31-1 => over Z)', nd == 0) + bad_t = bad_n = 0 + for s, n in S.srcop.items(): + bad_t += not inside([tv(trip[n - 1])], S.vstart[s]) + N1 = S.chain_keys(s)[2] # first frame of the use after its start + bad_n += not inside(S.vstart[s], exact(N1)) + report('Q. V leaves exactly: t_S <= s_i (%d bad), s_i <= N_i, the first frame of the use (%d bad), %d slots' % ( + bad_t, bad_n, len(S.srcop)), bad_t == bad_n == 0) + def xchains(order_fn): + bad = 0; steps = [] + for n, us in S.xs: + seq = [[tv(trip[n - 1])]] + [S.vstart[s] for s in order_fn(us)] + [FULL] + keys = [('n', n)] + [('v', s) for s in order_fn(us)] + [('F',)] + for (A, ka), (B, kb) in zip(zip(seq, keys), zip(seq[1:], keys[1:])): + if len(A) > len(B) or not inside(A, B): bad += 1 + steps.append(keys) + return bad, steps + bx, xkeys = xchains(lambda us: us) + report('Q. X_S chains nested exactly in time order (, early V gates, deferred V gates, F; %d leaves)' % len(S.xs), bx == 0) + + # ------------------------------------------------------------------ S. side lemma on the new high-rank steps + ops0, chains0, _, R0 = cl.compile_(pr, dn, users) + def dimof0(k): + if k == ('0',): return 0 + if k == ('F',): return h + if k[0] in ('out', 'ret'): return h - 1 + if k[0] == 'c': return ld[k] + return d[k[1]] + _, base_steps = cl.chain_steps(chains0, dimof0, h) + base_frames = {k for e in base_steps for k in e} + def dimx(k): return len(exact(k)) if k[0] in ('sigma', 'v') else dimof0(k) + new = {} + def add_chain(keys, kind): + prev = keys[0]; pd = dimx(prev) + for k in keys[1:]: + dk = dimx(k) + if dk > pd: + if (prev, k) not in base_steps and 2 * (dk - pd) > h: new.setdefault((prev, k), (dk - pd, kind)) + prev, pd = k, dk + else: prev = k + for s in range(S.R): + add_chain(S.chain_keys(s), 'slot') + if S.f[s]: add_chain([('sigma', s), ('F',)], 'corner') + for t, lv in levZ.items(): + add_chain([('0',)] + [('sigma', s) for s in lv] + [tperp(trip[t])], 'ydata') + for t, lv in levF.items(): + add_chain([('0',)] + [('sigma', s) for s in lv] + [tperp(trip[t])], 'ydata') + for keys in xkeys: add_chain(keys, 'xdata') + extra = {('sigma', s): B for s, B in S.sigma.items()}; extra.update({('v', s): B for s, B in S.vstart.items()}) + mq = ModQ7(fr, ld, extra) + used = {k for e in new for k in e} - base_frames + ndq = sum(1 for k in used if not mq.nondeg(k)) + report('S. frames used only by the new steps: %d, G-degenerate mod 2^31-1 %d, reduction dimension mismatches %d' % ( + len(used), ndq, mq.dimfail), ndq == 0 and mq.dimfail == 0) + pr_ = predicted(h); q = mq.q + def lemma(items, m): + bad = 0 + for (A, B), (r, _) in items: + QA, QB = m.conjugated(A), m.conjugated(B) + for t in range(2): + a, b = QA[t], QB[t] + M = [[(b[i * h + c] - a[i * h + c]) % q for c in range(h)] for i in range(h)] + if rightmost_pivots(M, q) != pr_[r]: bad += 1 + return bad + items = sorted(new.items(), key=lambda e: (str(e[0][1]), str(e[0][0]))) + badL = lemma(items, mq) + report('S. side lemma (generic NE pivots, both conjugations, mod 2^31-1) on all %d new high-rank steps %s' % ( + len(items), dict(Counter(k for _, k in new.values()))), badL == 0) + + # ------------------------------------------------------------------ F. histogram from exact dims + import moment + from certificate_round3 import evaluate + def dim_exact(k): return dimx(k) + rk = dr.chain_ranks(S, dim_exact) + xd = S.xdata(lambda s: len(exact(('v', s)))) + okx = all(sum(x) == h - 1 for x in xd) + ylZ = S.ylevels(CZ); ylF = {t: sorted({S.f[s] for s in sel if t in CF[s]}) for t in range(S.v)} + res = {} + for corner_name, corner in (('round-six corner', dr.ROUND6_CORNER(h)), ('staircase corner', dr.STAIRCASE_CORNER(h))): + for yname, yl in (('Z', ylZ), ('F2', ylF)): + c = dr.histogram(S, rk, yl, xd, corner) + rs = sum(w * n for w, n in c['hist'].items()) + a, _ = moment.certify(c) + k = evaluate(a, Fr(36926111, 5 * 10**11), Fr(1, 1000), 'crude', m_c=576, s_c=119453132304) + res[corner_name, yname] = (a, k['kappa'], k['ok'], rs == c['s'] and max(c['hist']) < c['m']) + for corner_name in ('round-six corner', 'staircase corner'): + (aZ, kZ, oZ, sZ), (aF, kF, oF, sF) = res[corner_name, 'Z'], res[corner_name, 'F2'] + report('F. %s: rank sum == s (Z and F2 y supports), a_b = %s (%.6e), kappa = %s (%.7e) ok=%s, F2 a_b = %s' % ( + corner_name, aZ, float(aZ), kZ, float(kZ), oZ, aF), sZ and sF and oZ and oF and okx) + report('F. claims: a_b 12599/200000000, kappa 6299103187973/10^17; staircase a_b 31987/500000000, kappa 1599247689723/(2.5*10^16)', + res['round-six corner', 'Z'][:2] == (Fr(12599, 200000000), Fr(6299103187973, 10**17)) and + res['staircase corner', 'Z'][:2] == (Fr(31987, 500000000), Fr(1599247689723, 25 * 10**15))) + + # ------------------------------------------------------------------ N. negative controls + bZr, _ = ychains(CZ, list(reversed(sel))) + report('N. NEG reversed readout order breaks the y_T chains (%d bad)' % bZr, bZr > 0) + bF0, _ = ychains(CF, sorted(sel, key=lambda s: (dimx(F0[s]), s)), frame=lambda s: exact(F0[s]), limit=300) + report('N. NEG readouts at F0(u) instead of sigma_u break the y_T chains (%d breaks on 300 targets)' % bF0, bF0 > 0) + rng = random.Random(5); pert = tot = 0 + for s in [s for s in sel if dimx(F0[s]) < h][:200]: + B = [r[:] for r in S.sigma[s]]; B[0] = [x + rng.randint(1, 3) for x in B[0]]; tot += 1 + pert += not inside(B, exact(F0[s])) + report('N. NEG perturbed sigma frames fail sigma <= F0 (%d / %d)' % (pert, tot), tot and pert >= 0.9 * tot) + early = set(S.srcop) - S.sel + bxr, _ = xchains(lambda us: [s for s in us if s not in early] + [s for s in us if s in early]) + report('N. NEG deferred V gates before the early ones break the X_S chains (%d bad)' % bxr, bxr > 0) + mq0 = ModQ7(fr, ld, extra, control=True) + badc = lemma(items[:300], mq0) + report('N. NEG side lemma with U = V = I fails (%d / %d)' % (badc, 2 * min(300, len(items))), badc > 0) + log('ALL %s' % ('PASS' if all(OK.values()) else 'FAIL: ' + str([k for k, x in OK.items() if not x]))) + return all(OK.values()) + + +if __name__ == '__main__': + sys.exit(0 if main(int(sys.argv[1]) if len(sys.argv) > 1 else 23) else 1) diff --git a/references/partial-gauge/pr97/check_lifted.py b/references/partial-gauge/pr97/check_lifted.py new file mode 100644 index 0000000000..4a19240e2f --- /dev/null +++ b/references/partial-gauge/pr97/check_lifted.py @@ -0,0 +1,677 @@ +"""Release check (stdlib only) of the lifted-frame + late-copy bit side program, stacked with the staircase corner. + +Input: certificates/round7/witness_.json.gz: the side DAG (leaves = triples of [h], additions), outputs (c, T), +retained totals, links (donor x -> use (y, k)), the flag matrix F (integer h x h), the lift index j(n) of every +lifted addition and the late-copy decisions (early users, ordered late users) per node. + +What is checked, from the witness alone: + A. DAG semantics: disjoint supports; output (c,T) support = {S : c in S, S cap T = {c}}; retained = star(c). + B. Compile: one slot per role, schedule order (dim span, id), links hand the donor's non-pivot slot to the linked + use; late copies: the pivot of n climbs C_1 <= ... <= C_k (C_i = frames of users late[i:] intersected) and the + copy for late user i is a gate (pivot, fresh slot) at C_i, placed in time as LATE as possible (just before the + first of: its user's gate, the pivot's consumer gate, the next copy's slot). R = adds + outputs + retained - links. + C. Dirty-scratch replay of the compiled program: word L J L^-1 V L J L^-1 V^-1 and its mirror, arbitrary scratch, + over F2 and over Z, reads at the slot's last touch and at the end; targets must receive J L V x exactly + (DAG values) and every slot is restored; over F2 every target also receives exactly x_T. + D. Frames (exact over Q). Frame of addition n: M_n = span(n) + (U_n cap F_j(n)), U_n = common kernel of the root + covectors reachable from n ((9I-J) t_T for an output to Y_T, 1 - 3 e_c for a retained use of c), F_j = first j + rows of F. Nesting is a THEOREM given the combinatorial facts checked here: + j(n) <= j(t) on every slot successor pair n -> t; span(x) <= span(t) on every link pair (exact); + span(n) <= every root frame n reaches directly (exact integer dot products); F invertible. + Then U_n <= U_t, so M_n <= M_t, M_n <= U_n <= every reachable root frame, and every late-copy frame C_i + (an intersection of frames that all contain M_n) is nested. Dimensions (exact, see linalg.py): + dim M_n = rank[span(n); F_j] - rank(K_n F_j^T) (modular law; span(n) <= U_n; K_n spans the root covectors), + with ranks by mod-p + Hadamard certificates, Bareiss when the mod-p rank is not full; late-copy intersections by + exact Fraction bases. Rank of every chain step = difference of dimensions (nested), histogram vs claim. + E. Frame reductions mod q = 2^31-1 (dimension-matched, so they are the reductions of the rational frames), + G = I - J/9 nondegenerate on every frame of every step (Gram matrix invertible mod q => over Q), and the side + lemma at ONE integer point (U, V of point_UV(h, 1), the random stream of independent/two-stage-bit/flag_existence.py): for every distinct step A -> B of + rank r with 2r > h (retained copy edges 0 -> U_c included), U^T (P_B - P_A) U^-T and V^T (..) V^-T have the + generic north-east pivots of f_r. (NE ranks mod q <= over Q <= f_r, so equality mod q proves it over Q.) + F. Certificate: rt_histogram with the round-6 entrance corner and with the staircase corner (m-4h+2, h-2, h-5, 1^6), + rank sum == s, moment.certify (exact), kappa = certificate_round3.evaluate(a_b, round-6 complex values). +Negative controls (CONTROL=1): see controls(). +Usage: python3 check_lifted.py h [--no-generic]""" +import sys, os, json, random, time +from itertools import combinations +from collections import Counter, OrderedDict +from fractions import Fraction as Fr +from array import array +HERE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, HERE) +from linalg import * + +T0 = time.time() +def load_witness(h): + import gzip + with gzip.open(os.path.join(HERE, '..', '..', 'certificates', 'round7', 'witness_%d.json.gz' % h), 'rt') as fh: + return json.load(fh) + + +def log(*a): + print('[%5.0fs]' % (time.time() - T0), *a, flush=True) + + +# ----------------------------------------------------------------------------------------------- A. DAG +class Prog: + def __init__(self, W): + self.W = W; h = self.h = W['h'] + self.trip = list(combinations(range(h), 3)); v = self.v = len(self.trip) + self.args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()} + self.act = sorted(self.args) + for n in self.act: + if self.args[n] is None: assert 1 <= n <= v and tuple(W['leaf'][str(n)]) == self.trip[n - 1] + else: assert all(a < n and a in self.args for a in self.args[n]), n + self.sup = {} + for n in self.act: + if self.args[n] is None: self.sup[n] = 1 << (n - 1) + else: + a, b = self.args[n]; assert not self.sup[a] & self.sup[b], 'overlapping supports' + self.sup[n] = self.sup[a] | self.sup[b] + self.outputs = {(c, tuple(T)): n for c, T, n in W['outputs']} + self.retained = {c: n for c, n in W['retained']} + star = [sum(1 << i for i, t in enumerate(self.trip) if q in t) for q in range(h)] + assert len(self.outputs) == 3 * v and len(self.retained) == h + for (c, T), n in self.outputs.items(): + A, B = [q for q in T if q != c]; assert c in T and self.sup[n] == star[c] & ~star[A] & ~star[B] + for c, n in self.retained.items(): assert self.sup[n] == star[c] + roots = set(self.outputs.values()) | set(self.retained.values()); reach = set(); st = list(roots) + while st: + n = st.pop() + if n in reach: continue + reach.add(n) + if self.args[n]: st.extend(self.args[n]) + assert reach == set(self.act), 'inactive nodes in witness' + self.mL = {x: (y, k) for x, y, k in W['links']} + self.j = {int(n): j for n, j in W['j'].items()} + self.late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()} + self.F = W['flag'] + + +def trow(h, S): return [int(q in S) for q in range(h)] + + +def spans(pr): + """independent triple subsets (exact: 0/1 rows with three ones, every minor < 3^(h/2) < Q31) and dims.""" + h = pr.h; assert 3 ** h < Q31 ** 2 + bas = {}; dn = {} + for n in pr.act: + if pr.args[n] is None: bas[n] = (n - 1,); dn[n] = 1; continue + a, b = pr.args[n]; E = Echelon(Q31); keep = [] + for i in bas[a] + bas[b]: + if len(E) == h: break + if E.insert(trow(h, pr.trip[i])): keep.append(i) + bas[n] = tuple(keep); dn[n] = len(keep) + return bas, dn + + +def users_of(pr, dn): + key = lambda n: (dn[n], n); users = {n: [] for n in pr.act} + for n in sorted(pr.act, key=key): + if pr.args[n]: + for pos, x in enumerate(pr.args[n]): users[x].append(('gate', n, pos)) + for (c, T), n in sorted(pr.outputs.items()): users[n].append(('out', (c, T))) + for c, n in sorted(pr.retained.items()): users[n].append(('ret', c)) + return users + + +# ----------------------------------------------------------------------------------------------- B. compile +def root_key(u): return ('out',) + u[1] if u[0] == 'out' else ('ret', u[1]) + + +def compile_(pr, dn, users, late=True, defer=True, tamper=None): + """returns ops (scalar program), chains (frame keys per slot), reads, R. tamper: negative-control hooks.""" + key = lambda n: (dn[n], n); order = sorted(pr.act, key=key); gpos = {n: i for i, n in enumerate(order)} + linked = {r: x for x, r in pr.mL.items()} + chains = []; edge = {}; reads = []; ops = []; deferred = [] + def new(first): chains.append(list(first)); return len(chains) - 1 + def assign(s, n, k): + u = users[n][k] + if u[0] == 'gate': edge[u[1], u[2]] = s + else: + chains[s] += [root_key(u), ('F',)] + reads.append((s, [u[1][1]] if u[0] == 'out' else [T for T in pr.trip if u[1] in T])) + def ufr(n, k): + u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u) + for n in order: + if pr.args[n] is None: + piv = new([('0',), ('n', n)]); ops.append(('src', piv, n, n)) + else: + a, b = pr.args[n]; sa, sb = edge.pop((n, 0)), edge.pop((n, 1)) + if n in pr.mL and pr.mL[n][0] == a: sa, sb = sb, sa # the linked operand stays on the non-pivot + piv, oth = sa, sb + chains[piv].append(('n', n)); chains[oth].append(('n', n)); ops.append(('add', piv, oth, n)) + if n in pr.mL: y, k = pr.mL[n]; assign(oth, y, k) + else: chains[oth].append(('F',)) + ks = [k for k in range(len(users[n])) if (n, k) not in linked] + if late and n in pr.late: + early, lt = pr.late[n]; assert sorted(early + lt) == ks, ('bad late decision', n) + else: early, lt = ks[1:], [ks[0]] + for k in early: + f = new([('0',), ('n', n)]); ops.append(('copy', piv, f, n)); assign(f, n, k) + for i, k in enumerate(lt): + Ck = ufr(n, k) if i == len(lt) - 1 else ('c', n, tuple(lt[i:])) + if tamper == 'nointersect' and i < len(lt) - 1: Ck = ufr(n, k) + chains[piv].append(Ck) + if i < len(lt) - 1: + f = new([('0',), Ck]); deferred.append((n, i, f, k, lt[-1])); assign(f, n, k) + k = lt[-1] + if users[n][k][0] == 'gate': edge[users[n][k][1], users[n][k][2]] = piv + else: assign(piv, n, k) + assert not edge + # place deferred copies: as late as possible, in order, before the user's gate and the pivot consumer's gate + INF = len(order); byn = {} + for (n, i, f, k, kl) in deferred: byn.setdefault(n, []).append((i, f, k, kl)) + ins = {} + for n, lst in byn.items(): + lst.sort(); D = [] + for i, f, k, kl in lst: + u, ul = users[n][k], users[n][kl] + d = min(gpos[u[1]] if u[0] == 'gate' else INF, gpos[ul[1]] if ul[0] == 'gate' else INF) + D.append(d) + for t in range(len(D) - 2, -1, -1): D[t] = min(D[t], D[t + 1]) + for (i, f, k, kl), d in zip(lst, D): + if not defer: d = gpos[n] + 1 # immediate copy (still a valid program) + if tamper == 'aftercons' and n == tamper_node[0] and i == 0: + ul = users[n][kl]; d = gpos[ul[1]] + 1 # copy AFTER the pivot was consumed + ins.setdefault(d, []).append((n, i, f)) + pivslot = {} + for o in ops: + if o[0] in ('src', 'add'): pivslot[o[3]] = o[1] + out = [] + for o in ops: + if o[0] in ('src', 'add'): + for (n, i, f) in sorted(ins.get(gpos[o[3]], []), key=lambda z: (gpos[z[0]], z[1])): + out.append(('copy', pivslot[n], f, n)) + out.append(o) + for (n, i, f) in sorted(ins.get(INF, []) + [z for d, zs in ins.items() if d > INF for z in zs], key=lambda z: (gpos[z[0]], z[1])): + out.append(('copy', pivslot[n], f, n)) + if tamper == 'dropcopy': + idx = next(i for i, o in enumerate(out) if o[0] == 'copy' and o[3] in pr.late); out.pop(idx) + R = len(chains); adds = sum(1 for n in pr.act if pr.args[n]) + assert R == adds + len(pr.outputs) + len(pr.retained) - len(pr.mL), 'role count' + return out, chains, reads, R + +tamper_node = [None] + + +# ----------------------------------------------------------------------------------------------- C. replay +def replay(pr, ops, reads, R, ring, rng, mirror=False, midread=True): + trip, v = pr.trip, pr.v; tid = {T: i for i, T in enumerate(trip)} + mod = (lambda z: z & 1) if ring == 2 else (lambda z: z) + last = {} + for i, o in enumerate(ops): + last[o[1]] = i + if o[0] != 'src': last[o[2]] = i + readers = {} + for s, Ts in reads: readers.setdefault(last[s] if midread else len(ops) - 1, []).append((s, Ts)) + x = [rng.randrange(-10**6, 10**6) for _ in range(v)] + a0 = [rng.randrange(-10**6, 10**6) for _ in range(R)]; y0 = [rng.randrange(-10**6, 10**6) for _ in range(v)] + a = list(a0); y = list(y0); src = [(o[1], o[2]) for o in ops if o[0] == 'src'] + def L(sg=None): + for i, o in enumerate(ops): + if o[0] == 'add': a[o[1]] += a[o[2]] + elif o[0] == 'copy': a[o[2]] += a[o[1]] + if sg is not None: + for s, Ts in readers.get(i, ()): + for T in Ts: y[tid[T]] += sg * a[s] + def Li(): + for o in reversed(ops): + if o[0] == 'add': a[o[1]] -= a[o[2]] + elif o[0] == 'copy': a[o[2]] -= a[o[1]] + def V(sg): + for s, n in src: a[s] += sg * x[n - 1] + if not mirror: L(-1); Li(); V(+1); L(+1); Li(); V(-1) + else: V(+1); L(+1); Li(); V(-1); L(-1); Li() + if any(mod(p - q) for p, q in zip(a, a0)): return False + val = {} + for n in pr.act: val[n] = x[n - 1] if pr.args[n] is None else val[pr.args[n][0]] + val[pr.args[n][1]] + want = list(y0) + for (c, T), n in pr.outputs.items(): want[tid[T]] += val[n] + for c, n in pr.retained.items(): + for T in trip: + if c in T: want[tid[T]] += val[n] + if any(mod(p - q) for p, q in zip(y, want)): return False + if ring == 2 and any(mod(y[i] - y0[i] - x[i]) for i in range(v)): return False + return True + + +# ----------------------------------------------------------------------------------------------- D. frames +class Frames: + def __init__(self, pr, dn, bas, users): + self.pr = pr; self.dn = dn; self.bas = bas; self.users = users; h = self.h = pr.h + self.rootcov = {} + for (c, T) in pr.outputs: self.rootcov[('out', c, T)] = [9 * int(q in T) - 3 for q in range(h)] + for c in pr.retained: self.rootcov[('ret', c)] = [1 - 3 * int(q == c) for q in range(h)] + rid = {k: i for i, k in enumerate(sorted(self.rootcov))}; self.rkeys = sorted(self.rootcov) + self.rid = rid + # slot successors (same for base and late compile: every free use of n is reached by one slot from n, + # a donor's non-pivot slot goes on to its linked use) and direct roots + linked = {r: x for x, r in pr.mL.items()} + self.succ = {n: set() for n in pr.act}; self.droots = {n: set() for n in pr.act} + def to(n, use): + if use[0] == 'gate': self.succ[n].add(use[1]) + else: self.droots[n].add(rid[root_key(use)]) + for n in pr.act: + for k, u in enumerate(users[n]): + if (n, k) not in linked: to(n, u) + if n in pr.mL: y, k = pr.mL[n]; to(n, users[y][k]) + + def check_structure(self): + """combinatorial / exact facts behind the nesting theorem.""" + pr, h = self.pr, self.h; bad_j = bad_link = bad_root = 0 + J = lambda n: self.pr.j.get(n, 0) + for n in pr.act: + if pr.args[n] is None: assert J(n) == 0 + for t in self.succ[n]: + if J(n) > J(t): bad_j += 1 + for x, (y, k) in pr.mL.items(): # span(x) <= span(linked use target) + u = self.users[y][k] + if u[0] == 'gate': + t = u[1]; E = Echelon(Q31) + for i in self.bas[t]: E.insert(trow(h, pr.trip[i])) + if not all(E.contains(trow(h, pr.trip[i])) for i in self.bas[x]): bad_link += 1 + for n in pr.act: # span(n) <= direct root frames + for r in self.droots[n]: + g = self.rootcov[self.rkeys[r]] + if any(sum(gq * tq for gq, tq in zip(g, trow(h, pr.trip[i]))) for i in self.bas[n]): bad_root += 1 + # F invertible over Q (a nonzero determinant mod a prime) + F_ok = rank_mod(self.pr.F, Q31) == h + return bad_j, bad_link, bad_root, F_ok + + def cobases(self): + """K_n: independent subset of the root covectors reachable from n, spanning all of them over Q + (selection mod M127, valid by the Hadamard certificate on root covectors).""" + pr, h = self.pr, self.h + rows = [self.rootcov[k] for k in self.rkeys] + mx = max(sum(x * x for x in r) for r in rows); assert mx ** h < M127 ** 2, 'Hadamard bound for K' + key = lambda n: (self.dn[n], n); K = {} + for n in sorted(pr.act, key=key, reverse=True): + cand = sorted(self.droots[n]); srcs = sorted((K[t] for t in self.succ[n]), key=len, reverse=True) + cap = h - self.dn[n] # span(n) <= U_n + if not cand and len(srcs) == 1: K[n] = srcs[0]; continue + E = Echelon(M127); keep = [] + seq = list(srcs[0]) if srcs else [] + for r in seq: E.insert(rows[r]); keep.append(r) # srcs[0] is already independent + for lst in [cand] + srcs[1:]: + for r in lst: + if len(keep) >= cap: break + if E.insert(rows[r]): keep.append(r) + K[n] = tuple(keep) + self.K = K + return K + + def dims(self): + """exact dim of every addition frame M_n.""" + pr, h = self.pr, self.h; F = pr.F; d = dict(self.dn); stats = Counter() + rows = [self.rootcov[k] for k in self.rkeys] + self.KF = {} + for n, j in pr.j.items(): + Fj = F[:j]; K = [rows[r] for r in self.K[n]] + KF = [[sum(a * b for a, b in zip(kr, fr)) for fr in Fj] for kr in K] + SF = [trow(h, pr.trip[i]) for i in self.bas[n]] + Fj + r1 = self._rank(SF, min(len(SF), h), stats, 'SF'); r2 = self._rank(KF, min(len(K), j), stats, 'KF') + d[n] = r1 - r2; self.KF[n] = (r2, KF) + assert self.dn[n] <= d[n] <= h - len(K) + self.d = d + return d, stats + + @staticmethod + def _rank(M, full, stats, tag): + if not M or full == 0: return 0 + r = rank_mod(M, Q31) + if r == full: stats[tag + ' full mod q'] += 1; return r # rank mod q <= rank over Q <= full + if hadamard_ok(M, M521): stats[tag + ' M521'] += 1; return rank_mod(M, M521) + stats[tag + ' Bareiss'] += 1; return rank_exact(M) + + # exact rational bases, used for the late-copy intersections + def exact_basis(self, key): + pr, h = self.pr, self.h + if key[0] in ('out', 'ret'): + return null_exact([self.rootcov[key]], h) + n = key[1] + S = [trow(h, pr.trip[i]) for i in self.bas[n]] + j = pr.j.get(n, 0) + if not j: return S + _, KF = self.KF[n]; F = pr.F[:j] + X = null_exact(KF, j) if KF else [[int(i == t) for t in range(j)] for i in range(j)] + vecs = S + [[sum(c * F[i][q] for i, c in enumerate(x)) for q in range(h)] for x in X] + # independent subset: rows independent mod q are independent over Q; d of them span M_n (dim M_n = d exactly) + E = Echelon(Q31); out = [] + for vv in vecs: + if E.insert(vv): out.append(vv) + assert len(out) == self.d[n], ('exact basis dim', n, len(out), self.d[n]) + return out + + def intersect_exact(self, A, B): + h = self.h + if not A or not B: return [] + # z = (x, y): x A = y B <=> [A; -B]^T z = 0 + M = [[A[i][q] for i in range(len(A))] + [-B[i][q] for i in range(len(B))] for q in range(h)] + Z = null_exact(M, len(A) + len(B)) + # A and B are bases, so z -> x A is injective on the null space: the images are a basis of A cap B + return [[sum(z[i] * A[i][q] for i in range(len(A))) for q in range(h)] for z in Z] + + +def late_frames(fr, pr, users): + """exact dims of every late-copy intersection frame ('c', n, late users).""" + cache = {}; dims = {} + def eb(k): + if k not in cache: cache[k] = fr.exact_basis(k) + return cache[k] + def ufr(n, k): + u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u) + for n, (early, lt) in pr.late.items(): + for i in range(len(lt) - 1): + B = eb(ufr(n, lt[-1])) + for k in reversed(lt[i:-1]): B = fr.intersect_exact(eb(ufr(n, k)), B) + dims[('c', n, tuple(lt[i:]))] = len(B) + return dims, cache + + +def chain_steps(chains, dimof, h): + rk = Counter(); steps = {} + for ch in chains: + prev = ch[0]; pd = dimof(prev) + for k in ch[1:]: + dk = dimof(k) + assert dk >= pd, ('decreasing chain', prev, k, pd, dk) + if dk > pd: rk[dk - pd] += 1; steps[prev, k] = dk - pd; prev, pd = k, dk + else: prev = k # equal dims, nested => equal frames + assert pd == h + return rk, steps + + +# ----------------------------------------------------------------------------------------------- E. mod-q frames, side lemma +def point_UV(h, seed): + """the U, V drawn by independent/two-stage-bit/flag_existence.py with this seed (same random stream).""" + CR = 10**6; rng = random.Random(seed) + nz = lambda: rng.choice([-1, 1]) * rng.randint(1, CR) + for b in range(h): + for i in range(h): + for jj in range(h): + if i <= b and jj <= b: nz() + for b in range(h): + for i in range(h): + for jj in range(h): + if i >= b and jj >= b: nz() + U = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)] + V = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)] + return U, V + + +class ModQ: + def __init__(self, fr, latedims, control=False): + self.fr = fr; self.h = h = fr.h; self.q = q = Q31; self.latedims = latedims + U, V = point_UV(h, 1) + if control: U = [[int(i == k) for k in range(h)] for i in range(h)]; V = [r[:] for r in U] + self.conj = [] + for A in (U, V): + Ai = inv_mod_matrix(A, q); assert Ai is not None + self.conj.append(([list(c) for c in zip(*A)], Ai)) # columns of A, rows of A^-1 + self.inv9 = pow(9, q - 2, q); self.bcache = {}; self.qcache = OrderedDict(); self.cap = 6000 + self.degenerate = 0; self.dimfail = 0 + + def basis(self, key): + if key in self.bcache: return self.bcache[key] + fr, h, q = self.fr, self.h, self.q; pr = fr.pr + if key == ('0',): B = [] + elif key == ('F',): B = [[int(i == t) for t in range(h)] for i in range(h)] + elif key[0] in ('out', 'ret'): B = null_mod([fr.rootcov[key]], h, q) + elif key[0] == 'c': + n, lt = key[1], key[2] + B = None + for k in lt: + u = fr.users[n][k]; kk = ('n', u[1]) if u[0] == 'gate' else root_key(u) + Bk = self.basis(kk) + B = Bk if B is None else self._cap(B, Bk) + if len(B) != self.latedims[key]: self.dimfail += 1 + else: + n = key[1]; S = [trow(h, pr.trip[i]) for i in fr.bas[n]]; j = pr.j.get(n, 0) + E = Echelon(q) + for r in S: E.insert(r) + if j: + r2, KF = fr.KF[n] + if KF and rank_mod(KF, q) != r2: self.dimfail += 1 + X = null_mod(KF, j, q) if KF else [[int(i == t) for t in range(j)] for i in range(j)] + Fj = pr.F[:j] + for x in X: E.insert([sum(c * Fj[i][t] for i, c in enumerate(x)) % q for t in range(h)]) + B = E.rows + if len(B) != fr.d[n]: self.dimfail += 1 + self.bcache[key] = B + return B + + def _cap(self, A, B): + q, h = self.q, self.h + if not A or not B: return [] + M = [[A[i][t] for i in range(len(A))] + [(-B[i][t]) % q for i in range(len(B))] for t in range(h)] + Z = null_mod(M, len(A) + len(B), q); E = Echelon(q) + for z in Z: E.insert([sum(z[i] * A[i][t] for i in range(len(A))) % q for t in range(h)]) + return E.rows + + def gram_inv(self, B): + q = self.q; BG = [[(x - sum(b) * self.inv9) % q for x in b] for b in B] + Gr = [[sum(x * y for x, y in zip(bg, c)) % q for c in B] for bg in BG] + return BG, inv_mod_matrix(Gr, q) + + def nondeg(self, key): + B = self.basis(key) + if not B or len(B) == self.h: return True + return self.gram_inv(B)[1] is not None + + def conjugated(self, key): + """(U^T P U^-T, V^T P V^-T) for the G-orthogonal projector P onto the frame, flattened.""" + if key in self.qcache: self.qcache.move_to_end(key); return self.qcache[key] + h, q = self.h, self.q; B = self.basis(key) + if not B: out = (array('q', [0] * h * h),) * 2 + elif len(B) == h: I = array('q', [int(i == t) for i in range(h) for t in range(h)]); out = (I, I) + else: + BG, Gi = self.gram_inv(B) + if Gi is None: raise ZeroDivisionError(key) + res = [] + for Acols, Ai in self.conj: + LU = [[sum(x * y for x, y in zip(ac, b)) % q for b in B] for ac in Acols] # A^T B^T (h x d) + RU = [[sum(x * y for x, y in zip(bg, ai)) % q for ai in Ai] for bg in BG] # B G A^-T (d x h) + Mi = matmul(Gi, RU, q) + Mt = list(zip(*Mi)) + res.append(array('q', [sum(x * y for x, y in zip(l, c)) % q for l in LU for c in Mt])) + out = tuple(res) + self.qcache[key] = out + if len(self.qcache) > self.cap: self.qcache.popitem(last=False) + return out + + +def side_lemma(mq, steps, h, retained): + q = mq.q; pr_ = predicted(h); E = dict((k, r) for k, r in steps.items() if 2 * r > h) + for c in retained: E[('0',), ('ret', c)] = h - 1 # retained copy edges 0 -> U_c + keys = sorted(E, key=lambda e: (str(e[1]), str(e[0]))) # group by target frame (cache reuse) + bad = 0; n = 0 + for (A, B) in keys: + r = E[A, B]; QA, QB = mq.conjugated(A), mq.conjugated(B) + for t in range(2): + a, b = QA[t], QB[t] + M = [[(b[i * h + c] - a[i * h + c]) % q for c in range(h)] for i in range(h)] + if rightmost_pivots(M, q) != pr_[r]: bad += 1 + n += 1 + if n % 5000 == 0: log(' side lemma %d/%d, failures %d' % (n, len(keys), bad)) + return bad, len(keys) + + +# ----------------------------------------------------------------------------------------------- F. certificate +K_REPO = os.path.normpath(os.path.join(HERE, '..', '..')) +sys.path[:0] = [K_REPO + '/scripts', K_REPO + '/independent/two-stage-bit'] + + +def inner_children(r, h): return [1] * (h - r) + [2 * r - h] if 2 * r > h else [1] * r + + +def rt_histogram(h, R, rk, corner): + """cert_rt.rt_histogram with the data-entrance corner profile 'corner' (round six: [h-2] + [1]*(h+1)).""" + from math import comb + v, m = comb(h, 3), h * h; N = v * v; A = v * R; H = Counter() + assert sum(r * n for r, n in rk.items()) == h * R and sum(corner) == 2 * h - 1 + for _ in range(2): + H[m - 2 * h] += A; H[h] += A + for r, n in rk.items(): + for w in inner_children(r, h): H[w] += v * n + for w in inner_children(h - 1, h): H[w] += v * h + H[m - 4 * h + 2] += 2 * N + for w in corner: H[w] += 2 * N + for _ in range(2): H[h - 2] += 2 * N; H[1] += 2 * N + H[1] += N + W = 2 * N + 2 * A; L = 2 * v * h * (h - 1); s = W * m - N + L + H = {w: c for w, c in H.items() if c} + assert sum(w * c for w, c in H.items()) == s and max(H) <= m - 1 + return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=H) + + +def certificate(h, R, rk): + import moment + from certificate_round3 import evaluate + out = {} + for name, corner in (('round6 corner', [h - 2] + [1] * (h + 1)), ('staircase', [h - 2, h - 5] + [1] * 6)): + c = rt_histogram(h, R, rk, corner) + if c['W'] * c['m'] <= c['s']: out[name] = ('no deficit', c['s']); continue + a, root = moment.certify(c) + k = evaluate(a, Fr(36926111, 5 * 10**11), Fr(1, 1000), 'crude', m_c=576, s_c=119453132304) + out[name] = (a, root, c['s'], c['W'], k['kappa'], k['ok']) + return out + + +# ----------------------------------------------------------------------------------------------- main +def main(h, generic=True, control=False): + W = load_witness(h) + pr = Prog(W); log('h=%d: A. DAG semantics OK (%d nodes, %d additions, %d links, %d lifted, %d late)' % ( + h, len(pr.act), sum(1 for n in pr.act if pr.args[n]), len(pr.mL), len(pr.j), len(pr.late))) + bas, dn = spans(pr); users = users_of(pr, dn) + ops, chains, reads, R = compile_(pr, dn, users) + log('B. compiled: R=%d (claimed %d), ops %d, late copies %d' % (R, W['claimed']['R'], len(ops), + sum(len(l) - 1 for _, l in pr.late.values()))) + assert R == W['claimed']['R'] + rng = random.Random(h) + res = {(ring, mir, mid): all(replay(pr, ops, reads, R, ring, rng, mir, mid) for _ in range(2)) + for ring in (2, 0) for mir in (False, True) for mid in (True, False)} + log('C. dirty-scratch replay (F2/Z x word/mirror x midread/endread): %s' % ('ALL OK' if all(res.values()) else res)) + fr = Frames(pr, dn, bas, users) + bj, bl, br, Fok = fr.check_structure() + log('D. nesting facts: j-monotone failures %d, link span failures %d, root containment failures %d, F invertible %s' + % (bj, bl, br, Fok)) + fr.cobases(); log(' co-bases K_n done') + d, st = fr.dims(); log(' lifted frame dims exact: %s' % dict(st)) + nU = sum(1 for n in pr.j if d[n] == h - len(fr.K[n])) + log(' every lifted frame is the largest admissible frame U_n: %s (%d / %d; the flag only switches span -> U_n)' + % (nU == len(pr.j), nU, len(pr.j))) + ld, ecache = late_frames(fr, pr, users); log(' late-copy intersections exact: %d frames' % len(ld)) + def dimof(k): + if k == ('0',): return 0 + if k == ('F',): return h + if k[0] in ('out', 'ret'): return h - 1 + if k[0] == 'c': return ld[k] + return d[k[1]] + rk, steps = chain_steps(chains, dimof, h) + claimed = Counter({int(r): c for r, c in W['claimed']['rk'].items()}) + log(' chain steps: sum of ranks %d = h R %d: %s; histogram equals claim: %s; distinct steps %d (2r>h: %d)' % ( + sum(r * c for r, c in rk.items()), h * R, sum(r * c for r, c in rk.items()) == h * R, rk == claimed, + len(steps), sum(1 for r in steps.values() if 2 * r > h))) + out = dict(h=h, R=R, replay=all(res.values()), struct=(bj, bl, br, Fok), hist_ok=rk == claimed, rk=rk) + if generic: + mq = ModQ(fr, ld, control) + frames_used = {k for e in steps for k in e} | {('ret', c) for c in pr.retained} + nd = sum(1 for k in frames_used if not mq.nondeg(k)) + log('E. frames used %d: G-degenerate %d, reduction dimension mismatches %d' % (len(frames_used), nd, mq.dimfail)) + bad, ne = side_lemma(mq, steps, h, pr.retained) + log(' side lemma at one integer point%s: failures %d over %d distinct high-rank steps x 2 conjugations' % ( + ' (CONTROL U=V=I)' if control else '', bad, ne)) + out.update(degenerate=nd, dimfail=mq.dimfail, side_bad=bad, side_n=ne) + for name, val in certificate(h, R, rk).items(): + if val[0] == 'no deficit': log('F. %s: no deficit at this h (s=%d), certificate n/a' % (name, val[1])); continue + a, root, s, Wr, kap, ok = val + log('F. %s: s=%d W=%d a_b=%s (%.6e, root %.6e) kappa=%s (%.7e) ok=%s' % (name, s, Wr, a, float(a), root, kap, + float(kap), ok)) + out[name] = (a, kap, ok) + return out, pr, dn, users + + + + +# ----------------------------------------------------------------------------------------------- negative controls +def controls(h, nsample=40): + """Each must FAIL (or differ) for the check to have teeth: + (a) one late copy moved to just after its pivot's consumer gate: replay must fail; + (b) one late copy dropped: replay must fail; + (c) pivot chain without intersections (C_i := frame of user i alone): exhibit non-nested consecutive pivot frames; + (d) M_n rebuilt from an independent flag F' on targets strictly between span and U (vacuous for this + witness: every lifted frame equals U_n, so the flag is only a switch and nesting needs no common flag); + (e) side lemma at U = V = I on the first high-rank steps: generic pivots must fail; + (f) no late copies (lifted frames only): histogram must change.""" + W = load_witness(h) + pr = Prog(W); bas, dn = spans(pr); users = users_of(pr, dn); rng = random.Random(7) + key = lambda n: (dn[n], n); linked = {r: x for x, r in pr.mL.items()} + cand = [n for n, (e, lt) in pr.late.items() if users[n][lt[-1]][0] == 'gate'] + fails = 0; tried = 0 + for n in cand[:nsample]: + tamper_node[0] = n; ops, ch, rd, R = compile_(pr, dn, users, tamper='aftercons') + ok = all(replay(pr, ops, rd, R, ring, rng) for ring in (2, 0)); tried += 1; fails += not ok + log('(a) late copy moved after the pivot consumer: replay failed %d / %d (must be all)' % (fails, tried)) + ops, ch, rd, R = compile_(pr, dn, users, tamper='dropcopy') + log('(b) one late copy dropped: replay correct %s (must be False)' % all(replay(pr, ops, rd, R, ring, rng) for ring in (2, 0))) + fr = Frames(pr, dn, bas, users); fr.cobases(); d, _ = fr.dims(); d = dict(d); ld, _ = late_frames(fr, pr, users) + mq = ModQ(fr, ld) + def inside(A, B): + E = Echelon(mq.q) + for r in mq.basis(B): E.insert(r) + return all(E.contains(r) for r in mq.basis(A)) + def ufr(n, k): + u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u) + bad = tot = 0 + for n, (e, lt) in pr.late.items(): + for i in range(len(lt) - 1): + tot += 1; bad += not inside(ufr(n, lt[i]), ufr(n, lt[i + 1])) + log('(c) pivot chain through user frames without intersections: non-nested consecutive frames %d / %d ' + '(the intersections are needed)' % (bad, tot)) + # (d) the common flag is essential: rebuild M_n with an independent flag F' (same j(n)) and test M_n <= M_t + pairs = [(n, t) for n in pr.j for t in fr.succ[n] if pr.j.get(t, 0) > 0 and dn[t] < d[t] < h - len(fr.K[t])] + rng.shuffle(pairs); bad = tot = 0; r2 = random.Random(99) + Fp = [[r2.randint(-50, 50) for _ in range(h)] for _ in range(h)] + for n, t in pairs[:nsample]: + j = pr.j[n]; K = [fr.rootcov[fr.rkeys[r]] for r in fr.K[n]] + KF = [[sum(a * b for a, b in zip(kr, fl)) for fl in Fp[:j]] for kr in K] + if KF and rank_mod(KF, mq.q) != fr._rank(KF, min(len(K), j), Counter(), 'KF'): continue + X = null_mod(KF, j, mq.q) if KF else [[int(i == c) for c in range(j)] for i in range(j)] + E = Echelon(mq.q) + for r in mq.basis(('n', t)): E.insert(r) + vecs = [[sum(c * Fp[i][q] for i, c in enumerate(x)) % mq.q for q in range(h)] for x in X] + tot += 1; bad += not all(E.contains(v) for v in vecs) + log("(d) M_n rebuilt with an independent flag F': M_n not inside M_t on %d / %d lifted successor pairs (targets strictly between span and U)" % (bad, tot)) + ops, chains, reads, R = compile_(pr, dn, users) + fr2 = Frames(pr, dn, bas, users); fr2.cobases(); d2, _ = fr2.dims(); ld2, _ = late_frames(fr2, pr, users) + dimof = lambda k: 0 if k == ('0',) else h if k == ('F',) else h - 1 if k[0] in ('out', 'ret') else ld2[k] if k[0] == 'c' else d2[k[1]] + rk, steps = chain_steps(chains, dimof, h) + mqs = ModQ(fr2, ld2); smp = list(steps); random.Random(5).shuffle(smp); nb = 0 + for A, B in smp[:3000]: + E = Echelon(mqs.q) + for r in mqs.basis(B): E.insert(r) + nb += not all(E.contains(r) for r in mqs.basis(A)) + log('(g) sanity (positive): 3000 sampled chain steps A -> B with A inside B mod q: failures %d' % nb) + mq0 = ModQ(fr2, ld2, control=True); pr_ = predicted(h); hi = [(e, r) for e, r in steps.items() if 2 * r > h][:300] + nb = 0 + for (A, B), r in hi: + QA, QB = mq0.conjugated(A), mq0.conjugated(B) + M = [[(QB[0][i * h + c] - QA[0][i * h + c]) % mq0.q for c in range(h)] for i in range(h)] + nb += rightmost_pivots(M, mq0.q) != pr_[r] + log('(e) side lemma with U = V = I: failures %d / %d (must be most)' % (nb, len(hi))) + ops, chains0, reads, R = compile_(pr, dn, users, late=False) + rk0, _ = chain_steps(chains0, dimof, h) + log('(f) without late copies: histogram differs %s; certificate %s' % (rk0 != rk, {k: v[0] for k, v in certificate(h, R, rk0).items()})) + + +if __name__ == '__main__': + h = int(sys.argv[1]) + if '--controls' in sys.argv: controls(h) + else: + out = main(h, generic='--no-generic' not in sys.argv)[0] + ok = out['replay'] and out['struct'][:3] == (0, 0, 0) and out['struct'][3] and out['hist_ok'] + ok &= out.get('degenerate', 0) == 0 and out.get('dimfail', 0) == 0 and out.get('side_bad', 0) == 0 + ok &= all(v[2] for k, v in out.items() if k in ('round6 corner', 'staircase')) + log('ALL %s' % ('PASS' if ok else 'FAIL')) + sys.exit(0 if ok else 1) diff --git a/references/partial-gauge/pr97/deferred-readout.tex b/references/partial-gauge/pr97/deferred-readout.tex new file mode 100644 index 0000000000..d79abea77a --- /dev/null +++ b/references/partial-gauge/pr97/deferred-readout.tex @@ -0,0 +1,111 @@ +\documentclass[11pt]{article} +\usepackage{amsmath,amssymb,amsthm} +\newtheorem{lemma}{Lemma} +\newtheorem{proposition}{Proposition} +\theoremstyle{remark}\newtheorem*{remark}{Remark} +\title{Deferred readouts in the two-stage bit interchange} +\date{Draft, October 9, 2026} +\begin{document} +\maketitle + +This note describes the round-seven bit side. It keeps the round-six interchange (flag basis, retained point totals +with copied centres, side roles batched one level down, data-entrance run) and changes three things: the side +program comes from PR~\#62's producer, its frames are lifted and its fan-out copies are made late, and the stage-one +word is reordered so that most slots read their garbage out at a nonzero frame. All objects are frozen in +\texttt{certificates/round7/}; \texttt{scripts/certificate\_round7.py} rebuilds the child-width histogram from the +schedule, and the checks in \texttt{independent/deferred-readout/} verify every fact used below. Throughout, $h=23$, +$m=h^2$, $v=\binom h3$, $N=v^2$, $G=I-J/9$, and for a triple $T$ the root frame of the output wire $y_T$ is +$t_T^\perp=\ker\,(9t_T-3\mathbf 1)^{\mathsf T}$; the frame of a retained total of $c$ is $U_c=\ker(\mathbf 1-3e_c)^{\mathsf T}$. + +\section{The side program: PR \#62's producer} +The side DAG has the $v$ triples as leaves and disjoint additions as nodes; its roots are the $3v$ outputs +$\mathrm{out}(c,T)=\{S: S\cap T=\{c\}\}$ and the $h$ retained totals $\mathrm{star}(c)$. We build it with PR~\#62's +producer (ikeboy): interval strips and core-aware pair assembly, with PR~\#41's alternating order and links +(RaD/hipotures), and links chosen by a moment-weighted matching in the spirit of PR~\#44 (rohanarun). A link hands the +non-pivot slot of a donor gate to a later use of the same value, so the number of slots is +$R=\#\text{additions}+3v+h-\#\text{links}=28866$. Only the DAG enters the certificate, and it is checked from the +definitions: every addition is disjoint, every output and total has the support above, and every node is reachable +from a root (\texttt{check\_lifted.py}, part~A; \texttt{check\_word.py}, part~A). + +\section{Lifted frames and late copies} +For an addition $n$ let $U_n$ be the common kernel of the root covectors reachable from $n$ and $F_j$ the span of +the first $j$ rows of a fixed integer flag matrix. The gate of $n$ acts at +\[ M_n=\operatorname{span}(n)+(U_n\cap F_{j(n)}), \] +with a lift index $j(n)$ per addition. This is Paureel's complement-frame construction: it is valid for any frames +with (H1) leaf frames $\langle t_S\rangle$, (H2) frames nested along every slot (DAG edges, links, copies), +(H3) roots inside $t_T^\perp$ or $U_c$, (H4) $G$ nondegenerate on every frame. Nesting is a theorem given +$j(n)\le j(t)$ on every slot successor pair, $\operatorname{span}(x)\le\operatorname{span}(t)$ on every link and +$\operatorname{span}(n)$ inside every root it reaches directly; then $U_n\le U_t$ and $M_n\le M_t$. In this witness +every lifted frame equals $U_n$. Dimensions are exact (modular law, ranks with Hadamard certificates or Bareiss). + +\paragraph{Late copies.} A node with several free uses is copied for each of them. A copy made early sits at $M_n$; +a \emph{late} copy for the user $\ell_i$ of an ordered list $\ell_1,\dots,\ell_k$ is made when the pivot has climbed to +\[ C_i=\textstyle\bigcap_{i'\ge i} M(\ell_{i'}), \qquad M_n\le C_1\le\dots\le C_{k-1}\le M(\ell_k), \] +and starts there, so the copy saves the rank $\dim C_i-\dim M_n$. Each copy is placed as late as possible (before its +user's gate, the pivot's next gate and the next copy). The intersections are needed: without them consecutive pivot +frames are not nested (1396 of 1396), and a copy moved after the pivot's next gate breaks the replay. + +\section{The B-defer word} +In stage one each slot $u$ starts with its garbage $z_u$, and the word reads it out of every target it reaches: +$y_T\mathrel{-}=C_{T,u}z_u$, where $C=JL$ is given by the transpose sweep of $L$. In rounds five and six all these +readouts happen at frame $0$, before the second pass. B-defer splits the second pass in two phases. + +\begin{itemize} +\item \emph{Phase 1} is the closure of the retained totals' last operations under per-slot sequence precedence: every + op that must precede a total's completion. The totals complete, and their copies read every target containing + their centre at $0$ (copied centres, as in round six). +\item A slot that phase 1 neither reads nor writes still holds its garbage after phase 1. It reads it out + \emph{now}, at a frame $\sigma_u\le F_0(u)\cap\bigcap_{T}t_T^\perp$ (over its targets $T$), then the rest of $L$ runs, + then the output reads at $t_T^\perp$, then $L^{-1}$ and $V^{-1}$ exactly mirror it. +\end{itemize} +Only the topological order of the word changes, so it is still a mirror and still restores arbitrary scratch. The +slot's chain now starts at $\sigma_u$: its corner has rank $r_u=h-\dim\sigma_u$ and its auxiliary edge rank $m-r_u$. + +\paragraph{The sorting rule.} On a target $y_T$ the readout frames, in time order, are $0$ (non-deferred slots and +centre copies), the deferred $\sigma_u$, and $t_T^\perp$; they must form a chain. The word reads the deferred slots +in increasing $\dim\sigma_u$, and applies the deferred $V$ gates (below) in increasing $\dim F_0$. With this rule +every $y_T$ sequence is nested in time order, exactly over $\mathbb Q$, for both the $\mathbb Z$ and the +$\mathbb F_2$ supports of $C$; the reversed order breaks 11879 chains. + +\section{V leaves as late copies on $X_S$} +A leaf $S$ is used by several gates. Instead of copying $x_S$ by fan-out, every use $i$ gets its own $V$ gate on the +data wire $X_S$, into a slot that starts at +\[ s_i=N_i\cap N_{i+1}\cap\cdots \qquad(\text{falling back to }\langle t_S\rangle\text{ if $G$ is degenerate on it}), \] +where $N_j$ is the first frame of use $j$. The $V$ gates are then late copies on $X_S$: its frame chain +$\langle t_S\rangle\le s_{i_1}\le s_{i_2}\le\dots\le F$ has total rank $h-1$, as before, and the use slots start at +$s_i$ instead of $\langle t_S\rangle$. The $V$ gates of deferred slots come after their readouts; in time the $X_S$ chain +is $\langle t_S\rangle$, the early $V$ frames (by dimension), the deferred $V$ frames (by the rule above), $F$, and it +is checked nested exactly in that order. The number of slots is unchanged. + +\section{What the certificate uses} +\paragraph{Only the $\mathbb F_2$ flag identity.} The bit network is used over $\mathbb F_2$: the word must add exactly +$x_T$ to every $y_T$ and restore every slot, for arbitrary scratch. The replay checks this over $\mathbb F_2$ with +the parity coefficients (the actual circuit) and, separately, over $\mathbb Z$ with the exact path-count +coefficients; the histogram and $a_b$ are the same with either support. + +\paragraph{The stage-two complement.} Stage two is the complement time-reversal of stage one, with the same edge +multiset. This is the same assumption as in round six; it is stated, not machine-checked here. + +\paragraph{Frames and genericity.} Every $\sigma_u$ and $s_i$ is a primitive integer basis (entries at most 13). +Exactly over $\mathbb Q$: $\sigma_u\le F_0(u)$, $\sigma_u\le t_T^\perp$, $t_S\le s_i\le N_i$, $G$ nondegenerate. Every +high-rank step ($2r>h$) that the reordered word adds (slot starts, gauged corners $\sigma_u\to F$, $y_T$ and $X_S$ +chain steps) has the generic north-east pivots under both conjugations at the integer point of +\texttt{check\_lifted.py}, so the side lemma batches it. + +\section{Accounting} +Per stage and invocation: every slot contributes its auxiliary edge (block $m-2r_u$) and its corner, both batched +by the inner lemma, and its chain steps; every centre copy its step $U_c\to0$ of rank $h-1$; every $y_T$ and every +$X_S$ its chain of total rank $h-1$; the data entrance its block $m-4h+2$ and corner; one copy-correction singleton per +pair. The rank sum is exactly $s=Wm-N+L$ with $W=2N+2vR$, $L=2vh(h-1)$, so the histogram re-partitions the round-six +budget. The moment certificate gives +\begin{align*} + a_b&=31987/(5\cdot10^8) &&\text{(staircase entrance corner, runs $h-2,h-5,1^6$)},\\ + a_b&=12599/(2\cdot10^8) &&\text{(round-six entrance corner)}, +\end{align*} +and with round six's complex interchange ($a_c=36926111/(5\cdot10^{11})$, $h=24$) the assembly gives +$\kappa=1599247689723/(2.5\cdot10^{16})\approx6.39699\times10^{-5}$ with the staircase corner and +$\kappa=6299103187973/10^{17}$ with the round-six corner. The staircase corner is certified by +\texttt{check\_stair.py} at the same integer point; the entrance edge is not changed by the reordering. + +\end{document} + diff --git a/references/partial-gauge/pr97/deferred.py b/references/partial-gauge/pr97/deferred.py new file mode 100644 index 0000000000..d045126217 --- /dev/null +++ b/references/partial-gauge/pr97/deferred.py @@ -0,0 +1,189 @@ +"""Shared reader and accounting for the round-seven bit side (stdlib only). + +Frozen inputs (certificates/round7/): + witness_23.json.gz the base side program: DAG (leaves = triples of [h], additions), outputs (c, T), retained + totals, links, the flag matrix, the lift index j(n) of every lifted addition and the late-copy + decisions; checked by check_lifted.py; + deferred_23.json.gz the reordered stage-1 word: the slot schedule (ops, the node held by every slot over time, + slot starts, output and retained slots), the deferred readout frames sigma_u, the V-leaf start + frames s_i (both as primitive integer bases), the readout order, the X_S order of every leaf, + the order of the deferred V gates, and the dimension of every node frame and late-copy + intersection (re-derived exactly by check_frames.py). + +Ops: ['add', piv, oth, n] a[piv] += a[oth], the addition of node n; ['fan', piv, [f...]] a[f] += a[piv] for fresh +slots f (copies); ['src', s, n] the V gate a[s] += x_S of leaf n (applied outside L, see check_word.py).""" +import gzip, json, os +from collections import Counter, defaultdict +from itertools import combinations +from math import comb + +HERE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.normpath(os.path.join(HERE, '..', '..')) +DATA = os.path.join(ROOT, 'certificates', 'round7') + + +def load_json(name): + with gzip.open(os.path.join(DATA, name), 'rt') as fh: + return json.load(fh) + + +def load(h=23, witness=None, data=None): + """the base witness and the design-B data of one round-seven witness (default: the files of h).""" + W = load_json(witness or 'witness_%d.json.gz' % h); D = load_json(data or 'deferred_%d.json.gz' % h) + assert W['h'] == D['h'] == h + return W, D + + +class Schedule: + """The design-B schedule in convenient form.""" + def __init__(self, W, D): + self.h = h = D['h']; self.R = D['R']; self.trip = list(combinations(range(h), 3)); self.v = len(self.trip) + self.tid = {T: i for i, T in enumerate(self.trip)} + self.args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()} + self.ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']] + self.hold = D['hold']; self.start = D['start'] + self.out = {s: (c, tuple(T)) for s, c, T in D['out']} + self.ret = {s: c for s, c in D['ret']} + self.srcop = {o[1]: o[2] for o in self.ops if o[0] == 'src'} + self.readout = D['readout_order']; self.sel = set(self.readout) + self.sigma = dict(zip(D['readout_order'], D['sigma'])) + self.f = [0] * self.R + for s, B in self.sigma.items(): self.f[s] = len(B) + self.vstart = dict(zip(D['vleaf_slots'], D['vleaf_start'])) + self.xs = [(n, us) for n, us in D['xs_order']] + self.late_v = D['deferred_v_order'] + self.node_dims = {n: d for n, d in D['node_dims']} + self.late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']} + self.late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()} + self.pivslot = {o[3]: o[1] for o in self.ops if o[0] == 'add'} + + def touch(self, op): + if op[0] == 'add': return [op[1], op[2]] + if op[0] == 'fan': return [op[1]] + list(op[2]) + return [] + + def root_targets(self): + rt = {} + for s, (c, T) in self.out.items(): rt[s] = [self.tid[T]] + for s, c in self.ret.items(): rt[s] = [t for t, T in enumerate(self.trip) if c in T] + return rt + + def adjoint(self): + """garbage coefficients over Z: cov[s][t] = coefficient of slot s's start value in target y_T at the end of L + (the transpose sweep of L applied to the root reads); the F2 circuit uses their parities.""" + cov = [dict() for _ in range(self.R)] + for s, ts in self.root_targets().items(): + for t in ts: cov[s][t] = cov[s].get(t, 0) + 1 + def addto(d, e): + for t, x in e.items(): d[t] = d.get(t, 0) + x + for op in reversed(self.ops): + if op[0] == 'add': addto(cov[op[2]], cov[op[1]]) + elif op[0] == 'fan': + for g in op[2]: addto(cov[op[1]], cov[g]) + return cov + + # ------------------------------------------------------------------ frame keys of every slot's chain + def start_key(self, s): + """('v', s) for a V-leaf slot (start s_i), ('n', n0) for a base or early copy, ('c', n0, late suffix).""" + n0 = self.hold[s][0] + if self.args[n0] is None: return ('v', s) + st = self.start[s]; k = st[2]; dec = self.late.get(n0) + if dec is None or k in dec[0]: return ('n', n0) + lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):])) + + def chain_keys(self, s): + """frames of slot s in time order: [sigma_u | 0], start, then every later node it holds (with the pivot's + late-copy intersections after a node it pivots), its root frame if any, F.""" + ch = [('sigma', s) if s in self.sel else ('0',), self.start_key(s)] + for idx, n in enumerate(self.hold[s]): + if idx > 0: ch.append(('n', n)) + if self.args[n] is not None and self.pivslot.get(n) == s and n in self.late: + lt = self.late[n][1] + for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:]))) + if s in self.out: c, T = self.out[s]; ch.append(('out', c, T)) + if s in self.ret: ch.append(('ret', self.ret[s])) + ch.append(('F',)); return ch + + def dim(self, key): + k = key[0] + if k == '0': return 0 + if k == 'F': return self.h + if k in ('out', 'ret'): return self.h - 1 + if k == 'n': return self.node_dims[key[1]] + if k == 'c': return self.late_dims[key[1], key[2]] + if k == 'sigma': return len(self.sigma[key[1]]) + if k == 'v': return len(self.vstart[key[1]]) + raise KeyError(key) + + def ylevels(self, cov): + """deferred readout levels (dim sigma) on every target, from the garbage-coefficient supports.""" + lev = defaultdict(set) + for s in self.readout: + for t in cov[s]: lev[t].add(self.f[s]) + return {t: sorted(lev[t]) for t in range(self.v)} + + def xdata(self, dimof=None): + dimof = dimof or (lambda s: len(self.vstart[s])) + out = [] + for n, us in self.xs: + ds = [1] + [dimof(s) for s in us] + [self.h] + ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]] + out.append([b - a for a, b in zip(ds, ds[1:])]) + return out + + +def inner(r, h): + """children of a rank-r chain step under the inner-corner lemma (one block of width 2r-h when 2r > h).""" + return [1] * (h - r) + [2 * r - h] if 2 * r > h else [1] * r + + +def chain_ranks(S, dimof=None): + """multiset of chain-step ranks over all slots (dims must be monotone along every chain).""" + dimof = dimof or S.dim; rk = Counter() + for s in range(S.R): + ds = [dimof(k) for k in S.chain_keys(s)] + assert all(b >= a for a, b in zip(ds, ds[1:])), ('decreasing chain', s) + assert ds[-1] == S.h + for a, b in zip(ds, ds[1:]): + if b > a: rk[b - a] += 1 + return rk + + +ROUND6_CORNER = lambda h: [h - 2] + [1] * (h + 1) # data-entrance corner runs, rounds six and seven +STAIRCASE_CORNER = lambda h: [h - 2, h - 5] + [1] * 6 # staircase corner (check_stair.py) + + +def histogram(S, rk, ylev, xdata, corner=None): + """child-width histogram of the batched two-stage bit interchange with deferred readouts and V leaves. + Per stage (stage two is the complement time-reversal of stage one, same edge multiset), each of the v invocations: + every slot u: its auxiliary edge of rank m - r_u (block m - 2 r_u) and its corner of rank r_u = h - dim sigma_u, + both batched by the inner lemma, plus its chain steps; + every centre: the copy's step U_c -> 0 of rank h-1; + every target y_T: the chain 0 -> deferred levels -> t_T^perp (total rank h-1); + every leaf X_S: its chain -> V-gate frames -> F (total rank h-1). + Data: the entrance block m-4h+2 with its corner runs, one copy-correction singleton per pair.""" + h, v, R = S.h, S.v, S.R; m = h * h; N = v * v; A = v * R; H = Counter() + corner = corner or ROUND6_CORNER(h); assert sum(corner) == 2 * h - 1 + corners = Counter(h - S.f[s] for s in range(R)) + for _ in range(2): + for r, c in corners.items(): + H[m - 2 * r] += v * c + for w in inner(r, h): H[w] += v * c + for r, c in rk.items(): + for w in inner(r, h): H[w] += v * c + for _c in range(h): + for w in inner(h - 1, h): H[w] += v + for t in range(v): + ds = sorted(set([0] + ylev[t] + [h - 1])) + for a, b in zip(ds, ds[1:]): + for w in inner(b - a, h): H[w] += v + for xs in xdata: + for x in xs: + for w in inner(x, h): H[w] += v + H[m - 4 * h + 2] += 2 * N + for w in corner: H[w] += 2 * N + H[1] += N + H = {w: c for w, c in H.items() if c} + Wd = 2 * N + 2 * A; L = 2 * v * h * (h - 1); s = Wd * m - N + L + return dict(h=h, m=m, v=v, N=N, W=Wd, L=L, s=s, R=R, hist=H) + diff --git a/references/partial-gauge/pr97/deferred_23.json.gz b/references/partial-gauge/pr97/deferred_23.json.gz new file mode 100644 index 0000000000..4a4431bd42 Binary files /dev/null and b/references/partial-gauge/pr97/deferred_23.json.gz differ diff --git a/references/partial-gauge/pr97/linalg.py b/references/partial-gauge/pr97/linalg.py new file mode 100644 index 0000000000..a81cbaa61e --- /dev/null +++ b/references/partial-gauge/pr97/linalg.py @@ -0,0 +1,176 @@ +"""Stdlib exact linear algebra used by the release checks (no numpy). + +Ranks over Q are computed in one of two rigorous ways: + * modulo a prime p with a Hadamard certificate: if every row of an integer matrix has squared norm n_i and + prod_i max(1, n_i) < p^2, every minor has absolute value < p, so a minor is nonzero over Q iff it is nonzero + mod p, and the rank mod p equals the rank over Q (hadamard_ok); + * exactly, by fraction-free (Bareiss) elimination over Z (rank_exact) or Fraction elimination (null_exact). +Everything else is plain arithmetic modulo a prime.""" +from fractions import Fraction +from math import gcd + +Q31 = 2**31 - 1 # prime used for the point evaluation and frame reductions +M127 = 2**127 - 1 # Mersenne prime +M521 = 2**521 - 1 # Mersenne prime + + +def hadamard_ok(rows, p): + """True if prod of max(1, |row|^2) < p^2, i.e. every minor of the integer matrix is below p in absolute value.""" + b = 1; p2 = p * p + for r in rows: + b *= max(1, sum(x * x for x in r)) + if b >= p2: return False + return True + + +class Echelon: + """Row echelon basis mod p, built by insertion. Each stored row has a pivot (first nonzero, normalised to 1) + and zeros in the pivot columns of all earlier rows, so reducing a new row against the rows in order is exact.""" + __slots__ = ('p', 'rows', 'piv') + + def __init__(self, p): + self.p = p; self.rows = []; self.piv = [] + + def reduce(self, r): + p = self.p; r = [x % p for x in r] + for pc, b in zip(self.piv, self.rows): + c = r[pc] + if c: r = [(x - c * y) % p for x, y in zip(r, b)] + return r + + def insert(self, r): + """insert row; returns True if it was independent.""" + r = self.reduce(r) + for i, x in enumerate(r): + if x: + inv = pow(x, self.p - 2, self.p) + self.rows.append([(y * inv) % self.p for y in r]); self.piv.append(i); return True + return False + + def contains(self, r): + return not any(self.reduce(r)) + + def __len__(self): return len(self.rows) + + +def rank_mod(rows, p): + E = Echelon(p) + for r in rows: E.insert(r) + return len(E) + + +def rank_exact(rows): + """exact rank over Q of an integer matrix (Bareiss fraction-free elimination).""" + M = [list(r) for r in rows if any(r)] + if not M: return 0 + n = len(M); k = len(M[0]); r = 0; prev = 1 + for c in range(k): + i = next((i for i in range(r, n) if M[i][c]), None) + if i is None: continue + M[r], M[i] = M[i], M[r] + pr = M[r]; a = pr[c] + for t in range(r + 1, n): + row = M[t]; b = row[c] + M[t] = [(a * x - b * y) // prev for x, y in zip(row, pr)] + prev = a; r += 1 + if r == n: break + return r + + +def null_mod(A, k, p): + """basis of {x in F_p^k : A x = 0} (A: list of rows of length k).""" + rows = [[x % p for x in r] for r in A]; piv = []; R = [] + for r in rows: + for pc, b in zip(piv, R): + c = r[pc] + if c: r = [(x - c * y) % p for x, y in zip(r, b)] + i = next((i for i, x in enumerate(r) if x), None) + if i is None: continue + inv = pow(r[i], p - 2, p); r = [(y * inv) % p for y in r] + R = [[(x - b[i] * y) % p for x, y in zip(b, r)] if b[i] else b for b in R] # keep fully reduced + R.append(r); piv.append(i) + free = [c for c in range(k) if c not in piv]; out = [] + for f in free: + x = [0] * k; x[f] = 1 + for pc, b in zip(piv, R): x[pc] = (-b[f]) % p + out.append(x) + return out + + +def null_exact(A, k): + """basis (integer vectors) of {x in Q^k : A x = 0}, by Fraction reduced row echelon form.""" + R = []; piv = [] + for r0 in A: + r = [Fraction(x) for x in r0] + for pc, b in zip(piv, R): + c = r[pc] + if c: r = [x - c * y for x, y in zip(r, b)] + i = next((i for i, x in enumerate(r) if x), None) + if i is None: continue + inv = 1 / r[i]; r = [y * inv for y in r] + R = [[x - b[i] * y for x, y in zip(b, r)] if b[i] else b for b in R] + R.append(r); piv.append(i) + free = [c for c in range(k) if c not in piv]; out = [] + for f in free: + x = [Fraction(0)] * k; x[f] = Fraction(1) + for pc, b in zip(piv, R): x[pc] = -b[f] + out.append(primitive(x)) + return out + + +def primitive(x): + """scale a rational vector to a primitive integer vector.""" + den = 1 + for v in x: den = den * v.denominator // gcd(den, v.denominator) + y = [int(v * den) for v in x]; g = 0 + for v in y: g = gcd(g, v) + return [v // g for v in y] if g else y + + +def inv_mod_matrix(A, p): + """inverse of a square matrix mod p, or None if singular.""" + n = len(A); M = [[x % p for x in A[i]] + [int(i == j) for j in range(n)] for i in range(n)] + for c in range(n): + i = next((i for i in range(c, n) if M[i][c]), None) + if i is None: return None + M[c], M[i] = M[i], M[c] + inv = pow(M[c][c], p - 2, p); M[c] = [(x * inv) % p for x in M[c]] + rc = M[c] + for t in range(n): + if t != c and M[t][c]: + f = M[t][c]; M[t] = [(x - f * y) % p for x, y in zip(M[t], rc)] + return [r[n:] for r in M] + + +def matmul(A, B, p): + Bt = list(zip(*B)) + return [[sum(x * y for x, y in zip(r, c)) % p for c in Bt] for r in A] + + +def rightmost_pivots(Q, p): + """rows top to bottom: the rightmost nonzero column of the reduced row, then eliminate it below.""" + M = [list(r) for r in Q]; n = len(M); out = [-1] * n + for i in range(n): + row = M[i]; c = next((j for j in range(len(row) - 1, -1, -1) if row[j]), -1) + out[i] = c + if c < 0: continue + inv = pow(row[c], p - 2, p) + for t in range(i + 1, n): + f = M[t][c] + if f: + f = f * inv % p; M[t] = [(x - f * y) % p for x, y in zip(M[t], row)] + return out + + +def predicted(h): + """pivot column per row of the generic north-east rank function f_r of a rank-r idempotent.""" + pr = {} + for r in range(1, h + 1): + s = h - r + f = lambda i, j: 0 if i < 0 or j >= h else min(i + 1, h - j, r, max(0, i - j + 1) + s) + pc = [-1] * h + for i in range(h): + for j in range(h): + if f(i, j) - f(i - 1, j) - f(i, j + 1) + f(i - 1, j + 1) == 1: pc[i] = j + pr[r] = pc + return pr diff --git a/references/partial-gauge/pr97/round7_literal_frame_ledger.py b/references/partial-gauge/pr97/round7_literal_frame_ledger.py new file mode 100644 index 0000000000..aa0de9ed8a --- /dev/null +++ b/references/partial-gauge/pr97/round7_literal_frame_ledger.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +"""Explicit forward and reflected frame/event ledger of pinned round-seven. +Zhihao Chen / Codex audit. Exact nesting of the supplied chains is inherited +from the separately run frame/lifted checkers, not inferred from ranks here. +Copied-center moves are temporary macros, not erased arbitrary scratch. +""" +import sys,json,signal,time,hashlib,gzip +from pathlib import Path +from collections import defaultdict,Counter +from array import array +HERE=Path(__file__).resolve().parent;ROOT=HERE/'swapnil-round7' +sys.path.insert(0,str(ROOT/'independent/deferred-readout')) +import deferred as dr + +def main(): + started=time.monotonic() + def stop(*_):raise TimeoutError('180 second literal ledger limit') + signal.signal(signal.SIGALRM,stop);signal.alarm(180) + W,D=dr.load(23);S=dr.Schedule(W,D);v,R,h=S.v,S.R,S.h;size=2*v+R + co=S.adjoint();sel=S.sel;ops=S.ops;prev={};pred=defaultdict(list);last={} + for i,op in enumerate(ops): + for s in S.touch(op): + if s in prev:pred[i].append(prev[s]) + prev[s]=i;last[s]=i + ph=set();stack=[last[s] for s in S.ret] + while stack: + i=stack.pop() + if i in ph:continue + ph.add(i);stack.extend(pred[i]) + assert not any(set(S.touch(ops[i]))&sel for i in ph) + keys=[];ids={};dims=[] + def norm(k): + if k[0]=='out':return ('out',0,tuple(k[2])) + return k + def key(k): + k=norm(k) + if k not in ids: + ids[k]=len(keys);keys.append(k);dims.append(S.dim(k)) + return ids[k] + z,F=key(('0',)),key(('F',)) + paths=[None]*size + for n,ss in S.xs:paths[n-1]=[key(('n',n))]+[key(('v',s)) for s in ss]+[F] + y=[[] for _ in range(v)] + for s in S.readout: + for t,c in co[s].items(): + if c&1:y[t].append(key(('sigma',s))) + for t,T in enumerate(S.trip):paths[v+t]=[z]+y[t]+[key(('out',0,T))] + for s in range(R):paths[2*v+s]=[key(k) for k in S.chain_keys(s)] + assert all(p and all(dims[b]>=dims[a] for a,b in zip(p,p[1:])) for p in paths) + pos=[0]*size;current=[p[0] for p in paths];initial=current[:] + # Fixed-width event records: kind, register/destination, source-or-old, + # new-or-common, rank. kind=0 move,1 xor,2 temporary copied-center macro. + events=array('i');rank_hist={k:Counter() for k in ('aux','data','center')} + bits=[1<=0 + emit(0,s,a,b,r);rank_hist['aux' if s>=2*v else 'data'][r]+=1 + pos[s]+=1;current[s]=b + def xor(t,s): + assert current[t]==current[s],('gate frames',t,s,keys[current[t]],keys[current[s]]) + emit(1,t,s,current[t]);bits[t]^=bits[s] + def readout(s): + aux=2*v+s;f=key(('sigma',s)) if s in sel else z + assert current[aux]==f + for t,c in sorted(co[s].items()): + if c&1:move(v+t,f);xor(v+t,aux) + def source(s,active): + frame=key(('v',s)) if active else F + move(2*v+s,frame);move(S.srcop[s]-1,frame);xor(2*v+s,S.srcop[s]-1) + reordered_fans=[] + def operation(i,active): + op=ops[i] + if op[0]=='add': + _,p,o,n=op;frame=key(('n',n)) if active else F + move(2*v+p,frame);move(2*v+o,frame);xor(2*v+p,2*v+o) + elif op[0]=='fan': + # Scalar fan targets commute. The archive groups copies whose + # physical start frames differ; execute them in frame-chain order. + targets=sorted(op[2],key=lambda s:S.dim(S.start_key(s))) if active else op[2] + if active and tuple(targets)!=tuple(op[2]):reordered_fans.append(i) + for s in targets: + frame=key(S.start_key(s)) if active else F + move(2*v+op[1],frame);move(2*v+s,frame);xor(2*v+s,2*v+op[1]) + for s in range(R): + if s not in sel:readout(s) + early=sorted(set(S.srcop)-sel,key=lambda s:(S.srcop[s],len(S.vstart[s]),s)) + for s in early:source(s,True) + first=[i for i in range(len(ops)) if i in ph and ops[i][0]!='src'] + rest=[i for i in range(len(ops)) if i not in ph and ops[i][0]!='src'] + centers={} + for i in first:operation(i,True) + for s,c in S.ret.items(): + a=2*v+s;f=key(('ret',c));move(a,f) + targets=[v+t for t,T in enumerate(S.trip) if c in T] + assert all(current[t]==z for t in targets) + centers[a]=targets;emit(2,a,f,z,h-1);rank_hist['center'][h-1]+=1 + for t in targets:bits[t]^=bits[a] + for s in S.readout:readout(s) + for s in S.late_v:source(s,True) + for i in rest:operation(i,True) + for s,(c,T) in S.out.items(): + t=S.tid[T];f=key(('out',0,T));move(2*v+s,f);move(v+t,f);xor(v+t,2*v+s) + for i in reversed(first+rest):operation(i,False) + for s in S.srcop:source(s,False) + for s in range(R):move(2*v+s,F) + assert all(bits[i]==((1< 1: + values = array.array(values.typecode, values) + values.byteswap() + values.tofile(f) + + +def build(witness, prefix): + w = json.loads(gzip.decompress(Path(witness).read_bytes())) + h, v, d = w['h'], w['v'], w['central_disjoint'] + assert (h, d, w['center_denominator']) == (24, 24, 21) + triples = list(combinations(range(h), 3)) + assert v == len(triples) + args = [(0, 0)]; support = [0]; core = [0]; cover = [0]; types = [0]; ranks = [0] + for j, t in enumerate(triples): + mask = sum(1 << a for a in t) + args.append((0, 0)); support.append(1 << j); core.append(mask); cover.append(mask) + types.append(1); ranks.append(1) + flat = w['args'] + assert len(flat) % 2 == 0 + for k in range(0, len(flat), 2): + a, b, x = flat[k], flat[k+1], len(args) + assert 0 < a < x and 0 < b < x, 'Operands must precede their sum' + assert not support[a] & support[b], 'Ordinary additions must be cancellation-free' + args.append((a, b)); support.append(support[a] | support[b]) + core.append(core[a] & core[b]); cover.append(cover[a] | cover[b]) + if core[x].bit_count() >= 2: + types.append(1); ranks.append(support[x].bit_count()) + else: + types.append(2); ranks.append(cover[x].bit_count()) + n = len(args) + point_masks = [sum(1 << j for j, t in enumerate(triples) if a in t) for a in range(h)] + full_support = (1 << v) - 1 + roots, kind = [], [] + assert len(w['D']) == v + for t, node in zip(triples, w['D']): + assert 0 < node < n + assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]]) + target_mask = sum(1 << a for a in t) + if types[node] == 2: + assert not cover[node] & target_mask + else: + assert types[node] == 1 + assert not support[node] & (point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]]) + roots.append(node); kind.append(0) + stars = [(a, b, i) for a, b in combinations(range(h), 2) for i in range(h) if i not in (a, b)] + assert len(w['P']) == len(stars) + pair_outputs = {} + for (a, b, i), node in zip(stars, w['P']): + assert 0 < node < n + assert support[node] == point_masks[a] & point_masks[b] & ~point_masks[i] + assert types[node] == 1 + assert not support[node] & (point_masks[a]^point_masks[b]^point_masks[i]) + pair_outputs[a, b, i] = node + roots.append(node); kind.append(0) + assert len(w['A']) == d + for i, node in enumerate(w['A']): + assert 0 < node < n + assert support[node] == full_support & ~point_masks[i] + assert types[node] == 2 and cover[node] == ((1 << h)-1) ^ (1 << i) + assert ranks[node] == h-1 + roots.append(node); kind.append(1) + # Every A_i avoids i, so sum A_i = (h-3)T. The decoder is T=sum A_i/21 + # and the scatter is T-(1/2)sum_{i in target} A_i. + decoder = Fraction(1, h-3) + assert decoder == Fraction(1, 21) + scatter_coefficients = [decoder, decoder-Fraction(1, 2)] + for coefficient in scatter_coefficients: + odd_denominator = coefficient.denominator + while odd_denominator % 2 == 0: + odd_denominator //= 2 + assert 21 % odd_denominator == 0 and abs(coefficient) <= 1 + for source in triples: + assert sum(i not in source for i in range(h))*decoder == 1 + Dset = set(range(d)) + for triple in triples: + k = len(Dset.intersection(triple)) + assert 2*(3-k)-2*(d-k) == 2*(3-d) + patterns = {} + for target in triples: + chosen = len(Dset.intersection(target)) + if chosen not in patterns: + patterns[chosen] = target + for chosen, target in patterns.items(): + target_set = set(target) + for source in triples: + k = len(Dset.intersection(source)) + total_coefficient = Fraction(2*(3-k)-2*(d-k), 2*(3-d)) + scalar = Fraction(len((target_set-Dset).intersection(source)), 2) + scalar -= Fraction(len((target_set & Dset)-set(source)), 2) + scalar += Fraction(chosen-1, 2)*total_coefficient + assert scalar == Fraction(len(target_set.intersection(source))-1, 2) + for j, t in enumerate(triples): + masks = [point_masks[a] for a in t] + two = (masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0]) + actual = 0 + for a, b in combinations(t, 2): + excluded = next(i for i in t if i not in (a, b)) + actual |= support[pair_outputs[a, b, excluded]] + assert actual == two + assert masks[0]&masks[1]&masks[2] == 1 << j + assert [((k-1)+(k == 0)-(k == 2)) for k in range(4)] == [0, 0, 0, 2] + + def contained(x, y): + tx, ty = types[x], types[y] + if tx == 1 and ty == 1: return not(core[y]&~core[x] or cover[x]&~cover[y]) + if tx in (1, 2) and ty == 2: return not cover[x]&~cover[y] + return False + active = [0]*n; stack = list(roots) + while stack: + x = stack.pop() + if not x or active[x]: continue + active[x] = 1 + if args[x][0]: stack.extend(args[x]) + degree = [0]*n + for x in range(1, n): + if active[x]: + if types[x] == 1: + assert core[x].bit_count() >= 2 and ranks[x] == support[x].bit_count() + else: + assert types[x] == 2 and ranks[x] == cover[x].bit_count() + if active[x] and args[x][0]: + for y in args[x]: + assert y < x and contained(y, x), 'Binary frame nesting failed' + degree[y] += 1 + for x in roots: degree[x] += 1 + H = [0]*(h+1); c = 0; loss = 0 + for x in range(1, n): + if not active[x]: continue + r = ranks[x] + if args[x][0]: + c += 1; H[r] += degree[x]-1; H[h-r] += 1 + for y in args[x]: + assert r >= ranks[y] + H[r-ranks[y]] += 1 + else: H[1] += degree[x] + for x, k in zip(roots, kind): + r = ranks[x] + if k: H[r] += 1; H[h] += 1; loss += r + else: H[h-1-r] += 1; H[1] += 1 + q = len(roots); R = c+q + result = dict(h=h, v=v, c=c, q=q, R=R, loss=loss, central_disjoint=d, histogram=H, + rank_sum=sum(r*m for r, m in enumerate(H))) + assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss + result['center_denominator'] = 21 + result['scalar_validation'] = dict(ordinary_supports_exact=True, centers_exact=True, + center_decoder='sum A_i / 21', scatter_coefficients=list(map(str, scatter_coefficients)), + rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True, + binary_frames_nondegenerate=True) + with open(str(prefix)+'.bin', 'wb') as f: + f.write(struct.pack('<4I', h, v, n, q)) + write_array(f, array.array('I', (a for pair in args for a in pair))) + write_array(f, array.array('Q', core)); write_array(f, array.array('Q', cover)) + write_array(f, array.array('I', roots)); write_array(f, array.array('I', kind)) + write_array(f, array.array('B', active)) + with open(str(prefix)+'.labels', 'wb') as f: + write_array(f, array.array('I', ranks)); write_array(f, array.array('B', types)) + Path(str(prefix)+'.json').write_text(json.dumps(result, indent=2)+'\n') + return result diff --git a/research/cover-local-reuse/BIT-PADDED.md b/research/cover-local-reuse/BIT-PADDED.md new file mode 100644 index 0000000000..b79d2cc15e --- /dev/null +++ b/research/cover-local-reuse/BIT-PADDED.md @@ -0,0 +1,37 @@ +# Paid triple sharing in the weighted bit cover + +This extension retains the source-bound PR97 local word and the weighted-child, local-ring fallback, ordered-affine, ordinary-leaf and internal-row contracts in `notes/three-stage-cover-bit.tex` and `notes/three-stage-cover-rows.tex`. PR130 is due to icekylinx with OpenAI GPT-6 Astra assistance; the retained local word is due to Zhihao Chen and Swapnil Jain. This extension was prepared for eumemic with OpenAI Codex assistance. Apache-2.0. + +## Geometry and paid data finishes + +Use h = 23, v = 1771, R = 28866 and m = 69. Add a passive two-dimensional summand D to the retained 67-dimensional A ⊥ B ⊥ C geometry. The original rational port involutions fix D. Their active projectors sum to P_E0 + 2P_q, so the old data calculation completes its interchange on E0. Both data banks then pay their nested rank-2 transition on D: 2v children per vertex, or 6v per three-vertex cell. These are weighted split-projector children and are included in both the ideal histogram and the bad-class surcharge. + +In the retained rational basis (q0, k2, …, k23) of A, the three blocks A, (D1 ⊕ B), and (D2 ⊕ C) have dimension 23. Define τ to cycle their displayed bases. Then τ³ = I, τ ≠ I, and τ² ≠ I. A is the actual local active space; the other blocks lie in its projector kernel. This fixed rational chart describes a cover element; it introduces no executed dense adapter. Every local source injection, internal gate, data front and readout is retained. + +## Completed residuals and inherited weights + +In aligned reversed-tail coordinates, the retained partial interchange D_P satisfies D_P² = I and D_P D_Q = D_(P+Q) whenever P and Q are disjoint split projectors. Let S be a source-gauge projector inside A and O the current stage's outside projector. The forward entry and exit are D_O D_S and D_O D_A, giving completed residual D_A D_S = D_(A−S). The reversed entry and exit are D_O and D_O D_S D_A, giving the inverse residual. These are equal involutions in the bit contract. + +The outside factor cancels **before** residuals at different vertices are combined. It may overlap another vertex's active block. The complete local arbitrary-dirty-scratch identity factors a completed core into its data action and this auxiliary residual. A subsequent completed core may therefore use the same bank with arbitrary current contents. The three full cores execute successively; internal scalar gates are never combined into a larger-width gate. + +At vertices g, gτ and gτ², the three projectors A−S occupy disjoint blocks and mutually annihilate. If exit nullity is u = 23 − dim S, their sum P has split rank 3u. The final exterior F D_P⁻¹ = D_(I−P) has split rank 69 − 3u = 3 dim S. A zero-rank exterior is exactly identity and creates no recursive child. Each stage has its own shared bank family; all three stages use this construction. + +The weighted identity is a **common conjugation** by Q_A = diag(A, I). The inherited diagonal units are independent of every fresh vertex, coset, stage and bank role field. They commute with fresh role routing and are identical across the three shared uses. Thus the product of Q_A D_Pj Q_A⁻¹ is Q_A D_(ΣPj) Q_A⁻¹, and the paid exterior is Q_A D_(I−ΣPj) Q_A⁻¹. It is one weighted split-projector child, including for the reversed stage. + +The new combined projector is a fixed rational matrix conjugated by the current g. The retained generic weighted elimination applies: diagonal pivot units stay in the child's descriptor. Exposed parent role fields become ancestor spectators at the child; fresh child roles use disjoint unused stock. Therefore weight independence is preserved recursively. The exact rational example checks in `bit_padded.py` are corruption controls; the displayed polynomial projector identities establish the general case over any admissible odd local ring. + +## Cosets, batching and complete fallback charges + +Choose q only after the port maps, τ, individual and combined projectors, and rank witnesses have been fixed. It exceeds 2^80 and avoids their finite denominator and witness-prime set. Reduction of τ retains order three. The right action is free: gτʲ = g implies τʲ = I. + +Choose one representative from each three-element low-residue orbit. Every full orbit has exactly one member reducing to that representative, with all 69² high-matrix coordinates free. The bank chart therefore has |GL_69(F_q)|/3 low types and the unchanged q^(69²(w−1)) high matrices. Routing to another member or port involution remains a fixed affine high-matrix map with its low-type carry. Three orbit phases are a fixed constant. Every high matrix is batched once per fixed operation type; a completed call restores its row coordinate before reuse. + +For each nonzero new projector, similarity to diag(I_r, 0) supplies nonzero pivot-minor polynomials. The chosen prime preserves the fixed rank witnesses. The retained full-group degree bound is 2·69³/q. A selected orbit-representative or fixed-phase subset has density 1/3, so conditioning can increase this bound by at most three. We conservatively use 6·69³/q < 10⁻¹⁶ **for each edge separately**, including the tails, without assuming invariance of the bad set. Every bad edge pays the full retained 32·69²-child local-ring fallback, each child at most one coarse field. This includes the new exterior and spectator edges. There is no union bound across edge types and no subtraction of displaced good cost. + +The paid histogram per cell is 9H_local + 3Σ_u n_u[69−3u] + 6v[2], with zero ranks omitted. Its allocation is 6v + 3R = 97224; rank mass 6702384; deficit 6072; maximum child 66; and actual nonzero edge count 1698207. The exact checker adds the entire fallback surcharge to the rank and characteristic moments and rejects the next 10⁻¹² coarse enclosure grid point. + +## Borrowed rows and effective saving + +The full role stock is (|GL_69(F_q)|/3)·(6v+3R)·q^(69²(w−1)). The maximum child ratio 66/69 gives halving degree 16. The complete-row divisor still has logarithm O(w log e), so the retained borrowed-and-restored row construction, single outer padding, ordinary wrapper, binary conversion and fixed-tape argument apply with changed constants. No external group-sized stock is introduced. + +For atom exponent 1/1000, the exact coarse saving is 22550837/50000000000. Combining it with old leaf saving 384599/10¹⁰ gives effective ordinary saving 11265104579/25000000000000 = 0.00045060418316. Both atom adapters and borrowing terms remain strictly subordinate. This retains the original local, weighted-streaming and multiplication-framework proof contracts. diff --git a/research/cover-local-reuse/NOTICE b/research/cover-local-reuse/NOTICE new file mode 100644 index 0000000000..308e67cc99 --- /dev/null +++ b/research/cover-local-reuse/NOTICE @@ -0,0 +1,46 @@ +Arbitrary physical frames and source gauges under the three-stage cover, 2026-10-09. + +The new composition, source closure and verifier were prepared for eumemic +with OpenAI Codex assistance. Apache-2.0 applies. No official endorsement or +independent external peer review is claimed. + +The three-stage cover, generalized Clifford frames, weighted bit supplier +and internal row borrowing are icekylinx's PR130 contribution, prepared with +OpenAI GPT-6 Astra and Codex assistance. The exact adopted commit is recorded +in SOURCE.json. Its original root NOTICE and all reference notices remain +unchanged. + +The pinned PR117 scalar DAG is by eumemic with Anthropic Claude assistance. +Its copyright, Apache-2.0 license and original notice remain in +references/three-stage-cover/pr117/. Compensated birth-cut reuse follows +jamesyc's PR124. Physical hull frames and their full literal reflection were +developed for eumemic with OpenAI Codex assistance in PR129. +The further arbitrary-subspace descent uses PR130's generalized Clifford +theorem, keeps source/root/gauge/reuse handoffs fixed, and was prepared for +eumemic with OpenAI Codex assistance. It claims no replacement proof of +PR130's all-size weighted and uniform transfer interfaces. +The subsequent individual and joint source-gauge descent, exact target-chain +checks and replay integration were also prepared for eumemic with OpenAI +Codex assistance. The fixed reuse mapping and all compensations remain paid. + +Swapnil Jain's round-seven bit witness and Zhihao Chen's PR97 physical +ledger retain their original notices under references/partial-gauge/pr97/. +The inherited semantic, product-row, analytic and fixed-tape interfaces +retain credit to icekylinx, Zhihao Chen, RaD / hipotures, and the other +contributors named in the root NOTICE. No predecessor notice is superseded. + +The orthogonal involution is credited to Avi Eisenberg / ikeboy +(PR132, Anthropic Claude assistance). This composition executes complete +cores sequentially in each of the three stages, retains all local children, and independently audits +the completed residual. It does not adopt the simultaneous lockstep step. + +The padded72D complex ports, three-vertex completed sharing, paid data +endings and padded69D weighted bit cover were prepared for eumemic with +OpenAI Codex assistance, retaining PR130's general Clifford and weighted +local-ring interfaces. All new finite children and fallback charges are paid. + +The h22 extension deterministically restricts the original h24 PR117 DAG to +its first 22 coordinates and regenerates the physical word, frames, gauges +and compensated reuses. The pinned original witness and its attribution are +preserved. This restriction and the padded66D cover were prepared for +eumemic with OpenAI Codex assistance. diff --git a/research/cover-local-reuse/PADDED-GEOMETRY.md b/research/cover-local-reuse/PADDED-GEOMETRY.md new file mode 100644 index 0000000000..611842a00b --- /dev/null +++ b/research/cover-local-reuse/PADDED-GEOMETRY.md @@ -0,0 +1,101 @@ +# Padded cover with completed groups of three + +This construction retains the audited physical local word, its compensated reuse, +and every scalar operation. It changes the ambient space, auxiliary allocation, +and final auxiliary/data transformations. Each local core finishes before the next +core uses its scratch bank. + +## Cover and paid data endings + +Start with the inherited spaces `A`, `B`, `C` of dimensions 22, 21, 21 and add an +orthogonal two-dimensional space `D`. Write `E0 = A + B + C` and `E = E0 + D`, so +`dim E = 66`. The inherited port involutions `R12,S` and `R23,S` act identically on +`D`; use the full finite group `G = O(E)`. Its order and the resulting wire stock +remain in the finite scalar/router and assembly charges. + +For every actual triple port, the three local data segments have exactly their +inherited frames inside `g E0`. At the end of stage three, the first data bank has +frame `g E0` and the second has frame `g(E0 intersect q-perp)`. Their final frames +are `E` and `(g q)-perp`. Each extension has dimension two and therefore costs one +width-two child. Both data banks pay this cost: `2v` children per vertex, or `6v` +per three-vertex accounting cell. + +The exact endpoints may be chosen as `(F_E0, F_E0 T_q^-1)` before finishing. Apply +`F_total F_E0^-1` to each bank. The exact operators then become +`(F_total, F_total T_q^-1)`. The original input Pauli correction, sign and bank +exchange still produce two copies of `F_total`. This argument uses an exact +operator ratio and its checked rank; it does not equate arbitrary lifts merely +because their binary symplectic matrices agree. + +## Sequential sharing in every stage + +Let `tau` cycle the three coordinate blocks of size 22. It is orthogonal and has +order three. Right cosets of `` partition every stage's invocation set into +three distinct vertices `k`, `k tau`, `k tau^2`; their active spaces are mutually +orthogonal and cover `E`. Each stage allocates a separate bank of `R` physical +roles per coset. Within a coset, run all three cores to completion in a fixed +order. Data positions remain distinct within a stage, as in the inherited cover. + +A completed local core accepts arbitrary physical dirty scratch. Its transparent +scalar word cancels all scratch contributions to the data and restores the +logical scratch; its prescribed physical residual need not be the identity. +For entrance gauge `T_sigma`, a forward core's residual is + +`P = F_active T_sigma^-1`. + +The middle reversed core has residual `P^-1 = T_sigma F_active^-1`. The common +stage offset is orthogonal to that core's active space. It commutes with both +active operators and cancels from the completed residual: + +- Forward entrance/exit: `F_offset T_sigma`, `F_offset F_active`. +- Reversed entrance/exit: `F_offset`, `F_offset T_sigma F_active^-1`. + +An offset may intersect another core's active space. That does not obstruct the +sequential construction: the next complete core accepts the arbitrary physical +scratch left by its predecessor. No residual is moved through an unfinished +scalar gate, and the internal scalar operations of different cores are never +merged. + +For one physical role, let the three completed residuals in a stage be +`R1`, `R2`, `R3`. Define its final transformation by the exact operator equation + +`Tail = F_total (R3 R2 R1)^-1`. + +Then `Tail R3 R2 R1 = F_total`, including the exact phases. The three residuals +act on separate tensor factors. Applying the inherited general Clifford rank +formula to each factor gives tail rank `3 dim(sigma)` in both forward and reversed +stages. This includes degenerate source gauges. The checker constructs the +binary symplectic operators for every physical source-frame type and checks this +rank independently in all three stages. + +A zero-width tail is still a physical rank-zero Clifford adapter: a fixed binary +address permutation with unit quadratic phases. It is excluded only from the +positive-width recursive-child multiset. The outer certificate adds the explicit conservative supplemental charge +`32 (m+1)^3 (|G| R + 2 |G| v)` for the completed auxiliary tails and both data +endings per vertex. It recomputes the entire semantic guard after adding this +charge. The inherited local and finite-router reserves remain paid as well. + +## Complete paid profile + +Let `H` be the complete one-invocation local histogram after removing only the +old two-stage bridges, endpoint copies and old exteriors. It includes source and +target movements, physical auxiliary transitions and copied-center children. +Let `s_d` count actual physical roles whose source gauge has dimension `d`. +For a three-vertex accounting cell, all three stages contribute: + +- Nine unchanged copies of `H`. +- `3 s_d` final auxiliary children of width `3d`, omitting only width-zero + recursive children while retaining their physical adapters. +- `6v` data-ending children of width two. + +The persistent stock is `W_cell = 6v + 3R`. For the frozen audited supplier, +`v = 1540`, `R = 21274`, so `W_cell = 73062`, rank mass is `4817010`, deficit is +`5082`, and the largest child has width `60 < 66`. The deficit is exactly +`3(2v - 3 ell)` with `ell = 462`; the two new data dimensions are fully paid. +Both data finishes contribute `6v = 9240` children of width two per cell. + +`padded_checks.py` checks every physical source-frame type, every one of the 1540 +actual ports, every stage's offset and orientation, the three-cycle partition, +the complete histogram and controls rejecting omitted data endings or residuals. +These finite checks retain the inherited all-size Clifford, scalar transparency, +weighted-bit, fixed-tape and analytic interfaces as explicit dependencies. diff --git a/research/cover-local-reuse/README.md b/research/cover-local-reuse/README.md new file mode 100644 index 0000000000..d89c31adfa --- /dev/null +++ b/research/cover-local-reuse/README.md @@ -0,0 +1,118 @@ +# Restricted 22-dimensional padded triple covers + +Conditional **κ = 420151003347/10¹⁵ = 0.000420151003347**. +The exact complex saving is **210252177/500000000000 = 0.000420504354**. +The complex side binds; the retained padded bit saving is 0.00045060418316. +The assembly uses positive rational slack parameters β = 10⁻¹⁸, η = 10⁻¹⁵ +and backoff 10⁻²⁶, with all strict constraints checked explicitly. + +The complex supplier deterministically restricts the immutable PR117 +24-dimensional scalar DAG to its first 22 coordinates. The original +compressed witness stays pinned at SHA-256 +`3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b`. +The restriction removes zero summands, collapses unary additions and merges +identical supports. It independently checks every resulting root support, +then regenerates the physical producer, carrier matching, frames, gauges +and compensated reuses. The restricted record has 66,234 additions; pruning +unused nodes leaves 64,140 live additions and 47,345 carrier links for 1,540 +triple ports. Its scalar readouts use exact numerator/38 chunks. + +The reconstructed local word has 22,977 virtual roles in 21,274 physical +slots, with 1,703 compensated birth-cut reuses. The complete source/workspace +chronology and its actual inverse retain every compensation. There are +2,865 deferred virtual roles, including all reused recipients; 111 deferred +gauges are degenerate. The physical inventory has 764 distinct source-frame +types, 1,162 nonzero source gauges and source-dimension sum 19,488. + +Arbitrary binary operation frames and source gauges use PR130's generalized +Clifford contract, including degenerate subspaces. Exact containment checks +fix the source injections, root frames and compensated handoffs. A second +gauge descent uses the paid padded-triple objective. All search choices use +frozen integer weights; the resulting children and characteristic moments +are certified with exact arithmetic. The complete reflected audit checks +literal frame incidences, exact source/readout coefficients, arbitrary dirty +scratch cancellation and every bounded scalar operation. + +The complex cover has dimension 66, with three orthogonal active spaces of +22 coordinates. A cell of three invocation vertices pays: + +| Quantity | Complex cover | +|---|---:| +| Persistent roles | 73,062 | +| Recursive rank | 4,817,010 | +| Rank deficit | 5,082 | +| Largest child | 60 | +| Complete local histogram copies | 9 | +| Rank-two data finishes | 9,240 | + +The original 64-dimensional ports extend by the identity on two padding +coordinates. Both data banks then pay a rank-two finish. Each stage has a +separate shared scratch bank, and every core finishes its entire scalar and +inverse word before the next core begins. Each accepts arbitrary incoming +scratch and leaves its exact completed frame residual. The forward residual +is `F_active T_sigma^-1`; the reversed middle stage uses its inverse. +Offsets cancel inside each completed core. + +For each physical source gauge of dimension d, the final exterior pays +three children of width **3d**, one for each independent stage bank. The +exact tail is `F_total (R3 R2 R1)^-1`, so its product with the completed +residuals includes the correct phases. Zero-width tails still pay their +rank-zero Clifford adapters. An explicit supplemental scalar reserve pays +all auxiliary adapters and both data finishes, and the semantic budget is +recomputed. The full group order, finite router, virtual-role scalar guard +and row reserve remain charged. [PADDED-GEOMETRY.md](PADDED-GEOMETRY.md) +gives the exact port, residual, padding and cost arguments. + +The unchanged padded bit supplier surrounds the retained PR97 word with a +69-dimensional cover. Its per-cell ledger has 97,224 roles, rank 6,702,384 +and deficit 6,072. It retains all nine local copies, both data finishes and +the complete rare-class fallback. The bad-class bound includes the factor +of three from conditioning on a coset representative. Its effective saving +is **11265104579/25000000000000 = 0.00045060418316**. +[BIT-PADDED.md](BIT-PADDED.md) states the weighted residual and fallback +arguments. The upstream complete-basis and rational-frame suites remain +inherited, as in PR130; this package does not claim to rerun them. + +Run from the repository root: + +```sh +python3 research/cover-local-reuse/verify.py +``` + +The verifier checks the closed frozen source inventory and copies it to a +temporary repository-shaped tree. It reconstructs the deterministic +restriction from the original DAG, rebuilds the complete local compiler and +reuse pairs, independently replays literal reflection and dirty cleanup, +recounts scalar work, regenerates finite and padded geometry, checks the +weighted bit ledger and verifies exact assembly. Generated JSON profiles +and receipts must reproduce byte for byte. The restricted compressed DAG +is checked against the exactly reconstructed record; its frozen bytes are +also source-hashed. Verification requires an unchanged source snapshot. + +The finite geometry audit checks every subspace and ordered pair through +dimension four, including degenerate cases, and all 1,540 actual ports. +The separate padded audit checks every physical source frame in all three +stage orientations, completed residuals and both data-bank endings. + +The 37 package controls reject omitted dependencies, changed original or +restricted DAGs, unsupported coordinate restrictions, wrong root supports, +omitted reuse roles or paid children, missing compensation/reflection +claims, changed source bindings, insufficient scalar reserves, formatting +drift and optimized Python. They also verify every local copy, both data +finishes, the auxiliary adapter charge, weighted fallback and atom +conversion. The local replay retains its literal-word, frame and +compensation corruption controls. Exact assembly checks 47 strict +constraints, seven positive margins and rejection of the next complex and +kappa grid points; no true-root optimum is claimed. + +`certificate.py` checks its frozen record by default. `--write` and +`verify.py --freeze-manifest` are explicit authoring operations; they are +never performed by the verifier. + +This remains a conditional finite witness. General Clifford normal forms, +the common generic basis, uniform weighted local-ring compilation, affine +batching, restored internal rows, prime selection, analytic estimates, +streaming, recovery and fixed-tape transfer remain explicit inherited proof +contracts. Finite checks do not establish those all-size contracts or a +practical speedup. [NOTICE](NOTICE) preserves attribution and the source +manifest pins all adopted proof sources and original notices. diff --git a/research/cover-local-reuse/SOURCE.json b/research/cover-local-reuse/SOURCE.json new file mode 100644 index 0000000000..457b1cf9c1 --- /dev/null +++ b/research/cover-local-reuse/SOURCE.json @@ -0,0 +1,104 @@ +{ + "files": { + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "NOTICE": "e891051aa7858815850030c9531a88794ba0f39436fbd03cc0f2607a76da8b74", + "certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf", + "certificates/partial-gauge-bit-input.json": "367b9844db23f8fa64002637903bcc5ce28ffc8879d274b5c54c0390fb0234e4", + "certificates/partial-gauge-network.json": "e2e6c48bc283b1417c13adaa35c36d782191e21a33f7279a4ed1558ca60518be", + "certificates/stopped-product-network.json": "43ddb7ee033d316375102cf2d97bb2cf47f879f36a005d3726fa6647a2cbecc5", + "certificates/three-stage-cover-bit-input.json": "d0d496b64d45408d6e0773ebbcd4d5dcca918a596073a51e5fc186b82c3b8520", + "certificates/three-stage-cover-complex-input.json": "afecf8ce2d8eb259074e61cd0c386b464ca2f57c61b00979eac808fa26e0b770", + "certificates/three-stage-cover-input.json": "633e108352d3a880c3dc05e265f40270698ea7ebbe655706f5f8675070c86bd2", + "certificates/three-stage-cover-network.json": "bfca1f225394c8b50f3360b71920652baf9bd885ce84f9c0a9184c3ba7dd35ab", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/three-stage-cover-assembly.tex": "ccf34a6d37c4af14bebeab15be50ab204eb1caebe546385520050ec30089441d", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-complex.tex": "1c5b638aa9b75365b8addec9c8eeee6bc5e499722901079b94c65fce033fde8a", + "notes/three-stage-cover-note.tex": "db8078687825bcd43c6cc2fb69712ebb12840057b77cd5af8f67f53e4ffffa92", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/partial-gauge/pr97/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "references/partial-gauge/pr97/NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f", + "references/partial-gauge/pr97/PROOF.md": "f2c95747d9a5858da43932d857be999e6166d4740f25e2c57f99ce05a8902352", + "references/partial-gauge/pr97/SOURCE.json": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "references/partial-gauge/pr97/bit-ledger-result.json": "c3dd79e5e6d72e49d8d1be2d4d9ad808cd7d24b7a725190d24100cbd3644394a", + "references/partial-gauge/pr97/check_frames.py": "1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8", + "references/partial-gauge/pr97/check_lifted.py": "c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c", + "references/partial-gauge/pr97/deferred-readout.tex": "4e848f7f06c975045629da7cca9f79e10f255d08dc17a72629c9bed522565d52", + "references/partial-gauge/pr97/deferred.py": "9b2acaeb6f1beb2a53c15e00c027f9ba22397a12071ad0b71131e12012a98036", + "references/partial-gauge/pr97/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c", + "references/partial-gauge/pr97/linalg.py": "56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b", + "references/partial-gauge/pr97/round7_literal_frame_ledger.py": "02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59", + "references/partial-gauge/pr97/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588", + "references/three-stage-cover/pr117/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "references/three-stage-cover/pr117/NOTICE": "a0030510cd3b5334fb113eae759aadd2c25951bd353dfb69ad9cb780ae5adf30", + "references/three-stage-cover/pr117/SOURCE.json": "74e9f4b4ae0529d21d19c159b2b50ee0923e93e0d7eb22cf208ad41dd5992275", + "references/three-stage-cover/pr117/dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "references/three-stage-cover/pr117/replayed.py": "99c1e3694ae06a7ce7a370b04ecb45ea3fcfe69a6e6e7f4c4606e0a6c74c3184", + "research/cover-local-reuse/BIT-PADDED.md": "f5c2747c0d3eab684012e754b087a2f751d48cc10f0fa9d6e8680f13f8254aa0", + "research/cover-local-reuse/NOTICE": "08f5618929903f32920875bea27f661b83de08bc19c2bce33405ab18808ede79", + "research/cover-local-reuse/PADDED-GEOMETRY.md": "8b7a2f4ca5a78069d95712d61836a421fccabca224c8d3396f487706f5531060", + "research/cover-local-reuse/README.md": "dd1f108a25f80988b7f40160a6672149f93026d737232e8f388603f7b9a45a46", + "research/cover-local-reuse/bit-padded.json": "f688f42ba37754074591a9d2a6b511189815725197a4f17fd0132b2b3ab89cc2", + "research/cover-local-reuse/bit_padded.py": "eabc6a81dcc7153070b30c31e3d143e423da6b543a018f369dcb6c2da77f8ae7", + "research/cover-local-reuse/certificate.json": "51cb4695a0e7903b58a305944b9612d99b1f8c7e8730380ed36f67bac5b68c9c", + "research/cover-local-reuse/certificate.py": "47570809f29686bac55aedc1b8f6def1dc3b97755a96ee5749571edafe2c30c4", + "research/cover-local-reuse/geometry-audit.json": "857f83b4b4404cfeec1cd256c7b757468eb2d4fff59df557c16e7203040eb27c", + "research/cover-local-reuse/geometry_checks.py": "4eed4da876a2cd4557c6ed833512eb28363497f308fe4747892f412b6ee546f5", + "research/cover-local-reuse/padded-geometry.json": "cefee111283998ca68e349dd6c0d1092950e7745e098e4f62c0263fcec9e0a9a", + "research/cover-local-reuse/padded_checks.py": "d39f4f36f3940138b748aaaf2b3dc158a3c20384f8141f80b55190a2e581fd63", + "research/cover-local-reuse/test_controls.py": "02e76e505e590df3364b586c444f5c21eab25f72cfb1ea79e8bf9604bbd07874", + "research/cover-local-reuse/verify.py": "23ffb0400143c3f88a24ce703ec58f3672a4931a71ecc33ab727ee8402d70f92", + "research/cyclic-deferred/arbitrary_frames.py": "2dcd2282f17fc36ff810c46928374d69a5501ed6f11c8f4ec9972395789a16b2", + "research/cyclic-deferred/complex-profile.json": "ca5e0293ac87d7cb0ad951fe9332bdfde7cb8cadae25a2ec0293aa7bbaddb0de", + "research/cyclic-deferred/complex_deferred.py": "1cc7b84843cd7480e36047e4683c8b10dd2800f42a31b1b5566a0f1f33d913d1", + "research/cyclic-deferred/gauge_frames.py": "8f9f4a5b1a7a5f8a72cb3a030e4d5c7fd1c529db44e6d236620d0347099f7e7c", + "research/cyclic-deferred/gauge_padded_frames.py": "f714804eea119accdcc1b16e529a81ed5ef442db7152bd44c6dd7111ddc2b1df", + "research/cyclic-deferred/inputs/complex-dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "research/cyclic-deferred/inputs/restricted-dag.json.gz": "2647e6a0e5beafd651feddcab1a210da87d131fe578ccb792aee00b2cd056adb", + "research/cyclic-deferred/producer.py": "011d906592559c38fb90e82cdca01559337314273310694c8878fc4f8e86319c", + "research/cyclic-deferred/reflection-audit.json": "e784187bd4d0c6a6172ddbb519b142d5bf427cb3949f040426be082b49dd75dc", + "research/cyclic-deferred/reflection_audit.py": "3046c283c78a3e9ec961dbce48a428edf46bf1ba4864a222fef02adef480ed3c", + "research/cyclic-deferred/replayed_producer.py": "9476ec4046c34accc2b92c139a8ef07cb863076966bcb05d8f3a8182e8d5d006", + "research/cyclic-deferred/restrict_dag.py": "a7f880d6abb49ae74c1ad633cf4a265c8fb69489eb908af75c321d117a7a3f84", + "research/cyclic-deferred/restriction-audit.json": "dc6fee76f81133da2e8e27a333113abbb9d62037ff3f6472c94562bc1d881eb0", + "research/cyclic-deferred/reuse-pairs.json": "78285c2d8c831490da5b01b7cdf90c5f82ade29379a2ea7cbb76eed157e35bdc", + "research/cyclic-deferred/reuse.py": "46261c65659cd5f2c8a0626d2aba25716bef81f2c4db8420a589e370400b9c11", + "scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "scripts/exclusion_circuit.py": "b253f9d7318becda1c1f3b24e2287ed44a9c27fcea00cf9d531afb950d0457a0", + "scripts/fast_gaussian.py": "11430c2df0783b933dc91080595bb7514bb052b8c7b12107e27a1ef701e31e43", + "scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "scripts/partial_gauge/binary.py": "b29e2f37d7f32a959a378190d7f1da3c2da534fbdaf878044800301957bffc03", + "scripts/partial_gauge/lift.py": "895874399113faa090d168d6168f0664136df6e21205671e7f7f9239cad93d1d", + "scripts/partial_gauge/match.cpp": "12b8b7c93bb78324e7328e624b166be2067ae8861540531c024040220d86f368", + "scripts/partial_gauge/word.py": "96015b7b08a261673ab8be1ea47f89302f8a1d62a822d657a09f6a1fcfb51e58", + "scripts/partial_gauge_bit.py": "7d58e86061da2d73991531e9bc431589019359391adea866c61c7dd1f99ac855", + "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782", + "scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "scripts/shared_point_circuit.py": "c9bb7a5df92d260a4e3ad532b53e26936730d7c93f7facfb0784957c1e81c8ba", + "scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d", + "scripts/three_stage_cover/README.md": "b39a28fa8da5d7d3188dfed4c0e0af1e2397f0f5c8f69cfb69671ed27ddca4bb", + "scripts/three_stage_cover/__init__.py": "b964b59af038e70cc15af655a22bcf6aaafc9c842b213765781bc8bea7166430", + "scripts/three_stage_cover/lift.py": "ae5f4c56cd32b5232d6dcdcaed1e24efb81fe20467a2d915ee51479bced06cfc", + "scripts/three_stage_cover/select.py": "457e636ced9bbd368198f78e015660a929ba1aaccbe34122d18da09ebb488f33", + "scripts/three_stage_cover/verify.py": "4bd2347e87e4edb699968bc31dfb94f2ab89bf1227576e59f43c779ba74e4e06", + "scripts/three_stage_cover_network.py": "7e0ad6fd1921b6905a53ce1eeaa03d3bb3a8a8bbaa0382516ea98b636f46335e", + "scripts/three_stage_cover_producer.py": "ea6dd4f06173304bbcb74b8e5bcc02357b7bb162a6d26b4a6f7a9e886158123f" + }, + "provenance": { + "cover_certificate_sha256": "bfca1f225394c8b50f3360b71920652baf9bd885ce84f9c0a9184c3ba7dd35ab", + "cover_commit": "6a9970a530119174507904e23592fd59ede19a5d", + "physical_local_source": "PR129 physical-frame/reuse method on the deterministic h22 restriction, extended by PR130 arbitrary-subspace Clifford frames; PR124 compensated birth-cut reuse", + "scalar_dag_commit": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "scalar_dag_restriction": "Retain the first 22 coordinates of the pinned h24 witness, regenerate its restricted output supports and deterministic physical producer; no alternate searched DAG is substituted.", + "scalar_dag_sha256": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b" + }, + "schema": 1, + "scope": "Deterministic restriction to the first 22 coordinates of the immutable PR117 DAG, finite local frame/gauge replay, padded complex/bit geometry and exact paid cover assembly; general cover/bit/analytic interfaces remain conditional." +} diff --git a/research/cover-local-reuse/bit-padded.json b/research/cover-local-reuse/bit-padded.json new file mode 100644 index 0000000000..902bf81dfa --- /dev/null +++ b/research/cover-local-reuse/bit-padded.json @@ -0,0 +1,156 @@ +{ + "R": 28866, + "added_bad_moment_upper": "52017238686022731608034300497691661649423559/13461756527311735502833306002989189693440000000000000000", + "atom_exponent": "1/1000", + "bad_fraction": "1/10000000000000000", + "checker_sha256": "eabc6a81dcc7153070b30c31e3d143e423da6b543a018f369dcb6c2da77f8ae7", + "coarse_saving": "22550837/50000000000", + "coset_conditioning_factor": 3, + "data_finish_child_multiplicities": { + "2": 10626 + }, + "edge_count_per_cell": 1698207, + "effective_saving": "11265104579/25000000000000", + "exact_role_stock": "(|GL_69(F_q)|/3)*(6v+3R)*q^(69^2*(w-1))", + "exterior_child_multiplicities": { + "12": 492, + "15": 12, + "18": 273, + "21": 15, + "24": 957, + "27": 108, + "3": 462, + "30": 348, + "33": 84, + "36": 1005, + "39": 288, + "42": 273, + "45": 90, + "48": 1341, + "51": 531, + "54": 2418, + "57": 11613, + "6": 147, + "60": 3921, + "63": 4788, + "66": 5280, + "9": 249 + }, + "fallback_children_per_edge": 152352, + "fresh_group_roles_independent_of_inherited_weights": true, + "full_local_ring_fallback_charged": true, + "geometry": { + "actual_h23_ports_checked": 1771, + "all_three_stages_paired_in_independent_cosets": true, + "common_diagonal_weight_conjugation": true, + "completed_reverse_residual_is_forward_inverse": true, + "high_matrix_batching_unchanged": true, + "local_low_residue_coset_representative_unique": true, + "negative_controls": [ + "omitted-third-completed-residual", + "omitted-nonzero-gauge-tail" + ], + "order_three_free_right_action": true, + "padded_ambient": 69, + "passive_dimensions": 2, + "rational_three_block_chart_invertible": true, + "right_coset_reason": "g*tau^j=g implies tau^j=I; reduction modulo odd q>2^80 retains exact order3, so each residue orbit has three members. Each full orbit has exactly one lift over its chosen residue representative, with all69^2 high coordinates free.", + "weighted_combined_exterior_split_rank": "69-3*nullity=3*source_dimension", + "weighted_offset_identity_checks": 27, + "zero_width_tails_omitted": true + }, + "good_moment_upper": "2972355841213160794011961012307515301173693/2972355841230431199025593965460013084311552", + "h": 23, + "halving_degree": 16, + "ideal_child_multiplicities": { + "1": 600615, + "10": 2232, + "11": 3528, + "12": 3237, + "13": 2403, + "14": 576, + "15": 6240, + "16": 3834, + "17": 12123, + "18": 5736, + "19": 18720, + "2": 616101, + "20": 20790, + "21": 3741, + "22": 225, + "24": 957, + "27": 108, + "3": 136092, + "30": 348, + "33": 84, + "36": 1005, + "39": 288, + "4": 119349, + "42": 273, + "45": 90, + "48": 1341, + "5": 60048, + "51": 531, + "54": 2418, + "57": 11613, + "6": 18975, + "60": 3921, + "63": 4788, + "66": 5280, + "7": 10431, + "8": 14625, + "9": 5541 + }, + "ideal_deficit": 6072, + "ideal_rank_mass_per_cell": 6702384, + "internal_borrowed_row_stock": "O(w log e), restored at the outer boundary; depth16*ceil(log2(n))+O(1)", + "local_child_multiplicities": { + "1": 66735, + "10": 248, + "11": 392, + "12": 305, + "13": 267, + "14": 64, + "15": 692, + "16": 426, + "17": 1347, + "18": 607, + "19": 2080, + "2": 67275, + "20": 2310, + "21": 414, + "22": 25, + "3": 15070, + "4": 13261, + "5": 6672, + "6": 2092, + "7": 1159, + "8": 1625, + "9": 588 + }, + "local_copies_per_cell": 9, + "m": 69, + "maxchild": 66, + "next_grid_enclosure_rejected": true, + "ordinary_leaf_saving": "384599/10000000000", + "prime_bad_bound": "985527/604462909807314587353088", + "rank_mass_upper_per_cell": "2094495000008085163527/312500000000000", + "roles_per_cell": 97224, + "scope": "Retained source-bound PR97 reconstruction, exact padded geometry and completed weighted identities, full paid fallback moment and atom conversion. Generic-basis weighted compiler, uniform affine batching, ordinary leaf, borrowed-row restoration and analytic/tape hypotheses remain the explicit retained proof contracts.", + "source_sha256": { + "certificates/partial-gauge-bit-input.json": "367b9844db23f8fa64002637903bcc5ce28ffc8879d274b5c54c0390fb0234e4", + "certificates/three-stage-cover-bit-input.json": "d0d496b64d45408d6e0773ebbcd4d5dcca918a596073a51e5fc186b82c3b8520", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-note.tex": "db8078687825bcd43c6cc2fb69712ebb12840057b77cd5af8f67f53e4ffffa92", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/partial-gauge/pr97/SOURCE.json": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "research/cover-local-reuse/BIT-PADDED.md": "f5c2747c0d3eab684012e754b087a2f751d48cc10f0fa9d6e8680f13f8254aa0" + }, + "stages": 3, + "status": "Exact paid padded triple-sharing bit moment under retained weighted contracts", + "strict_gap": "1807812097424729379201190496240212846189774429/928861200384509749695498114206254088847360000000000000000", + "v": 1771, + "vertices_per_cell": 3, + "weighted_projector_good_class_compiler_retained": true, + "zero_width_exteriors_omitted": 51903 +} diff --git a/research/cover-local-reuse/bit_padded.py b/research/cover-local-reuse/bit_padded.py new file mode 100644 index 0000000000..bf920cf821 --- /dev/null +++ b/research/cover-local-reuse/bit_padded.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +"""Paid padded69D triple sharing for the retained weighted PR130 bit word. + +PR130 geometry/weighted recursion: icekylinx with OpenAI GPT-6 Astra. +Retained PR97 local word: Zhihao Chen and Swapnil Jain. This extension +prepared for eumemic with OpenAI Codex assistance. Apache-2.0. +""" +import argparse,json,sys +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import combinations +from pathlib import Path +if sys.flags.optimize:raise ValueError('Assertions must remain enabled') +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1];sys.path.insert(0,str(ROOT/'scripts')) +from partial_gauge_bit import reconstruct +from three_stage_cover_network import log_upper,exp_upper +from structured_bulk_assembly import js,halving +BAD=Q(1,10**16);ATOM=Q(1,1000);OLD=Q(384599,10**10);GRID=10**12 +INPUT='certificates/three-stage-cover-bit-input.json' +INHERITED_NOTES=('notes/three-stage-cover-bit.tex','notes/three-stage-cover-rows.tex','notes/three-stage-cover-note.tex') + + +def matmul(A,B): + n=len(B);C=[] + for row in A: + out=[Q(0)]*len(B[0]) + for k,a in enumerate(row): + if a: + for j,b in enumerate(B[k]): + if b:out[j]+=a*b + C.append(out) + return C + +def eye(n):return [[Q(i==j)for j in range(n)]for i in range(n)] +def inverse(A): + n=len(A);B=[row[:]+e for row,e in zip(A,eye(n))] + for i in range(n): + j=next(j for j in range(i,n)if B[j][i]);B[i],B[j]=B[j],B[i];a=B[i][i];B[i]=[x/a for x in B[i]] + for j in range(n): + if j!=i and B[j][i]: + a=B[j][i];B[j]=[x-a*y for x,y in zip(B[j],B[i])] + assert [row[:n]for row in B]==eye(n) + return [row[n:]for row in B] +def add(A,B,sign=1):return [[a+sign*b for a,b in zip(x,y)]for x,y in zip(A,B)] +def block_swap(P): + # Reversed tail coordinates put D_P in ordinary aligned bank coordinates. + n=len(P);I=eye(n);Z=add(I,P,-1) + return [Z[i]+P[i]for i in range(n)]+[P[i]+Z[i]for i in range(n)] + + +def geometry(): + h=23;m=69;old=67;I=eye(h);q0=[Q(i<3)for i in range(h)] + H=[[Q(int(i==j),2)-Q(1,18)for j in range(h)]for i in range(h)] + cov=[sum(H[i][j]*q0[j]for j in range(h))for i in range(h)] + assert sum(x*y for x,y in zip(cov,q0))==1 + K=[[Q(i==j)-cov[j]*q0[i]for j in range(1,h)]for i in range(h)] + B=[[q0[i]]+K[i]for i in range(h)];Bi=inverse(B) + assert matmul(B,Bi)==I + assert all(sum(cov[i]*K[i][j]for i in range(h))==0 for j in range(h-1)) + # In the rational basis (q0,K), (D1,B22), (D2,C22), tau is a + # permutation cycling three23D blocks. The change of basis is invertible; + # its first block is the actual A23 and remaining blocks are in A-perp. + tau=tuple((i+h)%m for i in range(m)) + assert all(tau[tau[tau[i]]]==i and tau[i]!=i and tau[tau[i]]!=i for i in range(m)) + assert set(tau[:h]).isdisjoint(range(h)) and set(tau[tau[i]]for i in range(h)).isdisjoint(set(range(h))|set(tau[:h])) + ports=0 + for T in combinations(range(h),3): + t=[int(i in T)for i in range(h)];c=[Q(3*x-1,6)for x in t] + assert sum(x*y for x,y in zip(t,c))==1 + # P=t*c is the exact retained rank-one projector. P^2=P suffices + # for diag(I,0,0),diag(P,I22,0),diag(P,0,I22) to have pairwise + # product P and sum I67+2P. The two added coordinates are zero. + assert any(t)and any(c);ports+=1 + assert ports==1771 + # An exact weighted nonsymmetric example exercises the universal identities. + # Arbitrary fixed split projectors follow by similarity; arbitrary diagonal + # units A are a common conjugation and cancel in every displayed product. + n=6;G=eye(n) + for i in range(n-1):G[i][i+1]=Q(i+2,7) + Gi=inverse(G);Is=eye(2*n) + def projector(indices): + E=[[Q(i==j and i in indices)for j in range(n)]for i in range(n)] + return matmul(matmul(G,E),Gi) + weights=[Q(i+2,i+3)for i in range(n)]+[Q(1)]*n + def weighted(P): + D=block_swap(P) + return [[weights[i]*D[i][j]/weights[j]for j in range(2*n)]for i in range(2*n)] + F=weighted(eye(n));checks=0 + for d in (0,1,2): + residual=[] + for k in range(3): + active=set(range(2*k,2*k+2));sigma=set(range(2*k,2*k+d));outside=set(range(n))-active + FA=weighted(projector(active));TS=weighted(projector(sigma));P=matmul(FA,TS) + for Oset in (set(),set(sorted(outside)[:1]),outside): + FO=weighted(projector(Oset));entry=matmul(FO,TS);finish=matmul(FO,FA) + assert matmul(finish,inverse(entry))==P + revstart=FO;revfinish=matmul(matmul(FO,TS),FA) + assert matmul(revfinish,inverse(revstart))==inverse(P);checks+=1 + residual.append(P) + combined=matmul(residual[2],matmul(residual[1],residual[0])) + sigmaall=set(i for k in range(3)for i in range(2*k,2*k+d));tail=weighted(projector(sigmaall)) + assert matmul(tail,combined)==F + if d==0:assert combined==F and matmul(residual[1],residual[0])!=F + if d:assert combined!=F + # Frobenius/Schur arguments below concern any odd local ring, not only Q. + # The exact rational tests are controls; the displayed projector identities + # are polynomial and hold after any admissible denominator localization. + return dict(actual_h23_ports_checked=ports,padded_ambient=69,passive_dimensions=2, + rational_three_block_chart_invertible=True,order_three_free_right_action=True, + all_three_stages_paired_in_independent_cosets=True,weighted_offset_identity_checks=checks, + common_diagonal_weight_conjugation=True,completed_reverse_residual_is_forward_inverse=True, + weighted_combined_exterior_split_rank='69-3*nullity=3*source_dimension', + local_low_residue_coset_representative_unique=True,high_matrix_batching_unchanged=True, + right_coset_reason='g*tau^j=g implies tau^j=I; reduction modulo odd q>2^80 retains exact order3, so each residue orbit has three members. Each full orbit has exactly one lift over its chosen residue representative, with all69^2 high coordinates free.', + zero_width_tails_omitted=True,negative_controls=['omitted-third-completed-residual','omitted-nonzero-gauge-tail']) + + +def certificate(): + row=json.loads((ROOT/INPUT).read_text());physical=reconstruct() + assert (row['h'],row['v'],row['R'],row['center_loss'])==(23,1771,28866,506) + for k in('v','R','local_rank_histograms','exit_nullity_histogram'):assert row[k]==physical[k],k + geo=geometry();h,v,R=row['h'],row['v'],row['R'];m=3*h;H=Counter();local=Counter() + for hist in row['local_rank_histograms'].values(): + for r,n in hist.items():local[int(r)]+=n;H[int(r)]+=9*n + tails=Counter();zero=0 + for nullity,n in row['exit_nullity_histogram'].items(): + r=m-3*int(nullity);assert 0<=r0;edges=sum(H.values());fallback=32*m*m + logs={r:log_upper(Q(m,r))for r in H};logm=log_upper(Q(m)) + def moment(b): + good=sum(Q(r*n,W*m)*exp_upper(b*logs[r])for r,n in H.items());extra=BAD*Q(fallback*edges,W*m)*exp_upper(b*logm) + return good,extra + low,high=0,10**9 + assert sum(moment(Q(low,GRID)))<1 and sum(moment(Q(high,GRID)))>=1 + while high-low>1: + mid=(low+high)//2 + if sum(moment(Q(mid,GRID)))<1:low=mid + else:high=mid + coarse=Q(low,GRID);effective=(1-ATOM)*coarse+ATOM*OLD;good,extra=moment(coarse);rank_upper=mass+BAD*fallback*edges + assert good+extra<1 and rank_upper=1, 'Next coarse enclosure grid accepted' + assert Q(6*m**3,2**80)effective and ATOM<1-effective + names=[INPUT,*INHERITED_NOTES,'research/cover-local-reuse/BIT-PADDED.md','certificates/partial-gauge-bit-input.json','references/partial-gauge/pr97/SOURCE.json'] + return dict(status='Exact paid padded triple-sharing bit moment under retained weighted contracts',m=m,h=h,v=v,R=R, + vertices_per_cell=3,stages=3,roles_per_cell=W,ideal_rank_mass_per_cell=mass,ideal_deficit=6072,maxchild=max(H),halving_degree=halving(m,max(H)), + local_copies_per_cell=9,local_child_multiplicities=dict(sorted(local.items())),ideal_child_multiplicities=H, + exterior_child_multiplicities=dict(sorted(tails.items())),data_finish_child_multiplicities=dict(padding),zero_width_exteriors_omitted=zero, + coarse_saving=coarse,effective_saving=effective,atom_exponent=ATOM,ordinary_leaf_saving=OLD,bad_fraction=BAD, + fallback_children_per_edge=fallback,edge_count_per_cell=edges,good_moment_upper=good,added_bad_moment_upper=extra,strict_gap=1-good-extra, + rank_mass_upper_per_cell=rank_upper,prime_bad_bound=Q(6*m**3,2**80),coset_conditioning_factor=3,next_grid_enclosure_rejected=True, + geometry=geo,weighted_projector_good_class_compiler_retained=True,full_local_ring_fallback_charged=True, + fresh_group_roles_independent_of_inherited_weights=True,internal_borrowed_row_stock='O(w log e), restored at the outer boundary; depth16*ceil(log2(n))+O(1)', + exact_role_stock='(|GL_69(F_q)|/3)*(6v+3R)*q^(69^2*(w-1))', + source_sha256={name:sha256((ROOT/name).read_bytes()).hexdigest()for name in names},checker_sha256=sha256(Path(__file__).read_bytes()).hexdigest(), + scope='Retained source-bound PR97 reconstruction, exact padded geometry and completed weighted identities, full paid fallback moment and atom conversion. Generic-basis weighted compiler, uniform affine batching, ordinary leaf, borrowed-row restoration and analytic/tape hypotheses remain the explicit retained proof contracts.') + + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args();result=js(certificate());path=HERE/'bit-padded.json';encoded=json.dumps(result,indent=2,sort_keys=True)+'\n' + if a.write:path.write_text(encoded) + else:assert path.read_text()==encoded,'Padded bit certificate mismatch' + print('PASS paddedbit coarse',result['coarse_saving'],'effective',result['effective_saving'],'m69, paid spectators, weighted fallback',flush=True) +if __name__=='__main__':main() diff --git a/research/cover-local-reuse/certificate.json b/research/cover-local-reuse/certificate.json new file mode 100644 index 0000000000..aee5ce53b2 --- /dev/null +++ b/research/cover-local-reuse/certificate.json @@ -0,0 +1,717 @@ +{ + "actual_bit_saving": "11265104579/25000000000000", + "assembly": { + "absorption_gap": "127243612781745947749668167837976624639416354736122542228581/250210252176999999684411477322999790063208765500000210257177000000000000000", + "margins": { + "Gaussian_arithmetic": "1261513062000747265460155938000318111608801000209936791234499999789742823/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "bulk_exposure": "210252176999999999789742823/500000000000000000000000000000", + "compact_phase_layer": "105126088499999684516605911500210567562765499999789742823/250210252176999999684411477322999790063208765500000210257177", + "coordinate_movement": "210252176999999999789742823/500000000000000000000000000000", + "dimension": "249999999999999750000000000000000000000000000000000000000000/250210252176999999684411477322999790063208765500000210257177", + "original_prefix": "105126088500249894768782911499894979040088499789852951588500000210257177/250210252176999999684411477322999790063208765500000210257177000000000000000", + "scalar_work": "1682017416001747265039641583998636094192801000211618848650499999789742823/2001682017415999997475291818583998320505670124000001682057416000000000000000" + }, + "minimum_margin": "105126088499999684516605911500210567562765499999789742823/250210252176999999684411477322999790063208765500000210257177", + "parameters": { + "C0": 70720223835545737505373133262349750143505492300758716843663901380353039913367033841321210074480685057740291975817073789353226583104068526856128566767141556054886185813228573441568508527681684920175242130240762670551792354404176168898258155230321974719865044557650625962667872980715267817943573454659543163181199053648131300432873186969686202343485191335244215908193796029036528649686152346654499593161882805482769290748806265642733841385376259819281217630889048121294874585174160466934660930022388506150838912736037915672721182777947167588796794495513454602042697513365237629297796032465622920322454958677877886847780718199003299920109092283434893570413263598317241675221330753114674340193540982171172204473055292116647738049720048719547642405918148448065595762316436723819282214487314846715835389691853095495450853238232009146501718879700217721141157309762116163863595357710005028446009352919708706414035529882487215992182940300822562791202871553992771021368989743729621358477746715524102832752336547088934439403265585392243499295645535629178746427989341902658983857964803492347952139874181130368870547944566244972936127149584881963489066343800784467360792464341423851079792053448336376275311382639240085028360326634713760211530087143404975425004378369931453929457224398376953722337487259588703806215693715591845233560921257327009606461765307451751335815886176551620248735343946020133274560959442340252995110579372202975075636500848152581135695755103777840095027700975446101934385251595204945390476489499153463487289487265310507327004901027847832041926165637127728214609850015314693943376977974480101047462568424010989526242269079859519284106432059432997736143634933882387356949816330404132626270416974745676975380321970181523663011630471810094260293543659907754420485675163137213940404060140816805132254270183269808942266009044397832257615369969782498704515122549239431461993824838841708662360210716431966844230603642844789297341141035558266076155493602339917607922368758786189823925004010244532486641599049590286528182795016542263613158465967691802997011180638865287322658176047811497396881196426378760351836593699177119485635485116233924353532755217246138216454951582353957325082662298169011306686866038688583785143441957287284087454025371900451702294210811287517016492376666686223331368906285302778771139827324961456370232881645244830963045971400369949320381564221710485438136195042070347782545750532216277110587377219213713856377509557646534930280934620894666564629643185449800967369404499017012867562882516937289140366112619831024721798270324001093237342942377420680819649812395363117383799793217166653447112795953169541479895579100842175520396580207889427454405590277249846248737642266487161827158856139204514989296659303463709400392906364950594524463384524264488617520753056695652081786338245112694830782423490518274666531213097970966958943005039026032671767714672101725832664788783939419544545737273575180780757338911224036502252385442600730035129655773240465427964171641759716022667953646060179100762028505950542815140841896583113848118369060118600160180718449728206322167613407031890256809049933253018051017074511297981467827272059799437055951757620041578873023446374438743120322037767734210481569704211707183069561467737650620145525721364416084305044813330368757061231385412511963186450355704665041448605227643471004173589908713605908317019941674621282496443662421243868715483214861785716184330802228909229777051572748623023897894550722149330664929270226657747423777933142884886437755931053509748214046017101851032819280079454943336961243251626913030392731364196230533313732685296282406474573379383132285124377318856415014306674709724280467968006807572093394410375340390367323414646648973675405999796185786223150548103052908011748558943801819861197588708152485345986119228968554855317712503132330088541933342887421093007817019976339886268614794025327817223300909721694601681023727133640878198173780026472069721987748510499277003723090300784715937983080134887673740226891794837740385291109728071631854132560008601730254560322521302780377742625078092103118407609117999304635177994793671432734898112200755080198715297404607460743278780091147125425966440986925507472673753834459244687573214524376683321765744575899174414965751160590836608664352375322491428670652002096482319126771030426783492242179262539117963885051049635549360161843827087291081043015102575817854860442347800159557398541033090402540921711329305366132610190613321110799023609526400258754109016876593482204945216363661917656051946225123951765364739410326965814912764230042486478033599212853357804218042720815515389756244644842732270572616258479139134395568456701850759883603229503185043142954259630905570387379996075831113679828741257545903302873373548137237744703832807900497781015005786535527143658660380570346991337853268107848185024490583883984375360102562154360804045080991698244201895891480841775968667717270244186352829841081916227702117155456271663408955004048798225360247224456727019863138288717173260330907005485872022062988950035512445242457784846522862867336148869933401391430120016459599847219438270065234955893537065864228397593454444625973529708402830978149898319134735699659337654405479898846260482730541115384242726565643479637694627683308573683276681444394007792459439164003008167906091733864632954904387497037582510624573309706544453743134522574156201557173675810912656731448806602052330618460894891017051055543056848708644491021228117390310520516760433266659042353135379084746079557527661940200914988916352326358430322475181793173461644057146526789394605911841556435305858309645607721757647672256031134223907608126153057737511403800752874842531912294550363162556863764237625186055328680221787060617044329412438467919752931849716633994601091641317364989594837191898421825088784449756557668281680578712469091978593572055650981665903327036505672755041357650451276810032004679450951228344630802004938082517448938845423654651343144576088900348747288577036778517606246543241711031009876792033052209367011834442150276131808153274561801746659283371694961392189582019101180027670836874254542897609301973485834630097044725981287432634428563287198283490862642529216048896847362138999622463451528168133782160024123331019380753671336879467483650443566138091907302527711185971784224200903049353635608557190922518685817951308511413891440739128761450804995234706269603490544704122380665476185963830651143377311951713064336891911868930170403782717746853028152449351331421746074039850722304876860933296267317570100150928640816974683458128092443739236331830866892784508854705056730742321220395089901226014280810349026425292631759178654506917332916809868873057919153023904758361000055092663221956906626210342091167781743391521263418034005372099484043276486299673581711936629489492165403140948189592036132359190174239310450698629809534458438297368153445519473114547844962169665738688646342386995389774592273725182300079952400775600456601265795903201040217630873963675670288001731216030203900333464144417395380677038106601327346969503879476766026464462811877042571370982235110255819122122930573889116499307624041628380449679910055973874741465047973913271676390853990156107032326645599568111882748340370255804283473156400649699055535944874330934243355354348830198258535393002911765897881194005838642861221321076402164058865252249437848694964235606986128331122189560466897527905994187030070636293420440983542314120892661713743627750684705284181633474305601264646692719104072794226028612917310940430501138577883977469641228906666941938209641786833856135192395388897834059566372520956072643707819326746040355911607277193404253874468799779677252496357327601018494915957971093852972722694714912371515248092948866828945915197737223026881891604580506615056951440433335062736783418156054711122486616595114539410244317617534826337830931804104937404175453296748448972800782533030465241088, + "C1": 1, + "a_bit": "210252176999999999789742823/500000000000000000000000000000", + "a_complex": "210252177/500000000000", + "alpha_squared_power": "157689132750124684464041617250000315385765500000000000000/250210252176999999684411477322999790063208765500000210257177", + "beta": "1/1000000000000000000", + "c": "105126088499999894768782911499789852951588500000210257177/250000000000000000000000000000000000000000000000000000000000", + "delta": "1/8000000000000000", + "epsilon": "249999999999999750000000000000000000000000000000000000000000/250210252176999999684411477322999790063208765500000210257177", + "eta": "1/1000000000000000", + "kappa": "420151003347/1000000000000000", + "lambda_": "499789747823000000210462434176999999789742823/500000000000000000000000000000000000000000000", + "lambda_prime": "249894873911500000210357305588499999789742823/250000000000000000000000000000000000000000000", + "q": "105126088499999789642694411500000210257177/250000000000000000000000000000000000000000000", + "sigma": "499789747823/500000000000", + "tau": "499789747823000000000210257177/500000000000000000000000000000" + }, + "recurrence": { + "internal": "499789747823000000000210257177/500000000000000000000000000000", + "leaf": "499789747823000000000210252177/500000000000000000000000000000", + "reservations": "249894873911500000105231217088500210147048411499999789742823/250000000000000000000000000000000000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "420504354001767738229562613580630916449380813208734179488388980127571471/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "K_dominates_log": "105126088499999789642694411499895084168677000210357305588499999789742823/250210252176999999684411477322999790063208765500000210257177000000000000000", + "K_geometry": "105126088500249894768782911499894979040088499789852951588500000210257177/250210252176999999684411477322999790063208765500000210257177000000000000000", + "alpha_below_one": "250052563044249874999947435705749789747823000000000210257177/250210252176999999684411477322999790063208765500000210257177", + "alpha_below_one_fourth": "249579495645999500946555310853999788801665703500000210257177/1000841008707999998737645909291999160252835062000000841028708", + "alpha_positive": "157689132750124684464041617250000315385765500000000000000/250210252176999999684411477322999790063208765500000210257177", + "artificial_boundary": "14013876643682002729591661857317985197616467669000225075307978499999789742823/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "beta_positive": "1/1000000000000000000", + "bit_positive": "210252176999999999789742823/500000000000000000000000000000", + "bulk_exposure_above_kappa": "176675326499999789742823/500000000000000000000000000000", + "c_below_one": "249894873911500000105231217088500210147048411499999789742823/250000000000000000000000000000000000000000000000000000000000", + "c_positive": "105126088499999894768782911499789852951588500000210257177/250000000000000000000000000000000000000000000000000000000000", + "cell_above_band": "249947436955749625000052564294250210252176999999999789742823/500420504353999999368822954645999580126417531000000420514354", + "compact_leaf": "210252179499999999789742823/250000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "127243612781745947749668167837976624639416354736122542228581/250210252176999999684411477322999790063208765500000210257177000000000000000", + "compact_reservations": "105126088499999789642694411500000210257177/250000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "210257177/500000000000000000000000000000", + "complex_below_one_over32": "15414747823/500000000000", + "coordinate_movement_above_kappa": "176675326499999789742823/500000000000000000000000000000", + "delta_below_one_eighth": "999999999999999/8000000000000000", + "delta_positive": "1/8000000000000000", + "dimension_above_kappa": "249894873911499877559096175834447539100605072476624849673531736122542228581/250210252176999999684411477322999790063208765500000210257177000000000000000", + "epsilon_below_one": "210252177000249684411477322999790063208765500000210257177/250210252176999999684411477322999790063208765500000210257177", + "epsilon_positive": "249999999999999750000000000000000000000000000000000000000000/250210252176999999684411477322999790063208765500000210257177", + "gamma_sublinear": "52563044250124999947435705749789747823000000000210257177/250210252176999999684411477322999790063208765500000210257177", + "guard_width": "210252177000249684411477322999790063208765500000210257177/250210252176999999684411477322999790063208765500000210257177", + "lambda_above_internal": "210252176999999999789742823/500000000000000000000000000000000000000000000", + "lambda_above_sigma": "210462434176999999789742823/500000000000000000000000000000000000000000000", + "lambda_above_tau": "210252176999999999789742823/500000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "210252176999999999789742823/500000000000000000000000000000000000000000000", + "lambda_prime_below_one": "105126088499999789642694411500000210257177/250000000000000000000000000000000000000000000", + "leaf_saving_above_bit": "1/100000000000000000000000000", + "literal_scalar_guard": "182988946298917038970316151084026714904711951924686064258188228593365705232580520942565756494444295075470362502368892221182501451163158738757900224614210622547849278888255917888622050003086006841735680260811293901484265683438912539820411719060024086059008913823410162430329447016604753501675357437550487696674043856483775654703645574721689117877788972777860120045347268017489890829372657876047372618706578014435192016185671103951650268522964784125466613624441275312248984649153687986087993488841059671129695746786134419401909757101992030261425332549053960309027373800995221507570695892035066058082333291642471023729423315824380678128227425209593255221617273741913557308856513446209250580426707365625889702559267177920035628129448469203231295629980616728478424798695902366193181568423620385947565394171720119863244367868767365915303642542423420208033195510157005694322195680822188979063245094559288021653922038823687406706147406485453138868866980816149133334901327811892893682521276694595246156580940980351366258930270249030631828902084237823577521688819296032856533671143637307221276832465371576153158456511452092179200224494728298335451542269432733945858220099233639856302230390503044144569871394522121031545992649969581707844162789159410014011138845164149003905109241797112700185066431787899675411127295945711816851211523034840105950184607830319855758135235620136608561505756457911248922157486144619129188850305964591335366517919644770503072469947618517178777389747844949872129979782367010770895550459910706980914698542889505817605583865707477149821963200523022822156185212530733600123920079274156286554372809262948346702091805082241148980910328530061910177318412218829111448891285914965410945911472179626186536749582554414473220179621860439942293638985366473106431940536638499672384779733996847989242355920097045567398655134940721882432452910139557654632374021829143375442651117302907222579201339980727806739547268862863784803104508846843915399189663077629898129990912699482875211273029077274075013561085954738666220988217690010967318467343848278596515607271484555898349556496837503608040054845091983581409426635353316984298474610236351370031766444668237426570438805679580323110758049221567761712131035604349413331252847846819245015194231722691348756824189102435049128957701814053147331511763801249344958681702092113271106250661032703821021184522274861662931044601849174860553744484718369150446574223381850225389824448350579499425356478899836818821105596254429504847393460011277862623548419376529232680183207641958337092128161329134401005303295770254595341860076841420957655311313761322605841304355428678393260427438205531131216784557866737352260836095502543870885649635467265655188974108345917579029415088232115320117474090907371206254289073144561736779655187582007160257677985027955237345709225370418660671268162844135467689287079624245185035365951800222874579645964082855919016779877622402734883403270161588247051858748481037792876085685373676094858786408227028032591276721121543114802444083014358738380216799645587105805680780891519445817729369742581423884985471061857404143844818179059847396476288238641432406304382828322579687999697525588747587339527678732480604469780530315251215814952107940513418062111873322898923596368052912861578460334825124176353409626864529607867897761040124002549000492850809972976571024396533780093164145491392025345804733739083583038197256188872403569598782361552640455422039426323768841879668822989226837857899197072925360141492442274891806730500814731903945967926458474507988214598451081442213028980106297476719136833173387773872540844861390297793591021329879129094360354170488575036197187498599529068110259123901496895362402102658660685507907154343357261649771508969210832948252583946447741724844198885757919611259916520733663865548759248231384892015433031864229162658828856427142492490294501805045552741587125313923459250866570619726107258617425107925669334000599040000000000019246716", + "original_prefix_above_kappa": "188726932479372973717039822580488207351312560118061376242879/125105126088499999842205738661499895031604382750000105128588500000000000000", + "phase_boundary": "1261513062000747265460155938000318111608801000209936791234499999789742823/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "phase_local": "1682017416001747265039641583998636094192801000211618848650499999789742823/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "prime_interval_packing": "210252177000249684411477322999790063208765500000210257177/250210252176999999684411477322999790063208765500000210257177", + "q_below_internal": "210252176999999999789742823/250000000000000000000000000000000000000000000", + "q_below_leaf": "210252179499999999789742823/250000000000000000000000000000000000000000000", + "q_below_reservations": "105126088499999789642694411500000210257177/250000000000000000000000000000000000000000000000000000000000", + "q_positive": "105126088499999789642694411500000210257177/250000000000000000000000000000000000000000000", + "record_suffix": "210252177000249684411477322999790063208765500000210257177/250210252176999999684411477322999790063208765500000210257177", + "row_product_gap": "2600509/25", + "scalar_work_above_kappa": "841008708002767737809048259578948899033380813210416236904388980127571471/2001682017415999997475291818583998320505670124000001682057416000000000000000", + "short_record_fallback": "124947392749771941760789961675208247286231312637576475915323253732471356037708080480009329/125105126088499999842205738661499895031604382750000105128588500000000000000000000000000000", + "small_field_exposure": "105126088500249999894871411499579495646000000000420514354/250210252176999999684411477322999790063208765500000210257177" + } + }, + "assembly_bit_saving": "210252176999999999789742823/500000000000000000000000000000", + "bit": { + "R": 28866, + "added_bad_moment_upper": "52017238686022731608034300497691661649423559/13461756527311735502833306002989189693440000000000000000", + "atom_exponent": "1/1000", + "bad_fraction": "1/10000000000000000", + "checker_sha256": "eabc6a81dcc7153070b30c31e3d143e423da6b543a018f369dcb6c2da77f8ae7", + "coarse_saving": "22550837/50000000000", + "coset_conditioning_factor": 3, + "data_finish_child_multiplicities": { + "2": 10626 + }, + "edge_count_per_cell": 1698207, + "effective_saving": "11265104579/25000000000000", + "exact_role_stock": "(|GL_69(F_q)|/3)*(6v+3R)*q^(69^2*(w-1))", + "exterior_child_multiplicities": { + "12": 492, + "15": 12, + "18": 273, + "21": 15, + "24": 957, + "27": 108, + "3": 462, + "30": 348, + "33": 84, + "36": 1005, + "39": 288, + "42": 273, + "45": 90, + "48": 1341, + "51": 531, + "54": 2418, + "57": 11613, + "6": 147, + "60": 3921, + "63": 4788, + "66": 5280, + "9": 249 + }, + "fallback_children_per_edge": 152352, + "fresh_group_roles_independent_of_inherited_weights": true, + "full_local_ring_fallback_charged": true, + "geometry": { + "actual_h23_ports_checked": 1771, + "all_three_stages_paired_in_independent_cosets": true, + "common_diagonal_weight_conjugation": true, + "completed_reverse_residual_is_forward_inverse": true, + "high_matrix_batching_unchanged": true, + "local_low_residue_coset_representative_unique": true, + "negative_controls": [ + "omitted-third-completed-residual", + "omitted-nonzero-gauge-tail" + ], + "order_three_free_right_action": true, + "padded_ambient": 69, + "passive_dimensions": 2, + "rational_three_block_chart_invertible": true, + "right_coset_reason": "g*tau^j=g implies tau^j=I; reduction modulo odd q>2^80 retains exact order3, so each residue orbit has three members. Each full orbit has exactly one lift over its chosen residue representative, with all69^2 high coordinates free.", + "weighted_combined_exterior_split_rank": "69-3*nullity=3*source_dimension", + "weighted_offset_identity_checks": 27, + "zero_width_tails_omitted": true + }, + "good_moment_upper": "2972355841213160794011961012307515301173693/2972355841230431199025593965460013084311552", + "h": 23, + "halving_degree": 16, + "ideal_child_multiplicities": { + "1": 600615, + "10": 2232, + "11": 3528, + "12": 3237, + "13": 2403, + "14": 576, + "15": 6240, + "16": 3834, + "17": 12123, + "18": 5736, + "19": 18720, + "2": 616101, + "20": 20790, + "21": 3741, + "22": 225, + "24": 957, + "27": 108, + "3": 136092, + "30": 348, + "33": 84, + "36": 1005, + "39": 288, + "4": 119349, + "42": 273, + "45": 90, + "48": 1341, + "5": 60048, + "51": 531, + "54": 2418, + "57": 11613, + "6": 18975, + "60": 3921, + "63": 4788, + "66": 5280, + "7": 10431, + "8": 14625, + "9": 5541 + }, + "ideal_deficit": 6072, + "ideal_rank_mass_per_cell": 6702384, + "internal_borrowed_row_stock": "O(w log e), restored at the outer boundary; depth16*ceil(log2(n))+O(1)", + "local_child_multiplicities": { + "1": 66735, + "10": 248, + "11": 392, + "12": 305, + "13": 267, + "14": 64, + "15": 692, + "16": 426, + "17": 1347, + "18": 607, + "19": 2080, + "2": 67275, + "20": 2310, + "21": 414, + "22": 25, + "3": 15070, + "4": 13261, + "5": 6672, + "6": 2092, + "7": 1159, + "8": 1625, + "9": 588 + }, + "local_copies_per_cell": 9, + "m": 69, + "maxchild": 66, + "next_grid_enclosure_rejected": true, + "ordinary_leaf_saving": "384599/10000000000", + "prime_bad_bound": "985527/604462909807314587353088", + "rank_mass_upper_per_cell": "2094495000008085163527/312500000000000", + "roles_per_cell": 97224, + "scope": "Retained source-bound PR97 reconstruction, exact padded geometry and completed weighted identities, full paid fallback moment and atom conversion. Generic-basis weighted compiler, uniform affine batching, ordinary leaf, borrowed-row restoration and analytic/tape hypotheses remain the explicit retained proof contracts.", + "source_sha256": { + "certificates/partial-gauge-bit-input.json": "367b9844db23f8fa64002637903bcc5ce28ffc8879d274b5c54c0390fb0234e4", + "certificates/three-stage-cover-bit-input.json": "d0d496b64d45408d6e0773ebbcd4d5dcca918a596073a51e5fc186b82c3b8520", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-note.tex": "db8078687825bcd43c6cc2fb69712ebb12840057b77cd5af8f67f53e4ffffa92", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/partial-gauge/pr97/SOURCE.json": "68fb539abcd6df21d142e4e204b6e9482eb7f9cd3907650f54bd058070266596", + "research/cover-local-reuse/BIT-PADDED.md": "f5c2747c0d3eab684012e754b087a2f751d48cc10f0fa9d6e8680f13f8254aa0" + }, + "stages": 3, + "status": "Exact paid padded triple-sharing bit moment under retained weighted contracts", + "strict_gap": "1807812097424729379201190496240212846189774429/928861200384509749695498114206254088847360000000000000000", + "v": 1771, + "vertices_per_cell": 3, + "weighted_projector_good_class_compiler_retained": true, + "zero_width_exteriors_omitted": 51903 + }, + "complex": { + "N": 5429865121827552647077858011984403773446228037761673728654165426549376441136963461133579111375261403962832783565059430861677580953741933338971239868179645521810267907926914971080948851768302730715596838464903262932579038291761090141048659818154372840139148163678442450038898348539468599536208394288683311786141964113629758990915541957298452223772805761227305354988359320221563682400264517935229433694078258759639002755832687491853756457109207689852959449914859168067373148019407193996979059666888794415019480673041262745406588952651430008377772765283385630435747165553717833546987301599337107402794253419879831247329936617662054400000000000000000000, + "W": 85869438426615725433074125989524785388642491968602468823145158959859424576265979306783886804177348202669369877236011285198244030225604574374873750486783822752056665343929926756951576841535873184316652859723541600948071362699707525516298091695669867629057671674171939888472292454759881995522609892536748944960845061054116331470621499238991237310235656823980386113887339535503871377387040305061414044276351892098862515010096929335458691400284184466674658729367844272151172497964053767923654557874941363106093787215095397988072771008359043132488492159552969898462458746685223453378784898149516827069903407654385331297060569082169917440000000000000000000, + "cells_per_stage": 1175295480915054685514687881381905578668014726788241066808260914837527368211463952626315824973000303888059044061701175511185623583061024532244857114324598597794430283101063846554317933283182409245800181485909797171553904392156080117110099527739041740289858909887108755419674967216335194704807011750797253633364061496456657790241459298116548100383724190741840985928216303078260537316074570981651392574475813584337446483946469154080899666040954045422718495652566919495102412991213678354324471789369868920999887591567372888616144794946196971510340425386014205722023196007298232369477770908947425844760660913393902867387432168325120000000000000000000, + "child_width_multiplicities": [ + [ + 1, + 693513 + ], + [ + 2, + 411009 + ], + [ + 3, + 88236 + ], + [ + 4, + 64620 + ], + [ + 5, + 37764 + ], + [ + 6, + 28845 + ], + [ + 7, + 17865 + ], + [ + 8, + 24390 + ], + [ + 9, + 13968 + ], + [ + 10, + 34281 + ], + [ + 11, + 32958 + ], + [ + 12, + 26865 + ], + [ + 13, + 7164 + ], + [ + 14, + 7767 + ], + [ + 15, + 1803 + ], + [ + 16, + 2682 + ], + [ + 17, + 4401 + ], + [ + 18, + 3753 + ], + [ + 19, + 2610 + ], + [ + 20, + 126 + ], + [ + 21, + 14469 + ], + [ + 24, + 33 + ], + [ + 30, + 3 + ], + [ + 36, + 63 + ], + [ + 39, + 27 + ], + [ + 42, + 102 + ], + [ + 45, + 108 + ], + [ + 48, + 879 + ], + [ + 51, + 759 + ], + [ + 54, + 594 + ], + [ + 57, + 225 + ], + [ + 60, + 558 + ] + ], + "deficit": 5972851634010307911785643813182844150790850841537841101519581969204314085250659807246937022512787544359116061921565373947845339049116126672868363854997610073991294698719606468189043736945133003787156522311393589225836942120937199155153525799969810124153062980046286695042788183393415459489829233717551642964756160524992734890007096153028297446150086337350035890487195252243720050640290969728752377063486084635602903031415956241039132102820128458838255394906345084874110462821347913396676965633577673856521428740345389019947247847916573009215550041811724193479321882109089616901686031759270818143073678761867814372062930279428259840000000000000000000, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "499789747823/500000000000", + "group_order_bits": 2145, + "logarithm_upper_bounds": { + "1": "4189654742027/1000000000000", + "10": "1887069649033/1000000000000", + "11": "1791759469229/1000000000000", + "12": "1704748092239/1000000000000", + "13": "324941076913/200000000000", + "14": "387649353103/250000000000", + "15": "59264181637/40000000000", + "16": "1417066019787/1000000000000", + "17": "1356441397971/1000000000000", + "18": "1299282984131/1000000000000", + "19": "62260788143/50000000000", + "2": "3496507561467/1000000000000", + "20": "1193922468473/1000000000000", + "21": "71570769019/62500000000", + "24": "1011600911679/1000000000000", + "3": "3091042453359/1000000000000", + "30": "157691472073/200000000000", + "36": "606135803571/1000000000000", + "39": "526093095897/1000000000000", + "4": "2803360380907/1000000000000", + "42": "14124535117/31250000000", + "45": "382992252257/1000000000000", + "48": "318453731119/1000000000000", + "5": "2580216829593/1000000000000", + "51": "257829109303/1000000000000", + "54": "200670695463/1000000000000", + "57": "9162717137/62500000000", + "6": "2397895272799/1000000000000", + "60": "19062035961/200000000000", + "7": "560936148243/250000000000", + "8": "2110213200347/1000000000000", + "9": "1992430164691/1000000000000" + }, + "m": 66, + "maxchild": 60, + "moment_upper": "13853325922822385174410082191450974908747457637619120964337052905688618917014263310886028125750299600701934779992976051623702774300115227085842347655646177510874124114812596483846366529377289194366052906162688341337978785195844032164931624761497714191480151992192402694682152899898650763723851541485474305310805200372205659678188436710624583220971897816069615812640528760503263933644041710408545361729973401949087715039700669869765196945423763983402210073457796815851970146085063420323734544208242591418241107949798600844059762117480260594400824843490963653405172989801430890679104783270084218260750734923228567818993480529874597047432731149820081625455269561050681714013708046044388534309657807551365121627258416672415246293506682942326514993952356636156739769/13853325922845937170622124969626746323584054568506307499986166518019779739194550315774121173333365188506407907941713493029656482937750543728325435372739373294505842274068117544241814489970029605812570900501534337945680683359568680896875460049054297988095462816424730435437917775071453913487357735364368499042626260290595865479182377346356924150352014223230904618359696683424862642512222976446240261358368391232824156002263085616148165352423272395369570184327562936459832569935138851245160832976467268545150030137915298570951851639344843897255708787539636311232151158645056132679662326856645848850926154896473629704519904851106001138121149814965672008215872508303079148715754933916973875437098970482605095446055981416681978952677340444796000000000000000000000000", + "per_cell": { + "R": 21274, + "center_loss_per_invocation": 462, + "child_multiplicities": { + "1": 693513, + "10": 34281, + "11": 32958, + "12": 26865, + "13": 7164, + "14": 7767, + "15": 1803, + "16": 2682, + "17": 4401, + "18": 3753, + "19": 2610, + "2": 411009, + "20": 126, + "21": 14469, + "24": 33, + "3": 88236, + "30": 3, + "36": 63, + "39": 27, + "4": 64620, + "42": 102, + "45": 108, + "48": 879, + "5": 37764, + "51": 759, + "54": 594, + "57": 225, + "6": 28845, + "60": 558, + "7": 17865, + "8": 24390, + "9": 13968 + }, + "data_finish_child_multiplicities": { + "2": 9240 + }, + "deficit_per_cell": 5082, + "execution": "Three completed sequential cores in each independent stage bank; both data banks pay rank2 finishing transforms", + "exterior_child_multiplicities": { + "15": 12, + "21": 123, + "24": 33, + "30": 3, + "36": 63, + "39": 27, + "42": 102, + "45": 108, + "48": 879, + "51": 759, + "54": 594, + "57": 225, + "60": 558 + }, + "h": 22, + "local_child_multiplicities": { + "1": 77057, + "10": 3809, + "11": 3662, + "12": 2985, + "13": 796, + "14": 863, + "15": 199, + "16": 298, + "17": 489, + "18": 417, + "19": 290, + "2": 44641, + "20": 14, + "21": 1594, + "3": 9804, + "4": 7180, + "5": 4196, + "6": 3205, + "7": 1985, + "8": 2710, + "9": 1552 + }, + "local_copies_per_cell": 9, + "local_profile_sha256": "ca5e0293ac87d7cb0ad951fe9332bdfde7cb8cadae25a2ec0293aa7bbaddb0de", + "m": 66, + "maxchild": 60, + "padded_geometry_sha256": "cefee111283998ca68e349dd6c0d1092950e7745e098e4f62c0263fcec9e0a9a", + "rank_per_cell": 4817010, + "reflection_receipt_sha256": "e784187bd4d0c6a6172ddbb519b142d5bf427cb3949f040426be082b49dd75dc", + "removed_two_stage_child_multiplicities": { + "1": 2371600, + "441": 4743200, + "462": 61944960, + "467": 12320, + "469": 126280, + "470": 33880, + "472": 3080, + "474": 64680, + "475": 27720, + "476": 104720, + "477": 110880, + "478": 902440, + "479": 779240, + "480": 609840, + "481": 231000, + "482": 572880 + }, + "reused_roles": 1703, + "roles_per_cell": 73062, + "v": 1540, + "vertices_per_cell": 3, + "virtual_R": 22977 + }, + "saving": "210252177/500000000000", + "strict_gap": "23551996212042778175771414836596930887186535649113612331160822180287004888093047583065587804473127948737441405953708637635316642483087717093195783631718159255521060395447960592740411446517994338845996607701898163724648731943835287556583796615310824232327740755764875172803149763506193878894193731821059918390205800993940635732340929380116407161288805719167922921598708868181266037694899628394989283736440962562415746382968406999508411967360110869766120607862423850075430921426288768224677126908922188116697726892089521864583302854883944048672657826978168843625242000557543586561630590175419973245061885526424321231404090688418665145590382760602947252397434702046887872585341127441162931239973818797564744266732659170657502469485006047643363843260231/13853325922845937170622124969626746323584054568506307499986166518019779739194550315774121173333365188506407907941713493029656482937750543728325435372739373294505842274068117544241814489970029605812570900501534337945680683359568680896875460049054297988095462816424730435437917775071453913487357735364368499042626260290595865479182377346356924150352014223230904618359696683424862642512222976446240261358368391232824156002263085616148165352423272395369570184327562936459832569935138851245160832976467268545150030137915298570951851639344843897255708787539636311232151158645056132679662326856645848850926154896473629704519904851106001138121149814965672008215872508303079148715754933916973875437098970482605095446055981416681978952677340444796000000000000000000000000", + "total_rank": 5661410084522627570671106671495452991499613619086225101226060909381517707948303974440489592053192193831819295835655179449136260655840785782068799168272734691561748618000655559490615027804422497161111932219442352073346872996059759484920520526114241453393653267515301745944128513830758796245002423673707878724451017869046685142171011853620393365029403264045355447626077214091011790856904369164324574545175738793889323087634981379899234500315936046341689220743371376877103274402806200769564523854112552291145668527455950878192855638703780273735024932488684289105042955399115658306098117246108839768470551226427564051233934629143786291200000000000000000000, + "vertices_per_stage": 3525886442745164056544063644145716736004044180364723200424782744512582104634391857878947474919000911664177132185103526533556870749183073596734571342973795793383290849303191539662953799849547227737400544457729391514661713176468240351330298583217125220869576729661326266259024901649005584114421035252391760900092184489369973370724377894349644301151172572225522957784648909234781611948223712944954177723427440753012339451839407462242698998122862136268155486957700758485307238973641035062973415368109606762999662774702118665848434384838590914531021276158042617166069588021894697108433312726842277534281982740181708602162296504975360000000000000000000 + }, + "complex_saving": "210252177/500000000000", + "finite_bridge": { + "bit_uniform": { + "atom_beta": "1/1000", + "coarse_saving": "22550837/50000000000", + "external_stock": "No q-adic group-size factor is inserted into the external polynomial row stock", + "grouping": 3, + "old_atom_saving": "384599/10000000000", + "ordinary_saving": "11265104579/25000000000000", + "padded_dimension": 69, + "paid_data_finishes": { + "2": 10626 + }, + "selector_stock": "O(w log e) internal borrowed rows; restored by the uniform old-supplier wrapper" + }, + "complex": { + "N": 5429865121827552647077858011984403773446228037761673728654165426549376441136963461133579111375261403962832783565059430861677580953741933338971239868179645521810267907926914971080948851768302730715596838464903262932579038291761090141048659818154372840139148163678442450038898348539468599536208394288683311786141964113629758990915541957298452223772805761227305354988359320221563682400264517935229433694078258759639002755832687491853756457109207689852959449914859168067373148019407193996979059666888794415019480673041262745406588952651430008377772765283385630435747165553717833546987301599337107402794253419879831247329936617662054400000000000000000000, + "W": 85869438426615725433074125989524785388642491968602468823145158959859424576265979306783886804177348202669369877236011285198244030225604574374873750486783822752056665343929926756951576841535873184316652859723541600948071362699707525516298091695669867629057671674171939888472292454759881995522609892536748944960845061054116331470621499238991237310235656823980386113887339535503871377387040305061414044276351892098862515010096929335458691400284184466674658729367844272151172497964053767923654557874941363106093787215095397988072771008359043132488492159552969898462458746685223453378784898149516827069903407654385331297060569082169917440000000000000000000, + "actual_M_operations": 76778, + "coefficient_bound": 26, + "coefficient_denominator_divides": 38, + "completed_adapter_group_upper": 826443197104135213709685547359598176891017017982489098580979438215814403642607511495879748700313336879342326156388302789442543016407792275286724922165010012236058202842764689958432867378907322449108142849569009360830233192308868303899467614485272204726984720183647205013650947058270284435819735011488967133864276579130214086467153087219735088228429019307226011800675132822936027746465868904677954310358029571946565971263417048247057996851957509528015052269467550298400099008165206508864707705284511654140098743173559589922775386457186908469012363756276156338280463360937211568274031434308580142720811475083388652700730494043541468128215040000000000000000000, + "finite_group_router_upper": 141932426453657964678140606138280874947352133047182810483214249702478828200554269254949501409434853973431913602419510398291703686939791525546594119244958639432383683333161265504826162652580978816991631043520503663715371344580267527299319984589758533551189807722397027570515633444387476110784985463632329503438556555942666285837952252863783151017072472744365818613876328843083672174310883226612397245800656982833058783140698017877137039764518344863355453548203143032991680197258358719278748549909487738510508438642360843444516917270296903376542267299651877071703640576710242606652931081139582332482899591622351752413464041073110696813015869850080205577817860545716016862611385650881711391368383316813370933670307246925460480633887039427239697778427297505324658372572336973329001117414835718527854032618788385598970927751436767617428515737968775548078605823264316561433452267598568012630431755898463199344629754370409986958972738818992426728491613034843508412832939109041877860508699348542823462233497331785596722478345151782101327111010563982426906946303285445077150918298704723761269740321568216618162921284479943557387565899265189028555307185468487185502845960811485870791920487653919763699579508727056843444781305537119673411455372284053252820178757876139162342732595200000000000000000000000000000000000000, + "guarded_M_operations": 85577, + "halving_degree": 8, + "independently_audited_local_scalar_operations": 7075117, + "invocations_per_stage": 3525886442745164056544063644145716736004044180364723200424782744512582104634391857878947474919000911664177132185103526533556870749183073596734571342973795793383290849303191539662953799849547227737400544457729391514661713176468240351330298583217125220869576729661326266259024901649005584114421035252391760900092184489369973370724377894349644301151172572225522957784648909234781611948223712944954177723427440753012339451839407462242698998122862136268155486957700758485307238973641035062973415368109606762999662774702118665848434384838590914531021276158042617166069588021894697108433312726842277534281982740181708602162296504975360000000000000000000, + "local_group_upper": 24229379263324, + "local_scalar_guard_from_reflection": 8263379048, + "m": 66, + "maxchild": 60, + "physical_R": 21274, + "s": 5661410084522627570671106671495452991499613619086225101226060909381517707948303974440489592053192193831819295835655179449136260655840785782068799168272734691561748618000655559490615027804422497161111932219442352073346872996059759484920520526114241453393653267515301745944128513830758796245002423673707878724451017869046685142171011853620393365029403264045355447626077214091011790856904369164324574545175738793889323087634981379899234500315936046341689220743371376877103274402806200769564523854112552291145668527455950878192855638703780273735024932488684289105042955399115658306098117246108839768470551226427564051233934629143786291200000000000000000000, + "scalar_contract": "Virtual-role reserve covers all compensated readouts and inverse chronology; actual persistent stock and finite routers use physical roles.", + "scalar_group_upper": 141932426453657964678140606138280874947352133047182810483214249702478828200554269254949501409434853973431913602419510398291703686939791525546594119244958639432383683333161265504826162652580978816991631043520503663715371344580267527299319984589758533551189807722397027570515633444387476110784985463632329503438556555942666285837952252863783151017072472744365818613876328843083672174310883226612397245800656982833058783140698017877137039764518344863355453548203143032991680197258358719278748549909487738510508438642360843444516917270296903376542267299651877071703640576710242606652931081139582332482899591622351752413464041073110696813015869850080205834934423330304723175982008623929318743178741419232587280649142828128480804332391631489351132676616572643521954203045385712750956070400400101732802067711087257178423907986249343505322952955232402258382868976237790092937938038657986855684632000323326404147884753108920883202778882565024477046079127727636824214948688034536889554747584668814825326283276084430935373742924058006435775471261822441055070826074356256868294953672697590641039017134040921541387948717299224503355488737692675521198203290023471087860031620721863364186265117795322766917529086051680742593507732917169382356949392261185102815195303115786713410189369396997322018505359360000000000000000000, + "stages": 3, + "virtual_R": 22977, + "wire_bits": 2160 + }, + "conservative_old_coarse_row_reserve": 9909, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 27441, + "complex_coefficient": 17280, + "contract": "Finite complex group role stock plus conservative fixed legacy bit reserves; q-adic selectors borrowed internally and restored; one prefix and one padding; sequential reuse", + "degree": 160000, + "degree_gap": "2600509/25", + "suffix_slope": 640000 + }, + "semantic": { + "B": 182988946298917038970316151084026714904711951924686064258188228593365705232580520942565756494444295075470362502368892221182501451163158738757900224614210622547849278888255917888622050003086006841735680260811293901484265683438912539820411719060024086059008913823410162430329447016604753501675357437550487696674043856483775654703645574721689117877788972777860120045347268017489890829372657876047372618706578014435192016185671103951650268522964784125466613624441275312248984649153687986087993488841059671129695746786134419401909757101992030261425332549053960309027373800995221507570695892035066058082333291642471023729423315824380678128227425209593255221617273741913557308856513446209250580426707365625889702559267177920035628129448469203231295629980616728478424798695902366193181568423620385947565394171720119863244367868767365915303642542423420208033195510157005694322195680822188979063245094559288021653922038823687406706147406485453138868866980816149133334901327811892893682521276694595246156580940980351366258930270249030631828902084237823577521688819296032856533671143637307221276832465371576153158456511452092179200224494728298335451542269432733945858220099233639856302230390503044144569871394522121031545992649969581707844162789159410014011138845164149003905109241797112700185066431787899675411127295945711816853304617689001254762516406425948563197014863340969394461697787697160929751018759664295450410577911840795518943521291874024043789589437029131982315837427703221383132043181564276856419492961342051280908516949426781008940600854109277530972998613430748316378545262916071490048910271940734910348194499016855861113801235449708379875559102751468498091518368855502517796161884053080189515147573596465789513422334002159705421316642945634862156065534105923261491709194322317337816233576272143706767312916341737960213545087084016585422172378770538122818776723955674097097467312060966375093212175879399393416387180793553330267633710453704427568095682246253381815971635373453408589483034051155877308523799234249646694779665955156568529485108941924058309072748601503124862463665193135501564124892509552156656213201766524978454839539557709126315036386068567738505467842244623895784486247459912311549652420739870291928419378170901447130258884826860906383477718290033821375854783165101992309896307870460310637413710830642685750957056782630676186585459153756907092990885184693686986014543868028326304837379382297324343973693419856095201647184348479070900536536059814969870036114194064235650163508714762870066614117733489513126511562791824277873919607543794818620859736791584082024589349835858772635996483126190228222493194013865458133856547976444573004185895109872251356691322844157576685016886532276329582765790676304607446184871767958308855687291848117481907947937546069749533461807381712339284602333701241741553046452409490456785057894495529471784019061451384297031741457035916376732643675342050915566947278544940594454669415059642989583048924441393120190404866105649826003240246200669300379778957840436086901752243417422743083895799679900812204503163151245218463259772647997454488392690499393793006514977093042963714826362831282165748544239699878500016540596737252288986631996995159340766934045449525452253162741779004431291767211418274323140832007494733035370688532944938093017837808953647207938135654367830277240670249309641808312615477051479105954007881433956729423325750036081677393387957843762508991827617976262983870710314507423095288833222376948336177110082654423287673129914345432325008617419795625981933767285044314225737426775655705204550957306231694032175523112994087210344165215368228807310899111338546712978968357588047017914251557642505073476645682178404311261982058607235282788900137783392238723590865730637167927359481444623361448519501643912040728642069387667916759151301949308823070598283751891667864806822116283913282745334267999009481247782407187134300775724235211401579607956756889600000000000019248832, + "C0": 70720223835545737505373133262349750143505492300758716843663901380353039913367033841321210074480685057740291975817073789353226583104068526856128566767141556054886185813228573441568508527681684920175242130240762670551792354404176168898258155230321974719865044557650625962667872980715267817943573454659543163181199053648131300432873186969686202343485191335244215908193796029036528649686152346654499593161882805482769290748806265642733841385376259819281217630889048121294874585174160466934660930022388506150838912736037915672721182777947167588796794495513454602042697513365237629297796032465622920322454958677877886847780718199003299920109092283434893570413263598317241675221330753114674340193540982171172204473055292116647738049720048719547642405918148448065595762316436723819282214487314846715835389691853095495450853238232009146501718879700217721141157309762116163863595357710005028446009352919708706414035529882487215992182940300822562791202871553992771021368989743729621358477746715524102832752336547088934439403265585392243499295645535629178746427989341902658983857964803492347952139874181130368870547944566244972936127149584881963489066343800784467360792464341423851079792053448336376275311382639240085028360326634713760211530087143404975425004378369931453929457224398376953722337487259588703806215693715591845233560921257327009606461765307451751335815886176551620248735343946020133274560959442340252995110579372202975075636500848152581135695755103777840095027700975446101934385251595204945390476489499153463487289487265310507327004901027847832041926165637127728214609850015314693943376977974480101047462568424010989526242269079859519284106432059432997736143634933882387356949816330404132626270416974745676975380321970181523663011630471810094260293543659907754420485675163137213940404060140816805132254270183269808942266009044397832257615369969782498704515122549239431461993824838841708662360210716431966844230603642844789297341141035558266076155493602339917607922368758786189823925004010244532486641599049590286528182795016542263613158465967691802997011180638865287322658176047811497396881196426378760351836593699177119485635485116233924353532755217246138216454951582353957325082662298169011306686866038688583785143441957287284087454025371900451702294210811287517016492376666686223331368906285302778771139827324961456370232881645244830963045971400369949320381564221710485438136195042070347782545750532216277110587377219213713856377509557646534930280934620894666564629643185449800967369404499017012867562882516937289140366112619831024721798270324001093237342942377420680819649812395363117383799793217166653447112795953169541479895579100842175520396580207889427454405590277249846248737642266487161827158856139204514989296659303463709400392906364950594524463384524264488617520753056695652081786338245112694830782423490518274666531213097970966958943005039026032671767714672101725832664788783939419544545737273575180780757338911224036502252385442600730035129655773240465427964171641759716022667953646060179100762028505950542815140841896583113848118369060118600160180718449728206322167613407031890256809049933253018051017074511297981467827272059799437055951757620041578873023446374438743120322037767734210481569704211707183069561467737650620145525721364416084305044813330368757061231385412511963186450355704665041448605227643471004173589908713605908317019941674621282496443662421243868715483214861785716184330802228909229777051572748623023897894550722149330664929270226657747423777933142884886437755931053509748214046017101851032819280079454943336961243251626913030392731364196230533313732685296282406474573379383132285124377318856415014306674709724280467968006807572093394410375340390367323414646648973675405999796185786223150548103052908011748558943801819861197588708152485345986119228968554855317712503132330088541933342887421093007817019976339886268614794025327817223300909721694601681023727133640878198173780026472069721987748510499277003723090300784715937983080134887673740226891794837740385291109728071631854132560008601730254560322521302780377742625078092103118407609117999304635177994793671432734898112200755080198715297404607460743278780091147125425966440986925507472673753834459244687573214524376683321765744575899174414965751160590836608664352375322491428670652002096482319126771030426783492242179262539117963885051049635549360161843827087291081043015102575817854860442347800159557398541033090402540921711329305366132610190613321110799023609526400258754109016876593482204945216363661917656051946225123951765364739410326965814912764230042486478033599212853357804218042720815515389756244644842732270572616258479139134395568456701850759883603229503185043142954259630905570387379996075831113679828741257545903302873373548137237744703832807900497781015005786535527143658660380570346991337853268107848185024490583883984375360102562154360804045080991698244201895891480841775968667717270244186352829841081916227702117155456271663408955004048798225360247224456727019863138288717173260330907005485872022062988950035512445242457784846522862867336148869933401391430120016459599847219438270065234955893537065864228397593454444625973529708402830978149898319134735699659337654405479898846260482730541115384242726565643479637694627683308573683276681444394007792459439164003008167906091733864632954904387497037582510624573309706544453743134522574156201557173675810912656731448806602052330618460894891017051055543056848708644491021228117390310520516760433266659042353135379084746079557527661940200914988916352326358430322475181793173461644057146526789394605911841556435305858309645607721757647672256031134223907608126153057737511403800752874842531912294550363162556863764237625186055328680221787060617044329412438467919752931849716633994601091641317364989594837191898421825088784449756557668281680578712469091978593572055650981665903327036505672755041357650451276810032004679450951228344630802004938082517448938845423654651343144576088900348747288577036778517606246543241711031009876792033052209367011834442150276131808153274561801746659283371694961392189582019101180027670836874254542897609301973485834630097044725981287432634428563287198283490862642529216048896847362138999622463451528168133782160024123331019380753671336879467483650443566138091907302527711185971784224200903049353635608557190922518685817951308511413891440739128761450804995234706269603490544704122380665476185963830651143377311951713064336891911868930170403782717746853028152449351331421746074039850722304876860933296267317570100150928640816974683458128092443739236331830866892784508854705056730742321220395089901226014280810349026425292631759178654506917332916809868873057919153023904758361000055092663221956906626210342091167781743391521263418034005372099484043276486299673581711936629489492165403140948189592036132359190174239310450698629809534458438297368153445519473114547844962169665738688646342386995389774592273725182300079952400775600456601265795903201040217630873963675670288001731216030203900333464144417395380677038106601327346969503879476766026464462811877042571370982235110255819122122930573889116499307624041628380449679910055973874741465047973913271676390853990156107032326645599568111882748340370255804283473156400649699055535944874330934243355354348830198258535393002911765897881194005838642861221321076402164058865252249437848694964235606986128331122189560466897527905994187030070636293420440983542314120892661713743627750684705284181633474305601264646692719104072794226028612917310940430501138577883977469641228906666941938209641786833856135192395388897834059566372520956072643707819326746040355911607277193404253874468799779677252496357327601018494915957971093852972722694714912371515248092948866828945915197737223026881891604580506615056951440433335062736783418156054711122486616595114539410244317617534826337830931804104937404175453296748448972800782533030465241088, + "C1": 1, + "E": 182988946298917038970316151084026714904711951924686064258188228593365705232580520942565756494444295075470362502368892221182501451163158738757900224614210622547849278888255917888622050003086006841735680260811293901484265683438912539820411719060024086059008913823410162430329447016604753501675357437550487696674043856483775654703645574721689117877788972777860120045347268017489890829372657876047372618706578014435192016185671103951650268522964784125466613624441275312248984649153687986087993488841059671129695746786134419401909757101992030261425332549053960309027373800995221507570695892035066058082333291642471023729423315824380678128227425209593255221617273741913557308856513446209250580426707365625889702559267177920035628129448469203231295629980616728478424798695902366193181568423620385947565394171720119863244367868767365915303642542423420208033195510157005694322195680822188979063245094559288021653922038823687406706147406485453138868866980816149133334901327811892893682521276694595246156580940980351366258930270249030631828902084237823577521688819296032856533671143637307221276832465371576153158456511452092179200224494728298335451542269432733945858220099233639856302230390503044144569871394522121031545992649969581707844162789159410014011138845164149003905109241797112700185066431787899675411127295945711816853304617689001254762516406425948563197014863340969394461697787697160929751018759664295450410577911840795518943521291874024043789589437029131982315837427703221383132043181564276856419492961342051280908516949426781008940600854109277530972998613430748316378545262916071490048910271940734910348194499016855861113801235449708379875559102751468498091518368855502517796161884053080189515147573596465789513422334002159705421316642945634862156065534105923261491709194322317337816233576272143706767312916341737960213545087084016585422172378770538122818776723955674097097467312060966375093212175879399393416387180793553330267633710453704427568095682246253381815971635373453408589483034051155877308523799234249646694779665955156568529485108941924058309072748601503124862463665193135501564124892509552156656213201766524978454839539557709126315036386068567738505467842244623895784486247459912311549652420739870291928419378170901447130258884826860906383477718290033821375854783165101992309896307870460310637413710830642685750957056782630676186585459153756907092990885184693686986014543868028326304837379382297324343973693419856095201647184348479070900536536059814969870036114194064235650163508714762870066614117733489513126511562791824277873919607543794818620859736791584082024589349835858772635996483126190228222493194013865458133856547976444573004185895109872251356691322844157576685016886532276329582765790676304607446184871767958308855687291848117481907947937546069749533461807381712339284602333701241741553046452409490456785057894495529471784019061451384297031741457035916376732643675342050915566947278544940594454669415059642989583048924441393120190404866105649826003240246200669300379778957840436086901752243417422743083895799679900812204503163151245218463259772647997454488392690499393793006514977093042963714826362831282165748544239699878500016540596737252288986631996995159340766934045449525452253162741779004431291767211418274323140832007494733035370688532944932431607753286326076536831464158914838777627051163084540582251706095533771157650033440944364676231131918216785841738208508707501853151041835907463815597975622945674477288177662886333308372687585493311355453687562272085452012557660310705461407653043590920572469911473909761076037126547435449029751849405115362759326296168683086636299045490945181683575704312232599391837037466630714216572276517853829766086243264717912195153918757884157738407654819388947947183988104567520087045713300874347516874529517096522248231695351071115967431894503478156642932318137827178870327346218609692911364001673567418663749549296671160167644978812970598400000000000019248832, + "exact_grid": "One common dyadic grid times 19^(-K); K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 19, + "induction_gap": 2012878409288087428673477661924293863951831471171546706840070514527022757558385730368223321438887245830173987526057814433007515962794746126336902470756316848026342067770815096774842550033946075259092482868924232916326922517828037938024528909660264946649098052057511786733623917182652288518428931813055364663414482421321532201740101321938580296655678700556461320498819948192388799123099236636521098805772358158787112178042382143468152953752612625380132749868854028434738831140690567846967928377251656382426653214647478613421007328121912332875678658039593563399301111810947436583277654812385726638905666208067181261023656474068187459410501677305525807437790011161049130397421647908301756384693781021884786728151938957120391909423933161235544251929786784013262672785654926028124997252659824245423219335888921318495688046556441025068340067966657622288365150611727062637544152489044078769695696040152168238193142427060561473767621471339984527557536788977640466683914605930821830507734043640547707722390350783865028848232972739336950117922926616059352738577012256361421870382580010379434045157119087337684743021625973013971202469442011281689966964963760073404440421091570038419324534295533485590268585339743331347005919149665398786285790680753510154122527296805639042956201659768239702035730749666896429522400255402829985386350794579013802387680470685434195167163496750663339078675664668770227261206356307249954516357030248750708378734210614264481685483807320451805474211704735435214452474997207045420614422574762564089993686443694591098346609395202052840702984747738231480163997892076786390538012991348084013830139489185414472251813589946792178631150130266153479006702057410527695757780724583882084666623309561123684647645674023756759634483072401983483716720875165155876408801137545490715978569338993580774440442079759117562348995957924182439643896166475919351006543963512415068072140432670630126025333934673393327580258988729086632943970814990748703249052504708787199975687989107987494484313374562714650393761791576746113642576325506722253824336198361164641399800234616534373487100317124490517205373817605073723218345219431774763003234935134800389465400246754245123560146264690862853629348722059035427046176628138573211212613159879915918432847733095469970218254901190372035134402614816121915408859386575063417011550819137069543260527624608937438052440050691325978022899737031630556846159982548311589353211173205270567783710627618417047218119027833269779905901896657964668570397256134706592151798595862391570732755295068384644391627190710067056613115682981743004829457104707424902270482848194446498995961314388092510447425134152520039472422027740890303046044846208594764923604551285733343535185751855039625410423697439350681908033589447541397412560210329292300987427313006767244868079881198835732130625670713659157083510976504395024635636839450824189624209675965227267349156027395080144059080428762560071236420063994346539001363565656072885413538168855324322094453527162148086035642708207362304177568536244796955919274677591650173922853796478908934249534794663697403095857499127971999372319595493331723071664748023472600863089991144103823233986636698663500181946564109775178852951966946752748436274499944779974784790159569048744209439325601017554549152082442063389077573862394319023196215898490119287319492198046133049647372742406059891438770247566270165494086695773524023656583250396898451327267536281387598910103797738892822577813459581654048177165446146431697948210909198656164404429057799755575094791617751885801271440135487456483111694532212757250060530368548634353930754242934959313785817369050516880419890224724013842768651933468517197056767134067555808243102503962447423881802644679588110677901515617314625959499523037008847200954295890856975933714518083032448015062763264347084350664321442397053776581121270808346512875043279123046110198676947989104293725606479058477308532966587325417375687524325785600000000000211737152, + "literal_charge": 2093094654161148812331798595628707438879627720832785900192031239249680828861273519676321221727605876204183577003372229253540717119489410614803538447679858271511002063399197266085523942501431344299993818406537275191335016988401800381151035412907725494222360050385337889924990192666578623793821689753907514411709430367467230894648774221406587914199956636673406347270598138114778569236101416839602976672751447745232201137021085194919862426548739450155059768657683817665431453842275295717524956996244692392814889952143294702989719468630980468186402702126530721654816194758059152514010835898671586676839911930689545464529201606860512168906019168623483685980722673970533378210004973881802294962713279510980473791448265145601211017765093645461793465477116947226512907168355631893524070047417568575246786566413207994156364929321357756283269941400330311935029036565043572673728198238344549837521385135520878597166530324082202115064653104169557626653529187598772246897081351048844978384544069210965678732008738529414644706395749926855165400936878895244161946283335518826432270059149659175858263156000447098954149245069276595776290705448642252079430939805385465022642654182786373026615089338233637386430910091531176034383401462689876868616311773540223278999659950163124369278036074536166794692127697511834962065755808334326917071990109707220743349799607328380471041687376891921496042778186358750553350702444189287328710780860587102601398218703555745128292749964062589275783822353757101938893108330823080881778289565354989095770814871284286748653109651161422452095492953060457715863797719648180683544008383352347402810666578605196706963239067717025331618457878621793411963525079126185577334874826077348521535443771835637278215018788381366386773793408663794578274301586140050344547872320333945610038688854401531308521980002959586060544542174289752429201069058519808382162216464844089551119093341584938835100629905681532368170843365361461562371672669608859017278906080402823739855525285952534282463666064028804650480138688006802158541950042379132304228707205281093192934662027913438168609726345949212695619796481140046756095954122685250450319763689260383012546093051036463646957061457353548066589733852230953419438445139839130256882493803463599317989714262061255879308560253972461532705147353207507204685136774693108539507124733999862768927207506812719676914115751171105400735357563568837892268986375188527574706566805001499442263260368634329126102040957826783210663968337274016846803335638084103202731844649300215789825647532677065281793477022567597440542422700848044023442038053735059719309478969999360000000000000002116, + "strict_literal_gap": 182988946298917038970316151084026714904711951924686064258188228593365705232580520942565756494444295075470362502368892221182501451163158738757900224614210622547849278888255917888622050003086006841735680260811293901484265683438912539820411719060024086059008913823410162430329447016604753501675357437550487696674043856483775654703645574721689117877788972777860120045347268017489890829372657876047372618706578014435192016185671103951650268522964784125466613624441275312248984649153687986087993488841059671129695746786134419401909757101992030261425332549053960309027373800995221507570695892035066058082333291642471023729423315824380678128227425209593255221617273741913557308856513446209250580426707365625889702559267177920035628129448469203231295629980616728478424798695902366193181568423620385947565394171720119863244367868767365915303642542423420208033195510157005694322195680822188979063245094559288021653922038823687406706147406485453138868866980816149133334901327811892893682521276694595246156580940980351366258930270249030631828902084237823577521688819296032856533671143637307221276832465371576153158456511452092179200224494728298335451542269432733945858220099233639856302230390503044144569871394522121031545992649969581707844162789159410014011138845164149003905109241797112700185066431787899675411127295945711816851211523034840105950184607830319855758135235620136608561505756457911248922157486144619129188850305964591335366517919644770503072469947618517178777389747844949872129979782367010770895550459910706980914698542889505817605583865707477149821963200523022822156185212530733600123920079274156286554372809262948346702091805082241148980910328530061910177318412218829111448891285914965410945911472179626186536749582554414473220179621860439942293638985366473106431940536638499672384779733996847989242355920097045567398655134940721882432452910139557654632374021829143375442651117302907222579201339980727806739547268862863784803104508846843915399189663077629898129990912699482875211273029077274075013561085954738666220988217690010967318467343848278596515607271484555898349556496837503608040054845091983581409426635353316984298474610236351370031766444668237426570438805679580323110758049221567761712131035604349413331252847846819245015194231722691348756824189102435049128957701814053147331511763801249344958681702092113271106250661032703821021184522274861662931044601849174860553744484718369150446574223381850225389824448350579499425356478899836818821105596254429504847393460011277862623548419376529232680183207641958337092128161329134401005303295770254595341860076841420957655311313761322605841304355428678393260427438205531131216784557866737352260836095502543870885649635467265655188974108345917579029415088232115320117474090907371206254289073144561736779655187582007160257677985027955237345709225370418660671268162844135467689287079624245185035365951800222874579645964082855919016779877622402734883403270161588247051858748481037792876085685373676094858786408227028032591276721121543114802444083014358738380216799645587105805680780891519445817729369742581423884985471061857404143844818179059847396476288238641432406304382828322579687999697525588747587339527678732480604469780530315251215814952107940513418062111873322898923596368052912861578460334825124176353409626864529607867897761040124002549000492850809972976571024396533780093164145491392025345804733739083583038197256188872403569598782361552640455422039426323768841879668822989226837857899197072925360141492442274891806730500814731903945967926458474507988214598451081442213028980106297476719136833173387773872540844861390297793591021329879129094360354170488575036197187498599529068110259123901496895362402102658660685507907154343357261649771508969210832948252583946447741724844198885757919611259916520733663865548759248231384892015433031864229162658828856427142492490294501805045552741587125313923459250866570619726107258617425107925669334000599040000000000019246716 + } + }, + "kappa": "420151003347/1000000000000000", + "next_grid_rejections": { + "complex": "1e-12 enclosure", + "kappa": "1e-15 assembly" + }, + "profile": { + "R": 21274, + "center_loss_per_invocation": 462, + "child_multiplicities": { + "1": 693513, + "10": 34281, + "11": 32958, + "12": 26865, + "13": 7164, + "14": 7767, + "15": 1803, + "16": 2682, + "17": 4401, + "18": 3753, + "19": 2610, + "2": 411009, + "20": 126, + "21": 14469, + "24": 33, + "3": 88236, + "30": 3, + "36": 63, + "39": 27, + "4": 64620, + "42": 102, + "45": 108, + "48": 879, + "5": 37764, + "51": 759, + "54": 594, + "57": 225, + "6": 28845, + "60": 558, + "7": 17865, + "8": 24390, + "9": 13968 + }, + "data_finish_child_multiplicities": { + "2": 9240 + }, + "deficit_per_cell": 5082, + "execution": "Three completed sequential cores in each independent stage bank; both data banks pay rank2 finishing transforms", + "exterior_child_multiplicities": { + "15": 12, + "21": 123, + "24": 33, + "30": 3, + "36": 63, + "39": 27, + "42": 102, + "45": 108, + "48": 879, + "51": 759, + "54": 594, + "57": 225, + "60": 558 + }, + "h": 22, + "local_child_multiplicities": { + "1": 77057, + "10": 3809, + "11": 3662, + "12": 2985, + "13": 796, + "14": 863, + "15": 199, + "16": 298, + "17": 489, + "18": 417, + "19": 290, + "2": 44641, + "20": 14, + "21": 1594, + "3": 9804, + "4": 7180, + "5": 4196, + "6": 3205, + "7": 1985, + "8": 2710, + "9": 1552 + }, + "local_copies_per_cell": 9, + "local_profile_sha256": "ca5e0293ac87d7cb0ad951fe9332bdfde7cb8cadae25a2ec0293aa7bbaddb0de", + "m": 66, + "maxchild": 60, + "padded_geometry_sha256": "cefee111283998ca68e349dd6c0d1092950e7745e098e4f62c0263fcec9e0a9a", + "rank_per_cell": 4817010, + "reflection_receipt_sha256": "e784187bd4d0c6a6172ddbb519b142d5bf427cb3949f040426be082b49dd75dc", + "removed_two_stage_child_multiplicities": { + "1": 2371600, + "441": 4743200, + "462": 61944960, + "467": 12320, + "469": 126280, + "470": 33880, + "472": 3080, + "474": 64680, + "475": 27720, + "476": 104720, + "477": 110880, + "478": 902440, + "479": 779240, + "480": 609840, + "481": 231000, + "482": 572880 + }, + "reused_roles": 1703, + "roles_per_cell": 73062, + "v": 1540, + "vertices_per_cell": 3, + "virtual_R": 22977 + }, + "scope": "Finite local word and complete cover/assembly arithmetic. PR130 group geometry, weighted local-ring compilation, uniform batching and borrowed rows remain explicit written proof dependencies, together with inherited analytic/tape interfaces.", + "status": "Conditional padded covers with completed sequential triples, audited arbitrary frames and source gauges, compensated reuse, and weighted bit fallback" +} diff --git a/research/cover-local-reuse/certificate.py b/research/cover-local-reuse/certificate.py new file mode 100644 index 0000000000..8709563c92 --- /dev/null +++ b/research/cover-local-reuse/certificate.py @@ -0,0 +1,204 @@ +#!/usr/bin/env python3 +"""Exact composition of padded triple covers with audited local suppliers. + +PR130 Cayley cover and weighted bit interface: icekylinx, with OpenAI +GPT-6 Astra/Codex assistance. Local frames/reuse integration for eumemic +with OpenAI Codex assistance; PR117, PR124 and all source notices retained. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json +from math import prod +from pathlib import Path +import sys +if sys.flags.optimize: + raise ValueError('Assertions must remain enabled') +if hasattr(sys,'set_int_max_str_digits'): + sys.set_int_max_str_digits(0) +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +LOCAL=ROOT/'research/cyclic-deferred' +sys.path.insert(0,str(ROOT/'scripts')) +import three_stage_cover_network as inherited +from partial_swap_network import moment +from structured_bulk_assembly import assembly,js +from padded_checks import profile as padded_profile +from bit_padded import certificate as bit_certificate +KGRID=10**15 +BGRID=10**12 +STOP=Q(1,10**18) +BACKOFF=Q(1,10**26) +ETA=Q(1,10**15) + + +def load(name):return json.loads((LOCAL/name).read_text()) +def digest(path):return sha256(path.read_bytes()).hexdigest() + + +def cover_profile(): + local=load('complex-profile.json');audit=load('reflection-audit.json') + h,v,R=(local[k]for k in('h','v','R')) + assert (h,v,R)==(22,1540,21274) + assert local['virtual_R']==22977 and local['reused_roles']==1703 + assert local['generalized_lagrangian_frames'] is True + assert audit['generalized_lagrangian_frames'] is True + assert local['generalized_source_gauges'] is True + assert audit['generalized_source_gauges'] is True + assert local['gauge_frame_stats']['reuse_mapping_fixed'] is True + assert local['gauge_frame_stats']['source_injection_and_root_frames_fixed'] is True + assert local['arbitrary_frame_stats']['source_root_gauge_and_reuse_handoffs_fixed'] is True + assert audit['R']==R and audit['virtual_R']==local['virtual_R'] + assert audit['child_multiplicities']==local['child_multiplicities'] + assert audit['physical_auxiliary_source_frames']==local['physical_auxiliary_source_frames'] + for key in ('exact_arbitrary_dirty_cancellation_by_dependency_cut','physical_aliased_numeric_replay','exact_birth_cut_invariants','literal_frame_incidences_both_directions','reflected_residual_rank_histogram_equal','completed_core_source_inventory_bound','completed_core_pre_exterior_frames_full','reflected_core_active_frames_complement_source','bounded_chunk_coefficients'): + assert audit[key]is True,key + assert audit['source_sha256']==digest(LOCAL/'complex_deferred.py') + assert audit['audit_sha256']==digest(LOCAL/'reflection_audit.py') + inventory=local['physical_auxiliary_source_frames'] + assert sum(row['count']for row in inventory)==R + N=v*v + remaining=Counter({int(r):n for r,n in local['child_multiplicities'].items()}) + # Remove exactly the two-stage data bridges, endpoint copies and exterior + # class. All physical source/target moves and copied centers stay local. + removed=Counter({(h-1)**2:2*N,1:N}) + for row in inventory: + removed[h*h-h+len(row['basis'])]+=2*v*row['count'] + remaining.subtract(removed) + assert all(type(n)is int and n>=0 and n%(2*v)==0 for n in remaining.values()) + H={r:n//(2*v)for r,n in remaining.items()if n} + assert all(00 for r,n in children.items()) + independent=padded_profile(local) + assert independent['child_multiplicities']==dict(sorted(children.items())) + receipt=json.loads((HERE/'padded-geometry.json').read_text()) + assert receipt['profile']==js(independent) + for key in ('order_three_orthogonal_permutation','right_cosets_have_three_vertices', + 'completed_offsets_cancel','reversed_residual_is_forward_inverse', + 'all_three_active_spaces_disjoint','all_stage_tail_ranks_three_times_source_dimension', + 'zero_rank_exteriors_are_rank_zero_adapters','all_local_histograms_retained_nine_times', + 'both_data_bank_finishes_paid'): + assert receipt[key] is True,key + assert receipt['stages_shared']==[1,2,3] + assert receipt['actual_ports_checked']==v + assert receipt['data_finish_rank_per_bank']==2 and receipt['data_finish_ports_per_cell']==6*v + assert receipt['checker_sha256']==digest(HERE/'padded_checks.py') + assert set(receipt['source_sha256'])=={ + 'research/cyclic-deferred/complex-profile.json', + 'research/cyclic-deferred/reflection-audit.json', + 'notes/general-clifford-frames.tex','notes/three-stage-cover-complex.tex', + } + for name,pin in receipt['source_sha256'].items(): + assert digest(ROOT/name)==pin,('Padded source binding',name) + return dict(h=h,v=v,R=R,virtual_R=local['virtual_R'],reused_roles=local['reused_roles'], + m=m,roles_per_cell=w,rank_per_cell=rank,deficit_per_cell=w*m-rank, + vertices_per_cell=3,local_copies_per_cell=9,execution='Three completed sequential cores in each independent stage bank; both data banks pay rank2 finishing transforms', + maxchild=max(children),center_loss_per_invocation=ell, + local_child_multiplicities=dict(sorted(H.items())), + removed_two_stage_child_multiplicities=dict(sorted(removed.items())), + exterior_child_multiplicities=dict(sorted(exteriors.items())), + data_finish_child_multiplicities=dict(data_finishes), + child_multiplicities=dict(sorted(children.items())), + local_profile_sha256=digest(LOCAL/'complex-profile.json'), + reflection_receipt_sha256=digest(LOCAL/'reflection-audit.json'), + padded_geometry_sha256=digest(HERE/'padded-geometry.json')) + + +def exact(): + p=cover_profile();m,w=p['m'],p['roles_per_cell'];children=p['child_multiplicities'] + def contracts(n): + try:moment(m,w,children,Q(n,BGRID),True) + except ValueError:return False + return True + lo,hi=0,10**9 + assert contracts(lo)and not contracts(hi) + while hi-lo>1: + mid=(lo+hi)//2 + if contracts(mid):lo=mid + else:hi=mid + b=Q(lo,BGRID);cm=moment(m,w,children,b,True) + n=m//2 + vertices=2**(m-1+(n-1)**2)*prod(2**(2*i)-1 for i in range(1,n)) + assert vertices%3==0 + cells=vertices//3 + phase=dict(m=m,N=vertices*p['v'],W=cells*w,total_rank=cells*p['rank_per_cell'], + deficit=cells*p['deficit_per_cell'],vertices_per_stage=vertices,cells_per_stage=cells,maxchild=p['maxchild'], + group_order_bits=vertices.bit_length(),per_cell=p,**cm) + # Use virtual roles in the source-witness scalar reserve: compensated + # recipients still have readouts even though they have no persistent bank. + local=load('complex-profile.json');audit=load('reflection-audit.json') + assert (local['additions'],local['roots'])==(64140,6182) + assert local['total_operations']==87117 and local['total_M_operations']==76778 + for key,value in (('total_operations',87117),('total_M_operations',76778), + ('conservative_M_operations',85577),('readout_denominator',38)): + assert local[key]==audit[key]==value,(key,local[key],audit[key]) + # This conservative virtual-role guard also pays unused input-copy slots. + row=dict(h=p['h'],v=p['v'],R=p['virtual_R'],c=local['additions'],q=local['roots'], + total_M_operations=local['additions']+p['virtual_R']-p['v']) + assert row['total_M_operations']==85577>=local['total_M_operations'] + bridge=inherited.finite_bridge(phase,row) + bridge['semantic']['exact_grid']='One common dyadic grid times 19^(-K); K=G*(D_complex+1); no child rounding' + # Charge every completed auxiliary tail, including rank-zero tails, and + # both finishing data maps explicitly in addition to the inherited router. + supplemental=32*(m+1)**3*(vertices*p['R']+2*vertices*p['v']) + bc=bridge['complex'];bc['completed_adapter_group_upper']=supplemental + bc['scalar_group_upper']+=supplemental + global_W=phase['W'];global_rank=phase['total_rank'];G=bc['scalar_group_upper'] + E=64*(global_W+m+G+1)**3 + charge=2*G*global_W**2+8*global_rank+4*global_W+4+32*m + B=global_rank+E;C0=32*m*B*B + assert charge=global_rank+E and 2*B+18=audit['conservative_local_G']>=audit['expanded_scalar_operations_per_stage'] + bridge['complex'].update(physical_R=p['R'],virtual_R=p['virtual_R'], + actual_M_operations=local['total_M_operations'],guarded_M_operations=row['total_M_operations'], + independently_audited_local_scalar_operations=audit['expanded_scalar_operations_per_stage'], + local_scalar_guard_from_reflection=audit['conservative_local_G'], + scalar_contract='Virtual-role reserve covers all compensated readouts and inverse chronology; actual persistent stock and finite routers use physical roles.') + bit=bit_certificate() + actual_bit=bit['effective_saving'] + bridge['bit_uniform'].update(coarse_saving=bit['coarse_saving'],ordinary_saving=actual_bit, + atom_beta=bit['atom_exponent'],padded_dimension=bit['m'],grouping=3, + paid_data_finishes=bit['data_finish_child_multiplicities']) + a=min(actual_bit,(1-STOP)*b-BACKOFF) + def accepts(n): + try:assembly(a,b,bridge,Q(n,KGRID),beta=STOP,eta=ETA) + except AssertionError:return False + return True + low,high=0,int(b*KGRID)+1 + assert accepts(low)and not accepts(high) + while high-low>1: + mid=(low+high)//2 + if accepts(mid):low=mid + else:high=mid + k=Q(low,KGRID);result=assembly(a,b,bridge,k,beta=STOP,eta=ETA) + assert len(result['strict_constraints'])==47 and len(result['margins'])==7 + return dict(status='Conditional padded covers with completed sequential triples, audited arbitrary frames and source gauges, compensated reuse, and weighted bit fallback', + kappa=k,complex_saving=b,assembly_bit_saving=a,actual_bit_saving=actual_bit, + profile=p,complex=phase,bit=bit,finite_bridge=bridge,assembly=result, + next_grid_rejections=dict(complex='1e-12 enclosure',kappa='1e-15 assembly'), + scope='Finite local word and complete cover/assembly arithmetic. PR130 group geometry, weighted local-ring compilation, uniform batching and borrowed rows remain explicit written proof dependencies, together with inherited analytic/tape interfaces.') + + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');args=ap.parse_args() + result=js(exact());path=HERE/'certificate.json' + if args.write:path.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + else:assert result==json.loads(path.read_text()),'Frozen cover certificate mismatch' + print('PASS kappa',result['kappa'],float(Q(result['kappa'])),'complex',result['complex_saving'],'47 constraints,7 margins',flush=True) +if __name__=='__main__':main() diff --git a/research/cover-local-reuse/geometry-audit.json b/research/cover-local-reuse/geometry-audit.json new file mode 100644 index 0000000000..1c01ae28b2 --- /dev/null +++ b/research/cover-local-reuse/geometry-audit.json @@ -0,0 +1,48 @@ +{ + "status": "PASS independent exact binary symplectic and actual h22 port geometry", + "clifford_checks": [ + { + "h": 1, + "all_subspaces": 2, + "degenerate_subspaces": 0, + "all_ordered_pairs": 4, + "nested_tail_pairs": 3 + }, + { + "h": 2, + "all_subspaces": 5, + "degenerate_subspaces": 1, + "all_ordered_pairs": 25, + "nested_tail_pairs": 12 + }, + { + "h": 3, + "all_subspaces": 16, + "degenerate_subspaces": 6, + "all_ordered_pairs": 256, + "nested_tail_pairs": 66 + }, + { + "h": 4, + "all_subspaces": 67, + "degenerate_subspaces": 29, + "all_ordered_pairs": 4489, + "nested_tail_pairs": 513 + } + ], + "actual_port_triples_checked": 1540, + "source_sha256": { + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/three-stage-cover-complex.tex": "1c5b638aa9b75365b8addec9c8eeee6bc5e499722901079b94c65fce033fde8a", + "notes/three-stage-cover-note.tex": "db8078687825bcd43c6cc2fb69712ebb12840057b77cd5af8f67f53e4ffffa92" + }, + "scope": "Finite checks substantiate the written all-subspace algebra and all selected port identities. They do not verify exact operator phases or all-size fixed-tape/weighted-bit interfaces.", + "source_review_findings": [ + "K_G fixes L0 and LF, transports L_U, and has rank-zero adapters; arbitrary degenerate subspaces are allowed.", + "Dirty-tail Fourier rank holds for direct complement V_sigma, without claiming V_sigma=sigma_perp.", + "Reverse D_U=T_U F_inverse transitions cancel exactly at operator level.", + "The three Cayley port maps preserve source line and make every adjacent data frame equal.", + "Rank-zero adapters reconcile exact representatives; full finite router bound must remain paid." + ], + "publication_blocker_in_reviewed_scope": null +} diff --git a/research/cover-local-reuse/geometry_checks.py b/research/cover-local-reuse/geometry_checks.py new file mode 100644 index 0000000000..63edcf52f1 --- /dev/null +++ b/research/cover-local-reuse/geometry_checks.py @@ -0,0 +1,133 @@ +"""Independent finite checks of PR130's written Clifford and cover identities. +Not an all-size streaming proof or replacement for source verification. +""" +from pathlib import Path +from itertools import combinations +from functools import lru_cache +import json,time,hashlib,sys +if sys.flags.optimize:raise ValueError('Exact geometry requires assertions') +D=Path(__file__).parent + +def basis(rows): + p={} + for x in rows: + for j in sorted(p,reverse=True): + if x>>j&1:x^=p[j] + if x: + j=x.bit_length()-1 + for k in p: + if p[k]>>j&1:p[k]^=x + p[j]=x + return tuple(p[j]for j in sorted(p,reverse=True)) + +def perp(U,h): + U=basis(U);p={x.bit_length()-1:x for x in U};out=[] + for j in range(h): + if j not in p: + x=1<>j&1:x|=1<>i)&1)<>i&1);rows[i],rows[j]=rows[j],rows[i] + for j in range(n): + if j!=i and rows[j]>>i&1:rows[j]^=rows[i] + assert all(rows[i]&((1<>(n+j))&1)<>j)&1)<>h)).bit_count()+((y&mask)&(x>>h)).bit_count())&1 + +def subspaces(h): + spaces={()};todo=[()] + for U in todo: + for x in range(1,1<>i&1 else 0)for i in range(h)if i!=d) + assert all(((x&y).bit_count()&1)==int(i==j)for i,x in enumerate(Aq)for j,y in enumerate(Aq)) + assert all(not((x&q).bit_count()&1)for x in Aq) + def swap(other,fixed): + cols=[(q if q>>j&1 else 0)^sum((other[i] if u>>j&1 else 0)for i,u in enumerate(Aq))for j in range(h)] + for axis in (B,C):cols.extend(Aq if axis==other else axis) + R=tuple(cols) + assert app(R,q)==q and mul(R,R)==tuple(1<>j&1:x^=p[j] + if x: + j=x.bit_length()-1 + for k in p: + if p[k]>>j&1:p[k]^=x + p[j]=x + return tuple(p[j]for j in sorted(p,reverse=True)) +def app(C,x): + y=0 + while x: + z=x&-x;x-=z;y^=C[z.bit_length()-1] + return y +def mul(A,B):return tuple(app(A,b)for b in B) +def inverse(C): + n=len(C);rows=[sum(((C[j]>>i)&1)<>i&1);rows[i],rows[j]=rows[j],rows[i] + for j in range(n): + if j!=i and rows[j]>>i&1:rows[j]^=rows[i] + assert all(rows[i]&((1<>(n+j))&1)<>j)&1)<>h)).bit_count()+((y&mask)&(x>>h)).bit_count())&1 + +def representative(U,h): + """Construct K_G C_E K_G^-1, including degenerate U.""" + U=basis(U);cols=list(U) + for i in range(h): + if len(basis(tuple(cols)+(1<len(cols):cols.append(1<>h)<<(m+offset)) + C=[1<=0 and n%(2*v)==0 for n in H.values()) + H=Counter({r:n//(2*v)for r,n in H.items()if n}) + children=Counter({r:9*n for r,n in H.items()});exteriors=Counter() + zero_tails=0 + for row in inv: + d=len(row['basis']);c=row['count'] + if d:exteriors[3*d]+=3*c + else:zero_tails+=3*c + data=Counter({m-old_m:6*v});children.update(exteriors);children.update(data) + w=6*v+3*R;s=sum(r*n for r,n in children.items()) + assert w*m-s==3*(2*v-3*h*(h-1))==5082 + assert all(00 for r,n in children.items()) + return dict(h=h,m=m,v=v,R=R,vertices_per_cell=3,stages=3,roles_per_cell=w,rank_per_cell=s, + deficit_per_cell=w*m-s,maxchild=max(children),local_copies_per_cell=9, + local_child_multiplicities=dict(sorted(H.items())), + local_cell_child_multiplicities={r:9*n for r,n in sorted(H.items())}, + exterior_cell_child_multiplicities=dict(sorted(exteriors.items())), + data_finish_cell_child_multiplicities=dict(data),zero_width_exteriors_omitted=zero_tails, + child_multiplicities=dict(sorted(children.items()))) + +def image(C,U):return basis(app(C,x)for x in U) +def contains(U,V):return len(basis(U+V))==len(V) +def dot(x,y):return (x&y).bit_count()&1 + +def port_geometry(h,m): + A=tuple(1<>i&1 else 0)for i in range(h)if i!=d) + assert all(dot(x,y)==int(i==j)for i,x in enumerate(Aq)for j,y in enumerate(Aq)) + assert all(not dot(x,q)for x in Aq) + def swap(other): + cols=[(q if q>>j&1 else 0)^sum((other[i]if u>>j&1 else 0)for i,u in enumerate(Aq))for j in range(h)] + for axis in (B,C):cols.extend(Aq if axis==other else axis) + cols.extend(D);R=tuple(cols) + assert mul(R,R)==tuple(1< E, Y finish is (E0 intersect q-perp) + # -> q-perp. Both are nested exact transitions of Fourier rank2. + checks+=1 + return checks + +def check(local): + p=profile(local);h,m=p['h'],p['m'];F=fourier(m);I=tuple(1< 1 else path.parent),) if level else ( + path.parent, root / PACKAGE, root / LOCAL, root / 'scripts') + found = None + for base in bases: + module = base.joinpath(*name.split('.')) + for candidate in (module.with_suffix('.py'), module / '__init__.py'): + if candidate.is_file(): + found = candidate.resolve() + break + if found is not None: + break + require(found is not None and found.is_relative_to(root.resolve()), + 'Unpinned non-stdlib import: ' + name) + pending.append(found) + parent = found.parent + while parent != root.resolve(): + init = parent / '__init__.py' + if init.is_file(): + pending.append(init) + parent = parent.parent + return {str(path.relative_to(root.resolve())) for path in seen} + + +def inventory(root): + names = adopted_sources(root) + names.update(LOCAL + '/' + name for name in LOCAL_FILES) + names.update(PACKAGE + '/' + name for name in PACKAGE_FILES) + names.update(str(path.relative_to(root)) for path in (root / PACKAGE).iterdir() + if path.is_file() and path.name != 'SOURCE.json') + roots = {name for name in names if name.endswith('.py') and + (name.startswith(PACKAGE + '/') or name.startswith(LOCAL + '/'))} + roots.add('references/partial-gauge/pr97/deferred.py') + names.update(python_closure(root, roots)) + return names + + +def create_manifest(root): + return dict(schema=1, + scope='Deterministic restriction to the first 22 coordinates of the immutable PR117 DAG, finite local frame/gauge replay, padded complex/bit geometry and exact paid cover assembly; general cover/bit/analytic interfaces remain conditional.', + files={name: digest(safe_file(root, name)) for name in sorted(inventory(root))}, + provenance=dict(cover_commit='6a9970a530119174507904e23592fd59ede19a5d', + cover_certificate_sha256=BASE_PIN, + scalar_dag_commit='cbb05ce504d571546d9b7794c186a613c659c3bf', + scalar_dag_sha256=DAG_PIN, + scalar_dag_restriction='Retain the first 22 coordinates of the pinned h24 witness, regenerate its restricted output supports and deterministic physical producer; no alternate searched DAG is substituted.', + physical_local_source='PR129 physical-frame/reuse method on the deterministic h22 restriction, extended by PR130 arbitrary-subspace Clifford frames; PR124 compensated birth-cut reuse')) + + +def check_sources(root, manifest=None): + manifest = manifest or json.loads((root / PACKAGE / 'SOURCE.json').read_text()) + require(manifest['schema'] == 1, 'Unsupported source manifest') + require(set(manifest['files']) == inventory(root), 'Incomplete or stale source dependency closure') + for name, value in manifest['files'].items(): + require(digest(safe_file(root, name)) == value, 'Source hash mismatch: ' + name) + require(manifest['files'][LOCAL + '/inputs/complex-dag.json.gz'] == DAG_PIN, + 'Immutable PR117 scalar-DAG provenance mismatch') + return manifest + + +def compare_json(actual, expected): + require(json.loads(actual.read_text()) == json.loads(expected.read_text()), + 'Frozen generated record mismatch: ' + expected.name) + require(actual.read_bytes() == expected.read_bytes(), + 'Frozen generated byte mismatch: ' + expected.name) + + +def snapshot(root, manifest): + return {**{name: digest(root / name) for name in manifest['files']}, + PACKAGE + '/SOURCE.json': digest(root / PACKAGE / 'SOURCE.json')} + + +def verify(root): + manifest = check_sources(root) + before = snapshot(root, manifest) + environment = dict(os.environ, PYTHONDONTWRITEBYTECODE='1') + environment.pop('PYTHONPATH', None) + with tempfile.TemporaryDirectory(prefix='cover-local-reuse-verify-') as directory: + target = Path(directory) + for name in [*manifest['files'], PACKAGE + '/SOURCE.json']: + out = target / name + out.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(root / name, out) + def run(name, *args): + subprocess.run([sys.executable, str(target / name), *map(str, args)], + cwd=target, env=environment, check=True) + run(LOCAL + '/restrict_dag.py') + compare_json(target / LOCAL / 'restriction-audit.json', root / LOCAL / 'restriction-audit.json') + print('PASS deterministic first-22 restriction reconstructed from immutable PR117 DAG', flush=True) + run(LOCAL + '/complex_deferred.py') + for name in ('complex-profile.json', 'reuse-pairs.json'): + compare_json(target / LOCAL / name, root / LOCAL / name) + print('PASS complete physical local compiler and compensated reuse regenerated', flush=True) + run(LOCAL + '/reflection_audit.py', '--source', target / LOCAL / 'complex_deferred.py', + '--output', target / LOCAL / 'reflection-audit.json') + compare_json(target / LOCAL / 'reflection-audit.json', root / LOCAL / 'reflection-audit.json') + print('PASS full independent reflection, dirty cleanup and scalar audit', flush=True) + run(PACKAGE + '/geometry_checks.py') + compare_json(target / PACKAGE / 'geometry-audit.json', root / PACKAGE / 'geometry-audit.json') + run(PACKAGE + '/padded_checks.py') + compare_json(target / PACKAGE / 'padded-geometry.json', root / PACKAGE / 'padded-geometry.json') + run(PACKAGE + '/bit_padded.py') + compare_json(target / PACKAGE / 'bit-padded.json', root / PACKAGE / 'bit-padded.json') + run(PACKAGE + '/certificate.py') + run(PACKAGE + '/test_controls.py') + require(snapshot(root, manifest) == before, 'Verification mutated a frozen source or artifact') + print('PASS read-only finite cover/local-reuse verification; general interfaces remain conditional', flush=True) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--freeze-manifest', action='store_true', + help='Explicit authoring operation; replace SOURCE.json without certifying it') + args = ap.parse_args() + if args.freeze_manifest: + (HERE / 'SOURCE.json').write_text(json.dumps(create_manifest(ROOT), indent=2, sort_keys=True) + '\n') + print('Frozen source manifest; this operation does not certify the package') + else: + verify(ROOT) + + +if __name__ == '__main__': + main() diff --git a/research/cyclic-deferred/arbitrary_frames.py b/research/cyclic-deferred/arbitrary_frames.py new file mode 100644 index 0000000000..d59fa6d1a6 --- /dev/null +++ b/research/cyclic-deferred/arbitrary_frames.py @@ -0,0 +1,71 @@ +"""Arbitrary binary physical frames under icekylinx PR130's Clifford theorem. + +The PR117 DAG and PR124 compensated reuse remain unchanged. Only common +mixer frames move, with sources, roots, gauges and reuse handoffs fixed. +Prepared for eumemic with OpenAI Codex assistance. Apache-2.0. +""" +from collections import defaultdict +from functools import lru_cache +from reuse import basis, complement, contained + +# r^(1-1/3000), rounded to integer multiples of 10^-40 with 90-digit +# Decimal precision. These frozen integers choose the search path only; +# the complete histogram and characteristic moment are certified exactly. +WEIGHTS = (0, 10000000000000000000000000000000000000000, 19995379552591837382775889827050449904979, 29989015888449392928645236540478701956455, 39981520345220774690768272038046978013735, 49973183228757330836823088833072358339525, 59964175509825272502769082288517196077212, 69954610152207694202574952004534640790419, 79944567439236201753790348429080145493684, 89934107395767013189839565186018423885624, 99923276611021966935579916938258879056401, 109912112302259010906160819839182212710832, 119900644887718846958874586969063870269385, 129888899695720170457234823823425114507787, 139876898144698708970082643468833997994746, 149864658584359632812685622102969862143699, 159852196911530273460627424580342355718650, 169839527031456604018724816697495391901760, 179826661210191807363562888188255624208623, 189813610348441151070503826377433151796525, 199800384197600682599437329947280431748835, 209786991532483974684540213818179734824257, 219773440291076756696113170334150098302772, 229759737688831192394197057459135847609982, 239745890313046845226998719817503395211757) + +@lru_cache(None) +def cap(A,B,h): + return complement(basis(complement(A,h)+complement(B,h)),h) + +@lru_cache(None) +def general_frame(F,h): + """Check the actual arbitrary-subspace L_U, including its radical.""" + assert F==basis(F), 'Noncanonical generalized frame' + Q=complement(F,h) + L=basis(tuple(x|(x<>h)).bit_count()+((x>>h)&(y&mask)).bit_count())&1)==0)for x in L for y in L), 'General frame symplectic pairing' + return True + +def optimize(data): + ops=data['ops'];h=data['h'];R=data['R'];FULL=basis(1<> p & 1: vec ^= r + if vec: + p = vec.bit_length() - 1 + for i in range(len(rows)): + if rows[i] >> p & 1: rows[i] ^= vec + rows.append(vec); piv.append(p) + return rows + + +def kernel(funcs, h): + K = reduce(funcs); piv = [r.bit_length() - 1 for r in K] + out = [] + for c in (i for i in range(h) if i not in piv): + vec = 1 << c + for r, p in zip(K, piv): + if r >> c & 1: vec |= 1 << p + out.append(vec) + return out + + +def restrict(basis, funcs): + B = reduce(basis) + for f in funcs: + if not B: break + vals = [dot(b, f) for b in B] + if not any(vals): continue + k = vals.index(1); pv = B[k] + B = [b ^ pv if val else b for b, val in zip(B, vals)]; B.pop(k) + return reduce(B) + + +def contains(A, B): + RB = reduce(B) + return len(reduce(RB + list(A))) == len(RB) + + +def cap(A, B): + A = reduce(A); B = reduce(B) + if not A or not B: return [] + ker = []; red = [] + for i, vec in enumerate(A + B): + tag = 1 << i + for rv, rt in red: + if vec >> (rv.bit_length() - 1) & 1: vec ^= rv; tag ^= rt + if vec: red.append((vec, tag)) + else: + comb_ = 0 + for k in range(len(A)): + if tag >> k & 1: comb_ ^= A[k] + ker.append(comb_) + return reduce(ker) + + +def nondeg(B): + B = reduce(B); k = len(B) + if not k: return True + M = [sum(dot(B[i], B[j]) << j for j in range(k)) for i in range(k)] + return len(reduce(M)) == k + + +def hopcroft_karp(left, adj): + """maximum bipartite matching; adj[x] = sorted list of right vertices.""" + INF = 1 << 60 + mate_l = {x: None for x in left}; mate_r = {} + while True: + dist = {}; queue = [] + for x in left: + if mate_l[x] is None: dist[x] = 0; queue.append(x) + else: dist[x] = INF + found = INF; head = 0 + while head < len(queue): + x = queue[head]; head += 1 + if dist[x] >= found: continue + for r in adj[x]: + y = mate_r.get(r) + if y is None: found = min(found, dist[x] + 1) + elif dist[y] == INF: dist[y] = dist[x] + 1; queue.append(y) + if found == INF: break + gained = 0 + for x0 in left: + if mate_l[x0] is not None: continue + stack = [(x0, iter(adj[x0]))]; path = [] + while stack: + x, it = stack[-1] + advanced = False + for r in it: + y = mate_r.get(r) + if (y is None and dist[x] + 1 == found) or (y is not None and dist[y] == dist[x] + 1): + path.append((x, r)) + if y is None: + for xx, rr in path: mate_l[xx] = rr; mate_r[rr] = xx + gained += 1; stack = []; break + stack.append((y, iter(adj[y]))); advanced = True; break + else: + dist[x] = INF; stack.pop() + if path: path.pop() + continue + if not advanced: break + if not gained: break + return mate_l + + +from functools import lru_cache +from fractions import Fraction + +def sat_basis(vectors): + piv = {} + for x in vectors: + for p in sorted(piv, reverse=True): + if x >> p & 1: + x ^= piv[p] + if x: + p = x.bit_length() - 1 + for q in piv: + if piv[q] >> p & 1: + piv[q] ^= x + piv[p] = x + return tuple((piv[p] for p in sorted(piv, reverse=True))) + +def sat_dot(a, b): + return (a & b).bit_count() & 1 + +@lru_cache(None) +def sat_contained(A, B): + for x in A: + for r in B: + if x >> r.bit_length() - 1 & 1: + x ^= r + if x: + return False + return True + +@lru_cache(None) +def sat_cap(A, B): + if not A or not B: + return () + red = {} + out = [] + for i, x in enumerate(A + B): + tag = 1 << i + for p in sorted(red, reverse=True): + if x >> p & 1: + r, t = red[p] + x ^= r + tag ^= t + if x: + red[x.bit_length() - 1] = (x, tag) + else: + y = 0 + for j, r in enumerate(A): + if tag >> j & 1: + y ^= r + if y: + out.append(y) + return sat_basis(out) + +@lru_cache(None) +def sat_nondeg(B): + return len(sat_basis((sum((sat_dot(a, b) << j for j, b in enumerate(B))) for a in B))) == len(B) + +@lru_cache(None) +def sat_nonsingular_part(B): + rows = list(B) + out = [] + while rows: + i = next((i for i, x in enumerate(rows) if sat_dot(x, x)), None) + if i is not None: + a = rows.pop(i) + out.append(a) + rows = [x ^ a if sat_dot(x, a) else x for x in rows] + continue + pair = next(((i, j) for i in range(len(rows)) for j in range(i + 1, len(rows)) if sat_dot(rows[i], rows[j])), None) + if pair is None: + break + i, j = pair + a, b = (rows[i], rows[j]) + out.extend((a, b)) + rows = [x ^ (a if sat_dot(x, b) else 0) ^ (b if sat_dot(x, a) else 0) for k, x in enumerate(rows) if k not in (i, j)] + return sat_basis(out) + +def saturated_placement(cand, reach): + # Each extracted block is orthogonal to previously selected blocks. + # A diagonal-one pivot contributes a nondegenerate line; when all + # remaining diagonals vanish, a dot-one pair contributes a hyperbolic + # plane. The residual radical is discarded, not counted as a frame. + cand = {s: sat_basis(B) for s, B in cand.items()} + order = sorted(cand, key=lambda s: (Fraction(-(1 << len(cand[s])), max(1, len(reach[s]))**2), -len(cand[s]), s)) + byT = defaultdict(list); placed = {} + for s in order: + X = cand[s]; changed = True + while changed and X: + changed = False + for t in sorted(reach[s]): + for w in byT[t]: + B = placed[w] + if (len(B) >= len(X) and not sat_contained(X, B)) or (len(B) < len(X) and not sat_contained(B, X)): + X = sat_cap(X, B); changed = True + if not X: break + if not X: break + if X and not sat_nondeg(X): + before = X; X = sat_nonsingular_part(X) + assert sat_contained(X, before) and sat_nondeg(X) + assert len(X) < len(before) + changed = True # Extraction can break containment of a smaller target frame. + if X: + assert sat_nondeg(X) and sat_contained(X, cand[s]) + placed[s] = X + for t in reach[s]: byT[t].append(s) + for t, ss in byT.items(): + ss.sort(key=lambda s: (len(placed[s]), s)) + assert all(sat_contained(placed[a], placed[b]) for a, b in zip(ss, ss[1:])) + return placed + +def frame_restrict(A,B):return sat_basis(restrict(A,B)) + +@lru_cache(None) +def frame_protected_part(X, L): + Q = sat_nonsingular_part(X) + rad = frame_restrict(X, Q) + if not L: + return Q + red = {} + for q, r in [(q, 0) for q in Q] + [(0, r) for r in rad]: + x = q ^ r + for p in sorted(red, reverse=True): + if x >> p & 1: + y, a, b = red[p] + x ^= y + q ^= a + r ^= b + assert x + red[x.bit_length() - 1] = (x, q, r) + lin = {} + for x in L: + q = r = 0 + for p in sorted(red, reverse=True): + if x >> p & 1: + y, a, b = red[p] + x ^= y + q ^= a + r ^= b + if x: + return () + for p in sorted(lin, reverse=True): + if q >> p & 1: + a, b = lin[p] + q ^= a + r ^= b + if not q: + if r: + return () + else: + lin[q.bit_length() - 1] = (q, r) + out = [] + for x in Q: + q = x + r = 0 + for p in sorted(lin, reverse=True): + if q >> p & 1: + a, b = lin[p] + q ^= a + r ^= b + out.append(x ^ r) + out = sat_basis(out) + assert sat_nondeg(out) and sat_contained(out, X) and sat_contained(L, out) + return out + +@lru_cache(None) +def frame_smallest_hull(L, ambient): + L = sat_basis(L) + while not sat_nondeg(L): + radical = frame_restrict(L, L) + assert radical + r = radical[0] + partner = next((x for x in ambient if sat_dot(r, x))) + L = sat_basis(L + (partner,)) + assert sat_contained(L, ambient) + return L + +def main(): + with tempfile.TemporaryDirectory(prefix='deferred-stopped-') as work: + prefix = Path(work) / 'complex' + built = build(22, prefix, central_disjoint=22) + restriction_stats = built['restriction'] + h, v, n, q, args, core, cover, roots, kind, active, ranks, types = load(prefix) + trip = list(combinations(range(h), 3)); require(len(trip) == v, 'triple count') + m = h * h; N = v * v; FULL = (1 << h) - 1 + tmask = [sum(1 << p for p in T) for T in trip] + tid = {T: i for i, T in enumerate(trip)} + + # ------------------------------------------------------------ uses and matching (inherited adjacency) + degree = [0] * n; uses = defaultdict(list); c_add = 0 + for x in range(1, n): + if active[x] and args[x][0]: + c_add += 1 + for pos, y in enumerate(args[x]): degree[y] += 1; uses[y].append(('gate', x, pos)) + for j, x in enumerate(roots): degree[x] += 1; uses[x].append(('root', j)) + def unode(u): return roots[u[1]] if u[0] == 'root' else u[1] + def before(x, u): + y = unode(u) + return (ranks[x], x) < (ranks[y], (n + u[1]) if u[0] == 'root' else y) + def incl(x, y): + tx, ty = types[x], types[y] + if tx == 1 and ty == 1: return not (core[y] & ~core[x]) and not (cover[x] & ~cover[y]) + if tx in (1, 2) and ty == 2: return not (cover[x] & ~cover[y]) + if tx == 1 and ty == 3: return bool(core[x] & core[y]) + if tx == 2 and ty == 3: return not (cover[x] & ~core[y]) + if tx == 3 and ty == 2: return cover[y] == FULL + if tx == 3 and ty == 3: return core[x] == core[y] + return False + left = []; adj = {} + for x in range(1, n): + if not (active[x] and args[x][0]): continue + rs = sorted({(y, k) for y in args[x] for k, u in enumerate(uses[y]) if before(x, u) and incl(x, unode(u))}) + if rs: left.append(x); adj[x] = rs + mate = hopcroft_karp(left, adj) + links = {x: r for x, r in mate.items() if r is not None} + R = c_add + q - len(links) + require((c_add,q,len(links),R)==(64140,6182,47345,22977),'selected restricted PR117 graph') + print('PR117 graph matched', c_add, q, len(links), R, flush=True) + linked_use = {(y, k): x for x, (y, k) in links.items()} + + # ------------------------------------------------------------ root targets, read coefficients, root functionals + target = [None] * q + for j in range(v): target[j] = j + idx = v + # PR117 witness stores pair-star roots in natural excluded-point order. + for a, b in combinations(range(h), 2): + others = [i for i in range(h) if i not in (a, b)] + for i in others: target[idx] = tid[tuple(sorted((a, b, i)))]; idx += 1 + centre_of = {} + for j in range(q): + if kind[j]: + miss = FULL & ~cover[roots[j]]; require(bin(miss).count('1') == 1, 'centre cover') + centre_of[j] = miss.bit_length() - 1 + require(idx + len(centre_of) == q, 'root order') + rootfun = [(1 << centre_of[j]) if kind[j] else tmask[target[j]] for j in range(q)] + + # ------------------------------------------------------------ lifted binary frames, monotone + succ = defaultdict(set); droot = defaultdict(set) + for x in range(1, n): + if not active[x]: continue + for k, u in enumerate(uses[x]): + if (x, k) in linked_use: continue + (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1])) + for x, (y, k) in links.items(): + u = uses[y][k]; (succ[x].add(u[1]) if u[0] == 'gate' else droot[x].add(u[1])) + order_desc = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x), reverse=True) + K = {} + for x in order_desc: + rows = [rootfun[j] for j in droot[x]] + for t in succ[x]: rows += K[t] + K[x] = reduce(rows) + def envelope(x): + if not args[x][0]: return [tmask[x - 1]] + if types[x] == 2: return [1 << i for i in range(h) if cover[x] >> i & 1] + require(types[x] == 1, 'only ordinary and common-pair labels occur') + ks = [i for i in range(h) if (cover[x] & ~core[x]) >> i & 1] + require(len(ks) == ranks[x], 'common-pair support') + return [core[x] | (1 << k) for k in ks] + U = {} + for x in range(1, n): + if not active[x]: continue + if not args[x][0]: U[x] = envelope(x); continue + B = kernel(K[x], h) + require(contains(envelope(x), B), 'label outside lifted frame') + U[x] = B if nondeg(B) else envelope(x) + changed = True + while changed: + changed = False + for x in order_desc: + if args[x][0] and any(not contains(U[x], U[t]) for t in succ[x]): + env = envelope(x) + if len(reduce(U[x])) != len(reduce(env)) or not contains(U[x], env): U[x] = env; changed = True + dimU = {x: len(reduce(B)) for x, B in U.items()} + print('PR117 frames lifted',sum(dimU[x]>ranks[x] for x in U),flush=True) + + # ------------------------------------------------------------ explicit role compile + order = sorted((x for x in range(1, n) if active[x]), key=lambda x: (ranks[x], x)) + holds = []; first_node = []; ops = []; edge_key = {}; role_root = {} + def new_role(node): holds.append([node]); first_node.append(node); return len(holds) - 1 + def serve(s, y, k): + u = uses[y][k] + if u[0] == 'gate': edge_key[(y, k)] = s + else: role_root[s] = u[1] + for x in order: + free = [k for k in range(len(uses[x])) if (x, k) not in linked_use] + if not args[x][0]: + for k in free: + s = new_role(x); ops.append(('src', s, x)); serve(s, x, k) + continue + a, b = args[x] + ka = next(k for k, u in enumerate(uses[a]) if u == ('gate', x, 0)) + kb = next(k for k, u in enumerate(uses[b]) if u == ('gate', x, 1)) + sa, sb = edge_key.pop((a, ka)), edge_key.pop((b, kb)) + if x in links and links[x][0] == a: sa, sb = sb, sa + piv, oth = sa, sb + ops.append(('add', piv, oth, x)); holds[piv].append(x); holds[oth].append(x) + if x in links: serve(oth, *links[x]) + require(free, 'every use linked at node %d' % x) + serve(piv, x, free[0]) + for k in free[1:]: + f = new_role(x); ops.append(('copy', piv, f, x)); serve(f, x, k) + require(not edge_key and len(holds) == R, 'compile') + Rr = R + + # ------------------------------------------------------------ B. the word computes every root value + rng = random.Random(20261008) + xs = [rng.randrange(P) for _ in range(v)] + val = [0] * n + for i in range(v): val[i + 1] = xs[i] + for x in order: + if args[x][0]: val[x] = (val[args[x][0]] + val[args[x][1]]) % P + leaf_of = {s: first_node[s] for s in range(Rr) if not args[first_node[s]][0]} + a_ = [0] * Rr + for s, leaf in leaf_of.items(): a_[s] = xs[leaf - 1] + for o in ops: + if o[0] == 'add': a_[o[1]] = (a_[o[1]] + a_[o[2]]) % P + elif o[0] == 'copy': a_[o[2]] = (a_[o[2]] + a_[o[1]]) % P + require(all(a_[s] == val[roots[j]] for s, j in role_root.items()), 'root values') + + # ------------------------------------------------------------ phase one and garbage reach + def touch(o): return [o[1], o[2]] if o[0] in ('add', 'copy') else [] + prev = {}; pred = defaultdict(list); last = {} + for i, o in enumerate(ops): + for s in touch(o): + if s in prev: pred[i].append(prev[s]) + prev[s] = i; last[s] = i + centre_roles = [s for s, j in role_root.items() if kind[j]] + Anc = set(); st = [last[s] for s in centre_roles] + while st: + i = st.pop() + if i not in Anc: Anc.add(i); st.extend(pred[i]) + touched = set(centre_roles) + for i in Anc: touched.update(touch(ops[i])) + require(all(last[s] in Anc for s in centre_roles), 'centres complete in phase one') + reach = [set() for _ in range(Rr)]; reach_all = [False] * Rr + for s, j in role_root.items(): + if kind[j]: reach_all[s] = True + else: reach[s].add(target[j]) + for o in reversed(ops): + if o[0] == 'add': reach[o[2]] |= reach[o[1]]; reach_all[o[2]] = reach_all[o[2]] or reach_all[o[1]] + elif o[0] == 'copy': reach[o[1]] |= reach[o[2]]; reach_all[o[1]] = reach_all[o[1]] or reach_all[o[2]] + + # ------------------------------------------------------------ deferral frames, insertion nesting + def F0(s): return U[first_node[s]] + cand = {} + for s in range(Rr): + if s in touched or reach_all[s]: continue + S_ = restrict(F0(s), [tmask[t] for t in reach[s]]) + if S_ and nondeg(S_): cand[s] = S_ + print('PR117 candidates',len(cand),flush=True) + placed = saturated_placement(cand, reach) + print('PR117 placed',len(placed),flush=True) + deferred = sorted(placed, key=lambda s: (len(placed[s]), s)); dset = set(deferred) + + # Optimize the actual mixer word. Source injection and root frames stay fixed. + # Floating objective values choose legal finite frames only; the complete + # child profile and its contraction are certified independently and exactly. + root_frame={s:([1<= v else HALF + seed_c = {s: (None if cvec[s] is None else list(cvec[s])) for s in role_root} + seed_d = {s: dict(dpart[s]) for s in role_root} + def addc(dst, src): + if cvec[src] is not None: + cvec[dst] = list(cvec[src]) if cvec[dst] is None else [(p + q_) % P for p, q_ in zip(cvec[dst], cvec[src])] + for t, c in dpart[src].items(): dpart[dst][t] = (dpart[dst].get(t, 0) + c) % P + for o in reversed(ops): + if o[0] == 'add': addc(o[2], o[1]) + elif o[0] == 'copy': addc(o[1], o[2]) + scatter = [[(I21 - (HALF if i in trip[t] else 0)) % P for t in range(v)] for i in range(h)] + def readout(y, s, value, sign, seed=False): + # Logical readout macro: the literal audit combines its exact rational + # target coefficients and expands each numerator/(2*(h-3)) into bounded shears. + cv = seed_c[s] if seed else cvec[s]; dp = seed_d[s] if seed else dpart[s] + if cv is not None: + for i, ci in enumerate(cv): + if ci: + f = sign * ci * value % P; row = scatter[i] + for t in range(v): y[t] = (y[t] + f * row[t]) % P + for t, c in dp.items(): y[t] = (y[t] + sign * c * value) % P + phase1 = sorted(Anc); rest = [i for i in range(len(ops)) if i not in Anc] + def replay(seed, omit_compensation=None): + rng = random.Random(seed) + x = [rng.randrange(P) for _ in range(v)] + z = [rng.randrange(P) for _ in live] + y0 = [rng.randrange(P) for _ in range(v)]; a = list(z); y = list(y0) + chronology = [] + def inject(s, leaf): + dst = alias(s) + a[dst] = (a[dst] + x[leaf - 1]) % P + chronology.append(('src', dst, leaf - 1)) + def run(i): + o = ops[i] + if o[0] == 'src': return + dst, src = (o[1], o[2]) if o[0] == 'add' else (o[2], o[1]) + dst, src = alias(dst), alias(src) + require(dst != src, 'aliased gate ports') + a[dst] = (a[dst] + a[src]) % P + chronology.append(('work', dst, src)) + for s in range(Rr): + if s not in dset: readout(y, s, a[alias(s)], -1) + for s, leaf in leaf_of.items(): + if s not in dset: inject(s, leaf) + for i in phase1: run(i) + for s in centre_roles: readout(y, s, a[alias(s)], +1, True) + compensated = [] + for s in deferred: + if s != omit_compensation: + readout(y, s, a[alias(s)], -1) + compensated.append(s) + if omit_compensation is None: check_compensation(merge, compensated) + for s in deferred: + if s in leaf_of: inject(s, leaf_of[s]) + for i in rest: run(i) + for s, j in role_root.items(): + if not kind[j]: readout(y, s, a[alias(s)], +1, True) + # Aliased births require reversal of the actual source/workspace + # chronology, including delayed source injections. + for kind_, dst, src in reversed(chronology): + value = x[src] if kind_ == 'src' else a[src] + a[dst] = (a[dst] - value) % P + return a == z, all((y[t] - y0[t] - x[t]) % P == 0 for t in range(v)) + rep = [replay(seed) for seed in (1, 2)] + require(all(r == (True, True) for r in rep), 'aliased replay %s' % rep) + missing_compensation = replay(3, omit_compensation=reuse_pairs[0]['recipient']) + require(missing_compensation == (True, False), 'omitted compensation unexpectedly accepted') + compensated_births = sorted(merge) + + # ------------------------------------------------------------ D. exact F2 frame facts + root_frame = {} + for s, j in role_root.items(): + root_frame[s] = [1 << i for i in range(h) if i != centre_of[j]] if kind[j] else kernel([tmask[target[j]]], h) + FULLB = [1 << i for i in range(h)] + chain_dims = [] + for s in range(Rr): + seq = [placed.get(s, [])] + role_frames[s] + if s in root_frame: seq.append(root_frame[s]) + seq.append(FULLB) + require(all(contains(A, B) for A, B in zip(seq, seq[1:])), 'role chain nesting %d' % s) + require(all(general_frame(sat_basis(B), h) for B in seq[1:-1]), 'invalid generalized frame on role %d' % s) + chain_dims.append([len(reduce(B)) for B in seq]) + for s, X in placed.items(): + require(contains(X, F0(s)) and general_frame(sat_basis(X), h), 'deferral frame %d' % s) + require(all(not any(dot(xv, tmask[t]) for xv in X) for t in reach[s]), 'target frame %d' % s) + byT2 = defaultdict(list) + for s in deferred: + for t in reach[s]: byT2[t].append(s) + for t, ss in byT2.items(): + ss.sort(key=lambda s: (len(placed[s]), s)) + require(all(contains(placed[p], placed[q_]) for p, q_ in zip(ss, ss[1:])), 'target chain %d' % t) + + # ------------------------------------------------------------ E. one-child histogram + z = Counter() + for s in range(Rr): + ds = chain_dims[s] + for a, b in zip(ds[:-1], ds[1:-1]): + if b > a: z[b - a] += 2 * v + lastd = ds[-2] + if s in role_root and kind[role_root[s]]: z[h - 1] += 2 * v # copied centre transform + z[h - lastd] += 2 * v # final growth to F + z[m - h + ds[0]] += 2 * v # exterior, gauged by sigma + levels = defaultdict(set) + for s in deferred: + for t in reach[s]: levels[t].add(len(placed[s])) + for t in range(v): + ds = sorted(levels[t] | {0, h - 1}) + for a, b in zip(ds, ds[1:]): z[b - a] += 2 * v # target fronts + z[h - 1] += 2 * N # data-wire fronts + z[(h - 1) ** 2] += 2 * N # data macros + z[1] += N # endpoint copies + z.pop(0, None) + virtual_R = R + for pair in reuse_pairs: + e, f = pair['e'], pair['s'] + z[h - e] -= 2 * v + z[m - h + f] -= 2 * v + if f > e: z[f - e] += 2 * v + require(all(count >= 0 for count in z.values()), 'reuse histogram subtraction') + z = Counter({width: count for width, count in z.items() if count}) + physical_R = len(live) + # Canonical inventory of actual physical source gauges. Recipients have + # disappeared; every reused donor remains a separate zero-gauge slot. + source_counts = Counter(sat_basis(placed.get(s, ())) for s in live) + physical_auxiliary_source_frames = [dict(basis=list(F), count=count) + for F, count in sorted(source_counts.items(), key=lambda item: (len(item[0]), item[0]))] + require(sum(source_counts.values()) == physical_R, 'physical source inventory') + require(all(not placed.get(a) for a in merge.values()), 'reused donor source gauge') + W = 2 * N + 2 * v * physical_R; L = 2 * v * h * (h - 1); s_ = W * m - N + L + require(sum(t * c for t, c in z.items()) == s_, 'complex rank mass') + require(all(0 < t < m for t in z), 'children below m') + out = dict(h=h, v=v, additions=c_add, roots=q, links=len(links), R=physical_R, virtual_R=virtual_R, reused_roles=len(reuse_pairs), m=m, N=N, W=W, L=L, total_rank=s_, + deficit=N - L, maxchild=max(z), phase_one_ops=len(Anc), phase_one_roles=len(touched), + physical_auxiliary_source_frames=physical_auxiliary_source_frames, + generalized_lagrangian_frames=True, arbitrary_frame_stats=arbitrary_frame_stats, + generalized_source_gauges=True, gauge_frame_stats=gauge_frame_stats, + initial_gauge_frame_stats=initial_gauge_frame_stats,restriction=restriction_stats, + total_operations=len(ops),total_M_operations=sum(o[0]!='src' for o in ops), + conservative_M_operations=c_add+R-v,readout_denominator=2*(h-3), + deferred_roles=len(deferred), + deferred_dims=dict(sorted(Counter(len(X) for X in placed.values()).items())), + lifted_additions=sum(1 for i,o in enumerate(ops) if o[0]=='add' and len(op_frames[i])>ranks[o[3]]), + physical_gate_frame_changes=sum(op_frames[i]!=frame_U[o[3]] for i,o in enumerate(ops) if o[0]!='src'), + replay=dict(seeds=[1, 2], scratch_restored=True, y_plus_x=True, field='Z/(2^61-1)', + physically_aliased=True, inverse_order='true source/workspace chronology', + omitted_compensation_rejected=True), + reuse_rejected_controls=reuse_rejected_controls, + child_multiplicities=dict(sorted(z.items()))) + (HERE / 'complex-profile.json').write_text(json.dumps(out, indent=1) + '\n') + (HERE / 'reuse-pairs.json').write_text(json.dumps(reuse_pairs, indent=1) + '\n') + print('PASS complex: R=%d, deferred roles %d, maxchild %d, rank mass %d' % (physical_R, len(deferred), max(z), s_)) + + +if __name__ == '__main__': + main() diff --git a/research/cyclic-deferred/gauge_frames.py b/research/cyclic-deferred/gauge_frames.py new file mode 100644 index 0000000000..41ed5b8bfe --- /dev/null +++ b/research/cyclic-deferred/gauge_frames.py @@ -0,0 +1,206 @@ +"""Deterministic exact-subspace gauge insertion and shared-plateau descent. +Input must contain the exact local source state, +current arbitrary operation frames and fixed compensated reuse pairs. +""" +from collections import Counter,defaultdict +from functools import lru_cache +from reuse import basis,complement,nondeg,contained as plain_contained +from arbitrary_frames import general_frame + +@lru_cache(None) +def contained(A,B):return plain_contained(A,B) + +@lru_cache(None) +def intersection(A,B,h): + return complement(basis(complement(A,h)+complement(B,h)),h) + +# Frozen integer search weights; no floating result enters any certificate. +WEIGHTS = (0, 10000000000000000000000000000000000000000, 19995379552591837382775889827050449904979, 29989015888449392928645236540478701956455, 39981520345220774690768272038046978013735, 49973183228757330836823088833072358339525, 59964175509825272502769082288517196077212, 69954610152207694202574952004534640790419, 79944567439236201753790348429080145493684, 89934107395767013189839565186018423885624, 99923276611021966935579916938258879056401, 109912112302259010906160819839182212710832, 119900644887718846958874586969063870269385, 129888899695720170457234823823425114507787, 139876898144698708970082643468833997994746, 149864658584359632812685622102969862143699, 159852196911530273460627424580342355718650, 169839527031456604018724816697495391901760, 179826661210191807363562888188255624208623, 189813610348441151070503826377433151796525, 199800384197600682599437329947280431748835, 209786991532483974684540213818179734824257, 219773440291076756696113170334150098302772, 229759737688831192394197057459135847609982, 239745890313046845226998719817503395211757, 249731904201495296533012312534849449897105, 259717784908445522472210278494992615266707, 269703537560517101440408324572479956281500, 279689166904247967984995767237230697931084, 289674677346858433464531831432946135319808, 299660072991386137626417202966245749314891, 309645357667131309906013996018901817201642, 319630534956169648883469413861820322206269, 329615608216547946239711841226446070755662, 339600580602665602194156349433186737938982, 349585455083256285454287582466019631567456, 359570234457312897947927495239884378681063, 369554921368241751885243866479822165261943, 379539518316485457755435908822079205273288, 389524027670816171047685041694426412781394, 399508451678469795277115663814408216486410, 409492792474266127696541637300126708888982, 419477052088838699518395411801356466137245, 429461232456080370092893903902666862183135, 439445335419895924660946452619916239478452, 449429362740340473454711911343481884793238, 459413316099211936499973859286203787200282, 469397197105156986089196347967265083247119, 479381007298342234812418820326263672833330, 489364748154735979704796570095644671054616, 499348421090040261669862310776885137110086, 509332027463308225615245127768430435396110, 519315568580277648622735578578711551751269, 529299045696447940039842136448730430345222, 539282460019924824848306569868258868529645, 549265812714054230231448809753163047120645, 559249104899864546551611414841015531401954, 569232337658334378973755920378990083220073, 579215512032501103483286733598126059114324, 589198629029423956201542610683504258368037, 599181689622013988175317443766342623852270, 609164694750741984112709954242943473197095, 619147645325234351466410660273449000512923, 629130542225766017543652267331872731462200, 639113386304658511279126095898030443669003, 649096178387590639477537839434436583250988, 659078919274828483115809426326380440602354, 669061609742380827673467686881910531243346, 679044250543085593761985443132138642637733, 689026842407632343026430549588026886175730, 699009386045525492854112974747077346226498) + +def optimize(S, m=None, solo_rounds=8, joint_rounds=12): + if m is None:m=3*S['h']-2 + ops=S['ops'];R=S['R'];h=S['h'];v=S['v'];FULL=basis(1<=d),len(chain)-1) + if j==0:P=N=();pd=nd=0 + else:pd,P=chain[j-1];nd,N=chain[j] + assert contained(P,F)and contained(F,N),(s,d,pd,nd) + c+=weights[d-pd]+weights[nd-d]-weights[nd-pd] + return c + oldcost=cost(old);best=old;bestcost=oldcost + # Every interval of chronological neighbor frames has a concave rank cost, + # so an optimum occurs at the exact lower span or upper intersection. + cuts=sorted({0}|{d for ch in chains for d,F in ch}) + seen=set() + for k in cuts: + Ps=[];Ns=[] + for ch in chains: + j=max(j for j,(d,F)in enumerate(ch)if d<=k) + Ps.append(ch[j][1]);Ns.append(ch[min(j+1,len(ch)-1)][1]) + low=basis(donorF+tuple(x for F in Ps for x in F)) + if len(low)>len(f)or not contained(low,f):continue + high=f + for N in Ns: + high=cap(high,N) + if len(high)0:frames[i]=winner;changes+=1;gain+=improvement + return dict(changes=changes,gain=str(gain)) + + def sweep_groups(): + # A plateau contains equal gauges joined by a common target read. + # Move the complete component so duplicate readouts cannot pin it in place. + parents={s:s for s in sigma};owner={} + def find(s): + while parents[s]!=s:parents[s]=parents[parents[s]];s=parents[s] + return s + for s,F in sigma.items(): + for t in reach[s]: + key=(t,F) + if key in owner:parents[find(s)]=find(owner[key]) + else:owner[key]=s + groups=defaultdict(list) + for s in sigma:groups[find(s)].append(s) + changes=roles=removed=0;gain=0 + for ss in sorted(groups.values(),key=lambda ss:(-len(ss),ss)): + if len(ss)<2:continue + old=sigma[ss[0]];old_d=len(old);targetcounts=Counter(t for s in ss for t in reach[s]);targets=sorted(targetcounts) + chains=[] + for t in targets: + chain=[(d,F)for d,(F,n)in sorted(levels[t].items())if not(d==old_d and n==targetcounts[t])] + chains.append([(0,())]+chain+[(h-1,targetend[t])]) + f=FULL;donorF=();es=[];fs=[] + for s in ss: + f=cap(f,frames[first[s]]);fs.append(len(frames[first[s]])) + if s in merge: + F=frames[S['last'][merge[s]]];es.append(len(F));donorF=basis(donorF+F) + else:es.append(None) + def cost(F): + d=len(F);c=sum(weights[fd-d]+(weights[d-e]if e is not None else weights[m-h+d])for fd,e in zip(fs,es)) + for chain in chains: + j=next((j for j,(nd,N)in enumerate(chain)if nd>=d),len(chain)-1) + if j==0:P=N=();pd=nd=0 + else:pd,P=chain[j-1];nd,N=chain[j] + assert contained(P,F)and contained(F,N) + c+=weights[d-pd]+weights[nd-d]-weights[nd-pd] + return c + oldcost=cost(old);best=old;bestcost=oldcost;seen=set() + for k in sorted({0}|{d for ch in chains for d,F in ch}): + Ps=[];Ns=[] + for ch in chains: + j=max(j for j,(d,F)in enumerate(ch)if d<=k) + Ps.append(ch[j][1]);Ns.append(ch[min(j+1,len(ch)-1)][1]) + low=basis(donorF+tuple(x for F in Ps for x in F)) + if len(low)>len(f)or not contained(low,f):continue + high=f + for N in Ns: + high=cap(high,N) + if len(high)=d),len(chain)-1) + if j==0:P=N=();pd=nd=0 + else:pd,P=chain[j-1];nd,N=chain[j] + assert contained(P,F)and contained(F,N),(s,d,pd,nd) + c+=3*(weights[d-pd]+weights[nd-d]-weights[nd-pd]) + return c + oldcost=cost(old);best=old;bestcost=oldcost + # Every interval of chronological neighbor frames has a concave rank cost, + # so an optimum occurs at the exact lower span or upper intersection. + cuts=sorted({0}|{d for ch in chains for d,F in ch}) + seen=set() + for k in cuts: + Ps=[];Ns=[] + for ch in chains: + j=max(j for j,(d,F)in enumerate(ch)if d<=k) + Ps.append(ch[j][1]);Ns.append(ch[min(j+1,len(ch)-1)][1]) + low=basis(donorF+tuple(x for F in Ps for x in F)) + if len(low)>len(f)or not contained(low,f):continue + high=f + for N in Ns: + high=cap(high,N) + if len(high)0:frames[i]=winner;changes+=1;gain+=improvement + return dict(changes=changes,gain=str(gain)) + + def sweep_groups(): + # A plateau contains equal gauges joined by a common target read. + # Move the complete component so duplicate readouts cannot pin it in place. + parents={s:s for s in sigma};owner={} + def find(s): + while parents[s]!=s:parents[s]=parents[parents[s]];s=parents[s] + return s + for s,F in sigma.items(): + for t in reach[s]: + key=(t,F) + if key in owner:parents[find(s)]=find(owner[key]) + else:owner[key]=s + groups=defaultdict(list) + for s in sigma:groups[find(s)].append(s) + changes=roles=removed=0;gain=0 + for ss in sorted(groups.values(),key=lambda ss:(-len(ss),ss)): + if len(ss)<2:continue + old=sigma[ss[0]];old_d=len(old);targetcounts=Counter(t for s in ss for t in reach[s]);targets=sorted(targetcounts) + chains=[] + for t in targets: + chain=[(d,F)for d,(F,n)in sorted(levels[t].items())if not(d==old_d and n==targetcounts[t])] + chains.append([(0,())]+chain+[(h-1,targetend[t])]) + f=FULL;donorF=();es=[];fs=[] + for s in ss: + f=cap(f,frames[first[s]]);fs.append(len(frames[first[s]])) + if s in merge: + F=frames[S['last'][merge[s]]];es.append(len(F));donorF=basis(donorF+F) + else:es.append(None) + def cost(F): + d=len(F);c=sum(3*weights[fd-d]+(3*weights[d-e]if e is not None else weights[3*d])for fd,e in zip(fs,es)) + for chain in chains: + j=next((j for j,(nd,N)in enumerate(chain)if nd>=d),len(chain)-1) + if j==0:P=N=();pd=nd=0 + else:pd,P=chain[j-1];nd,N=chain[j] + assert contained(P,F)and contained(F,N) + c+=3*(weights[d-pd]+weights[nd-d]-weights[nd-pd]) + return c + oldcost=cost(old);best=old;bestcost=oldcost;seen=set() + for k in sorted({0}|{d for ch in chains for d,F in ch}): + Ps=[];Ns=[] + for ch in chains: + j=max(j for j,(d,F)in enumerate(ch)if d<=k) + Ps.append(ch[j][1]);Ns.append(ch[min(j+1,len(ch)-1)][1]) + low=basis(donorF+tuple(x for F in Ps for x in F)) + if len(low)>len(f)or not contained(low,f):continue + high=f + for N in Ns: + high=cap(high,N) + if len(high)>p&1:x^=piv[p] + if x: + p=x.bit_length()-1 + for q in piv: + if piv[q]>>p&1:piv[q]^=x + piv[p]=x + return tuple(piv[p] for p in sorted(piv,reverse=True)) + + +def dot(a,b):return (a&b).bit_count()&1 + + +@lru_cache(None) +def contained(A,B):return len(basis(A+B))==len(B) + + +@lru_cache(None) +def complement(A,h): + A=basis(A);piv={x.bit_length()-1:x for x in A};result=[] + for j in range(h): + if j not in piv: + x=1<>j&1:x|=1<

=0 else -1 + parts=(sign*DENOM,)*q+((sign*r,) if r else ()) + check_chunks(numerator,parts) + return parts + +def reverse_row(row): + if row[0]=='old':return (row[0],row[1],row[3],row[2]) + return row + + +def check_reflection(forward,backward,h,v): + def bank(s):return s+v if s=total_M_operations, 'Conservative M-operation guard' + assert d['out']['readout_denominator']==DENOM, 'Readout denominator binding' + for s in d['role_root']:root_readout(d,s) + full=(1<=4 + assert [((k-1)+(k==0)-(k==2)) for k in range(4)]==[0,0,0,2] + # Every centre decoder coefficient is 1/(h-3)-[i in T]/2. Thus the + # preceding source-support identities prove J L V = I over Q. + + # Independently form J L on arbitrary scratch as integer centre rows + # and signed half-output rows. Compare every coefficient, not hashes. + cc=[None]*R;dd=[{} for _ in range(R)] + for s,j in d['role_root'].items(): + if d['kind'][j]:cc[s]=[int(i==d['centre_of'][j]) for i in range(h)] + else:dd[s][d['target'][j]]=1 if j1) + readcount+=len(parts);maxchunk=max(maxchunk,max(map(abs,parts))) + for part in parts: + reached.append(t);records.append(struct.pack('len(old):hist[len(F)-len(old)]+=1 + current[s]=F + for event in events: + k,a,b,c,F,*rest=event + assert c in (-1,1) + promote(a,F) + if k=='gate':promote(b,F);scalar+=1 + elif k=='read': + for t in b:promote(t,F) + scalar+=len(b) + else: + assert k=='centre';G=rest[0] + assert contained(G,F) or contained(F,G) + assert general_frame(G,h);copies[abs(len(F)-len(G))]+=1 + for t in b:promote(t,G) + scalar+=len(b)+2 # temporary copy and erasure + digest.update(repr(event).encode()+b'\n') + # Each literal role cleanup reaches full space; any unused final + # endpoint is still represented explicitly in the expected chain. + for s,F in enumerate(expected):promote(s,F) + assert current==expected + return hist,copies,scalar,digest.hexdigest() + start=tm+[ZERO]*v+[sigma.get(s,ZERO) for s in live] + finish=[FULL]*v+[complement(T,h) for T in tm]+[FULL]*len(live) + # Independently bind the inventory to the actual literal physical ports. + # This reconstruction uses the frame scan's starting list, not the + # producer's virtual role inventory or its selected-pair accounting. + source_counts=Counter(basis(F) for F in start[2*v:]) + physical_auxiliary_source_frames=[dict(basis=list(F),count=count) + for F,count in sorted(source_counts.items(),key=lambda item:(len(item[0]),item[0]))] + assert sum(source_counts.values())==len(live) + assert physical_auxiliary_source_frames==d['out']['physical_auxiliary_source_frames'], 'Literal physical source frame inventory' + assert all(start[A(a)]==ZERO for a in merge.values()), 'Reused donor starts at zero' + assert all(F==FULL for F in finish[2*v:]), 'Completed physical scratch finish' + H,C,scalar,digest=framescan(word,start,finish) + revstart=[None]*len(start);revfinish=[None]*len(start) + for s in range(len(start)): + revstart[swap(s)]=complement(finish[s],h);revfinish[swap(s)]=complement(start[s],h) + HR,CR,scalarR,reverse_digest=framescan(reverse,revstart,revfinish) + assert (H,C,scalar)==(HR,CR,scalarR) + z=Counter({r:2*v*n for r,n in (H+C).items()}) + for s in live:z[h*h-h+len(sigma.get(s,ZERO))]+=2*v + z[(h-1)**2]+=2*v*v;z[1]+=v*v + z.pop(0,None) + assert dict(sorted(z.items()))=={int(r):n for r,n in d['out']['child_multiplicities'].items()},'Literal reflected child histogram' + assert sum(r*n for r,n in z.items())==d['out']['total_rank'] + G=v*v+2*v*scalar + safe=8*(d['c_add']+2*R+(R+q)*v*(h+1)+h*h+h+1) if 'c_add' in d else 8*(d['out']['additions']+2*R+(R+q)*v*(h+1)+h*h+h+1) + assert safe>=scalar + return dict(total_operations=len(ops),total_M_operations=total_M_operations,conservative_M_operations=d['c_add']+R-v,generalized_source_gauges=True,source_gauge_chronology_recomputed=True,source_gauge_deferred_roles=len(sigma),source_gauge_degenerate_roles=sum(not nondeg(F)for F in sigma.values()),physical_source_gauge_dimension_sum=sum(len(F)*n for F,n in source_counts.items()),h=h,v=v,R=len(live),virtual_R=R,reused_roles=len(merge),exact_birth_cut_invariants=True,last_uses_recomputed=True,physical_aliased_numeric_replay=True,omitted_compensation_numeric_control=True,inverse_source_order='True reverse chronological source/workspace word',exact_fresh_source_map=True,exact_integer_old_readout_transpose=True, + physical_auxiliary_source_frames=physical_auxiliary_source_frames, + completed_core_source_inventory_bound=True,completed_core_pre_exterior_frames_full=True, + reflected_core_active_frames_complement_source=all(revfinish[2*v+i]==complement(start[2*v+i],h) for i in range(len(live))), + exact_arbitrary_dirty_cancellation_by_dependency_cut=True, + dirty_reuse_identity="Every recipient is untouched before its compensated birth; donor has no future gate/root reads. Recipient old-response coefficient cancels its arbitrary current donor value. All physical shears are reversed in true chronology.", + reflected_word_rule='Reverse literal order including each bounded readout chunk, negate every shear, swap X/Y ports, complement every frame; auxiliary bank is separate.', + reflected_scalar_map='X becomes X-Y; Y unchanged; all auxiliary coordinates restored.', + two_stage_scalar_map='(X,Y) becomes (-Y,X+Y) before inherited endpoint correction.', + literal_frame_incidences_both_directions=True,generalized_lagrangian_frames=True, + all_frames_nondegenerate=all(nondeg(basis(F))for F in d['op_frames'].values()), + reflected_residual_rank_histogram_equal=True,child_multiplicities=dict(sorted(z.items())), + word_blocks=len(word),expanded_scalar_operations_per_stage=scalar, + expanded_old_readout_additions=readcount,largest_readout_numerator_over_denominator=maxcoef, + unsplit_old_readout_macros=unsplit_readcount,split_readout_macros=split_macros, + largest_bounded_chunk_numerator_over_denominator=maxchunk, + bounded_readout_chunks_sha256=chunk_digest.hexdigest(), + readout_denominator=DENOM,scalar_readout_normalization='Each exact numerator n/DENOM becomes signedDENOM chunks plus a signed remainder. Exact reconstruction and chunk magnitude<=1 checked; every same-frame shear is charged; reflection reverses chunk order.', + exact_chunk_reconstruction=True,bounded_chunk_coefficients=True, + old_readout_coefficients_over_denominator_sha256=coefficient_digest.hexdigest(), + literal_global_scalar_groups=G,conservative_local_G=safe, + forward_incidence_sha256=digest,reflected_incidence_sha256=reverse_digest, + rejected_controls=rejected, + scope='Exact finite source coefficients, dirty cancellation algebra and literal reflected frame/charge ledger. Copied-centre transforms, endpoint correction and residual-to-child/all-size transfer retain their stated inherited contracts.') + + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--source',type=Path);ap.add_argument('--state',type=Path) + ap.add_argument('--output',type=Path);ap.add_argument('--check',type=Path);a=ap.parse_args() + assert bool(a.source)!=bool(a.state) + d=capture(a.source) if a.source else pickle.loads(a.state.read_bytes()) + result=audit(d);source=Path(d['source']) + result['source_sha256']=sha256(source.read_bytes()).hexdigest() + result['audit_sha256']=sha256(Path(__file__).read_bytes()).hexdigest() + result=json.loads(json.dumps(result));encoded=json.dumps(result,indent=2,sort_keys=True)+'\n' + if a.check:assert result==json.loads(a.check.read_text()) + if a.output:a.output.write_text(encoded) + else:print(encoded,end='') + print('PASS exact scalar and literal complement reflection audit',file=sys.stderr) + + +if __name__=='__main__':main() diff --git a/research/cyclic-deferred/replayed_producer.py b/research/cyclic-deferred/replayed_producer.py new file mode 100644 index 0000000000..48b29da492 --- /dev/null +++ b/research/cyclic-deferred/replayed_producer.py @@ -0,0 +1,179 @@ +"""Generalized exact replay of the restricted PR117 complex producer. + +Copyright 2026 eumemic, Apache-2.0. AI-assisted (Claude). The DAG was found by an +automated search over producers of the retained paired-triple, pair-star and +center-disjoint interfaces. The checks below are adapted from +stopped_product/complex.py (copyright 2026 icekylinx, Apache-2.0, PR #104). + +The derived restricted witness lists the ordinary +additions after the v triple inputs and the retained roots: the disjoint sums +D[t], the pair stars P(a,b,i) and the center-disjoint sums A_i. Every support, +core, cover, type and rank is recomputed here from the operands; nothing is +read from the witness except the operand pairs and the root indices. +""" +import gzip, json, struct, sys, array +from fractions import Fraction +from itertools import combinations +from pathlib import Path + + +def write_array(f, values): + """Little-endian array writer, as partial_swap.binary.write_array.""" + if sys.byteorder != 'little' and values.itemsize > 1: + values = array.array(values.typecode, values) + values.byteswap() + values.tofile(f) + + +def build(witness, prefix): + w = json.loads(gzip.decompress(Path(witness).read_bytes())) + h, v, d = w['h'], w['v'], w['central_disjoint'] + assert h >= 12 and h%2 == 0 and (d,w['center_denominator']) == (h,h-3) + triples = list(combinations(range(h), 3)) + assert v == len(triples) + args = [(0, 0)]; support = [0]; core = [0]; cover = [0]; types = [0]; ranks = [0] + for j, t in enumerate(triples): + mask = sum(1 << a for a in t) + args.append((0, 0)); support.append(1 << j); core.append(mask); cover.append(mask) + types.append(1); ranks.append(1) + flat = w['args'] + assert len(flat) % 2 == 0 + for k in range(0, len(flat), 2): + a, b, x = flat[k], flat[k+1], len(args) + assert 0 < a < x and 0 < b < x, 'Operands must precede their sum' + assert not support[a] & support[b], 'Ordinary additions must be cancellation-free' + args.append((a, b)); support.append(support[a] | support[b]) + core.append(core[a] & core[b]); cover.append(cover[a] | cover[b]) + if core[x].bit_count() >= 2: + types.append(1); ranks.append(support[x].bit_count()) + else: + types.append(2); ranks.append(cover[x].bit_count()) + n = len(args) + point_masks = [sum(1 << j for j, t in enumerate(triples) if a in t) for a in range(h)] + full_support = (1 << v) - 1 + roots, kind = [], [] + assert len(w['D']) == v + for t, node in zip(triples, w['D']): + assert 0 < node < n + assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]]) + target_mask = sum(1 << a for a in t) + if types[node] == 2: + assert not cover[node] & target_mask + else: + assert types[node] == 1 + assert not support[node] & (point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]]) + roots.append(node); kind.append(0) + stars = [(a, b, i) for a, b in combinations(range(h), 2) for i in range(h) if i not in (a, b)] + assert len(w['P']) == len(stars) + pair_outputs = {} + for (a, b, i), node in zip(stars, w['P']): + assert 0 < node < n + assert support[node] == point_masks[a] & point_masks[b] & ~point_masks[i] + assert types[node] == 1 + assert not support[node] & (point_masks[a]^point_masks[b]^point_masks[i]) + pair_outputs[a, b, i] = node + roots.append(node); kind.append(0) + assert len(w['A']) == d + for i, node in enumerate(w['A']): + assert 0 < node < n + assert support[node] == full_support & ~point_masks[i] + assert types[node] == 2 and cover[node] == ((1 << h)-1) ^ (1 << i) + assert ranks[node] == h-1 + roots.append(node); kind.append(1) + # Every A_i avoids i, so sum A_i = (h-3)T. The decoder is T=sum A_i/(h-3) + # and the scatter is T-(1/2)sum_{i in target} A_i. + decoder = Fraction(1, h-3) + assert decoder == Fraction(1, h-3) + scatter_coefficients = [decoder, decoder-Fraction(1, 2)] + for coefficient in scatter_coefficients: + odd_denominator = coefficient.denominator + while odd_denominator % 2 == 0: + odd_denominator //= 2 + assert (h-3) % odd_denominator == 0 and abs(coefficient) <= 1 + for source in triples: + assert sum(i not in source for i in range(h))*decoder == 1 + Dset = set(range(d)) + for triple in triples: + k = len(Dset.intersection(triple)) + assert 2*(3-k)-2*(d-k) == 2*(3-d) + patterns = {} + for target in triples: + chosen = len(Dset.intersection(target)) + if chosen not in patterns: + patterns[chosen] = target + for chosen, target in patterns.items(): + target_set = set(target) + for source in triples: + k = len(Dset.intersection(source)) + total_coefficient = Fraction(2*(3-k)-2*(d-k), 2*(3-d)) + scalar = Fraction(len((target_set-Dset).intersection(source)), 2) + scalar -= Fraction(len((target_set & Dset)-set(source)), 2) + scalar += Fraction(chosen-1, 2)*total_coefficient + assert scalar == Fraction(len(target_set.intersection(source))-1, 2) + for j, t in enumerate(triples): + masks = [point_masks[a] for a in t] + two = (masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0]) + actual = 0 + for a, b in combinations(t, 2): + excluded = next(i for i in t if i not in (a, b)) + actual |= support[pair_outputs[a, b, excluded]] + assert actual == two + assert masks[0]&masks[1]&masks[2] == 1 << j + assert [((k-1)+(k == 0)-(k == 2)) for k in range(4)] == [0, 0, 0, 2] + + def contained(x, y): + tx, ty = types[x], types[y] + if tx == 1 and ty == 1: return not(core[y]&~core[x] or cover[x]&~cover[y]) + if tx in (1, 2) and ty == 2: return not cover[x]&~cover[y] + return False + active = [0]*n; stack = list(roots) + while stack: + x = stack.pop() + if not x or active[x]: continue + active[x] = 1 + if args[x][0]: stack.extend(args[x]) + degree = [0]*n + for x in range(1, n): + if active[x]: + if types[x] == 1: + assert core[x].bit_count() >= 2 and ranks[x] == support[x].bit_count() + else: + assert types[x] == 2 and ranks[x] == cover[x].bit_count() + if active[x] and args[x][0]: + for y in args[x]: + assert y < x and contained(y, x), 'Binary frame nesting failed' + degree[y] += 1 + for x in roots: degree[x] += 1 + H = [0]*(h+1); c = 0; loss = 0 + for x in range(1, n): + if not active[x]: continue + r = ranks[x] + if args[x][0]: + c += 1; H[r] += degree[x]-1; H[h-r] += 1 + for y in args[x]: + assert r >= ranks[y] + H[r-ranks[y]] += 1 + else: H[1] += degree[x] + for x, k in zip(roots, kind): + r = ranks[x] + if k: H[r] += 1; H[h] += 1; loss += r + else: H[h-1-r] += 1; H[1] += 1 + q = len(roots); R = c+q + result = dict(h=h, v=v, c=c, q=q, R=R, loss=loss, central_disjoint=d, histogram=H, + rank_sum=sum(r*m for r, m in enumerate(H))) + assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss + result['center_denominator'] = h-3 + result['scalar_validation'] = dict(ordinary_supports_exact=True, centers_exact=True, + center_decoder='sum A_i / '+str(h-3), scatter_coefficients=list(map(str, scatter_coefficients)), + rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True, + binary_frames_nondegenerate=True) + with open(str(prefix)+'.bin', 'wb') as f: + f.write(struct.pack('<4I', h, v, n, q)) + write_array(f, array.array('I', (a for pair in args for a in pair))) + write_array(f, array.array('Q', core)); write_array(f, array.array('Q', cover)) + write_array(f, array.array('I', roots)); write_array(f, array.array('I', kind)) + write_array(f, array.array('B', active)) + with open(str(prefix)+'.labels', 'wb') as f: + write_array(f, array.array('I', ranks)); write_array(f, array.array('B', types)) + Path(str(prefix)+'.json').write_text(json.dumps(result, indent=2)+'\n') + return result diff --git a/research/cyclic-deferred/restrict_dag.py b/research/cyclic-deferred/restrict_dag.py new file mode 100644 index 0000000000..136c78f16f --- /dev/null +++ b/research/cyclic-deferred/restrict_dag.py @@ -0,0 +1,68 @@ +"""Exact first22-coordinate restriction of the immutable PR117 scalar DAG. + +Original searched witness: eumemic with Anthropic Claude assistance. +Restriction and replay integration for eumemic with OpenAI Codex assistance. +Apache-2.0; original witness and upstream provenance remain unchanged. +""" +import argparse,gzip,json +from hashlib import sha256 +from itertools import combinations +from pathlib import Path +HERE=Path(__file__).resolve().parent +WITNESS_SHA256='3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b' +OMITTED=(22,23) + +def canonical(record):return json.dumps(record,separators=(',',':')).encode() + +def restrict_record(w,omitted=OMITTED): + assert (w['h'],w['v'],w['central_disjoint'],w['center_denominator'])==(24,2024,24,21) + assert tuple(omitted)==OMITTED,'Only the certified first22 restriction is supported' + keep=[i for i in range(24)if i not in omitted];rename={i:j for j,i in enumerate(keep)};h=len(keep) + oldtrip=list(combinations(range(24),3));oldtid={t:i for i,t in enumerate(oldtrip)} + oldstars=[(a,b,i)for a,b in combinations(range(24),2)for i in range(24)if i not in(a,b)] + trip=list(combinations(keep,3));v=len(trip);newtid={t:i+1 for i,t in enumerate(trip)} + mapping={0:0};support=[0]+[1<> p & 1: + x ^= piv[p] + if x: + p = x.bit_length() - 1 + for q in piv: + if piv[q] >> p & 1: + piv[q] ^= x + piv[p] = x + return tuple(piv[p] for p in sorted(piv, reverse=True)) + + +def contained(A, B): + return len(basis(tuple(A) + tuple(B))) == len(B) + + +def complement(A, h): + A = basis(A) + piv = {x.bit_length() - 1: x for x in A} + out = [] + for j in range(h): + if j not in piv: + x = 1 << j + for p, row in piv.items(): + if row >> j & 1: + x |= 1 << p + out.append(x) + return basis(out) + + +def nondeg(A): + return len(basis(sum(((x & y).bit_count() & 1) << j + for j, y in enumerate(A)) for x in A)) == len(A) + + +def check_pairs(data, pairs): + """Reject aliases, unfinished donors and unavailable recipient births.""" + donors = [row['donor'] for row in pairs] + recipients = [row['recipient'] for row in pairs] + assert (len(set(donors)) == len(donors) and + len(set(recipients)) == len(recipients) and + not set(donors) & set(recipients)), 'Reuse pair alias' + early = set(data['Anc']) + first = {} + late_touched = set() + for i, op in enumerate(data['ops']): + if op[0] == 'src': + first.setdefault(op[1], i) + continue + for s in op[1:3]: + first.setdefault(s, i) + if i not in early: + late_touched.update(op[1:3]) + for row in pairs: + a, b = row['donor'], row['recipient'] + assert type(a) is int and type(b) is int, 'Reuse role type' + assert 0 <= a < data['R'] and 0 <= b < data['R'], 'Reuse role range' + assert (a not in data['placed'] and a not in data['role_root'] and + data['last'].get(a) in early and a not in late_touched), 'Reuse nondead donor' + assert (b in data['placed'] and b not in data['leaf_of'] and + b not in data['touched'] and first.get(b) not in early), 'Reuse unavailable birth' + birth = data['ops'][first[b]] + assert birth[0] == 'copy' and birth[2] == b, 'Reuse unavailable birth' + A = basis(data['op_frames'][data['last'][a]]) + F = basis(data['placed'][b]) + B = basis(data['op_frames'][first[b]]) + from arbitrary_frames import general_frame + assert all(general_frame(X, data['h']) for X in (A,F,B)), 'Reuse invalid generalized frame' + assert contained(A, F) and contained(F, B), 'Reuse frame containment' + assert basis(row['donor_frame']) == A and basis(row['birth_frame']) == F, 'Reuse recorded frames' + assert (row['e'], row['s']) == (len(A), len(F)), 'Reuse recorded dimensions' + return dict(zip(recipients, donors)) + + +def check_compensation(merge, compensated): + assert set(merge) <= set(compensated), 'Reuse omitted compensation' + + +def select_reuse(data): + groups = defaultdict(list) + for a, i in data['last'].items(): + if i in data['Anc'] and a not in data['role_root']: + A = basis(data['op_frames'][i]) + assert nondeg(A) + groups[A].append(a) + frames = sorted(groups, key=lambda F: (-len(F), F)) + pool = [groups[F][:] for F in frames] + births = defaultdict(list) + for b, F in data['placed'].items(): + if b not in data['leaf_of']: + births[basis(F)].append(b) + allgroups = (1 << len(frames)) - 1 + + @lru_cache(None) + def annihilated(q): + return sum(1 << i for i, A in enumerate(frames) + if all(not ((a & q).bit_count() & 1) for a in A)) + + eligible, capacity = {}, {} + for F in births: + mask = allgroups + for q in complement(F, data['h']): + mask &= annihilated(q) + if not mask: + break + eligible[F] = mask + capacity[F] = sum(len(pool[i]) for i in range(len(frames)) if mask >> i & 1) + available, pairs = allgroups, [] + for F in sorted(births, key=lambda F: (capacity[F], len(F), F)): + for b in sorted(births[F]): + mask = eligible[F] & available + if not mask: + break + i = (mask & -mask).bit_length() - 1 + a = pool[i].pop() + A = frames[i] + if not pool[i]: + available ^= 1 << i + pairs.append(dict(donor=a, recipient=b, donor_frame=A, + birth_frame=F, e=len(A), s=len(F))) + check_pairs(data, pairs) + return pairs + + +def mutation_controls(data, pairs): + """Mutate the actual selected finite pairing, not a synthetic inventory.""" + import copy + rejected = [] + occupied = {row[key] for row in pairs for key in ('donor', 'recipient')} + for failure in ('nondead-donor', 'unavailable-birth', 'pair-alias'): + changed = copy.deepcopy(pairs) + if failure == 'nondead-donor': + changed[0]['donor'] = next(s for s in data['role_root'] if s not in occupied) + elif failure == 'unavailable-birth': + changed[0]['recipient'] = next(s for s in data['leaf_of'] if s not in occupied) + else: + changed[0]['recipient'] = changed[0]['donor'] + try: + check_pairs(data, changed) + except AssertionError as error: + expected = {'nondead-donor': 'nondead donor', + 'unavailable-birth': 'unavailable birth', + 'pair-alias': 'pair alias'}[failure] + assert expected in str(error), (failure, error) + rejected.append(failure) + else: + raise AssertionError('Accepted reuse mutation: ' + failure) + merge = check_pairs(data, pairs) + try: + check_compensation(merge, set(merge) - {pairs[0]['recipient']}) + except AssertionError: + rejected.append('omitted-compensation') + else: + raise AssertionError('Accepted omitted birth compensation') + return rejected diff --git a/research/joint-dual/SOURCE.json b/research/joint-dual/SOURCE.json index 80c0f29dc4..607336c6f9 100644 --- a/research/joint-dual/SOURCE.json +++ b/research/joint-dual/SOURCE.json @@ -3,9 +3,9 @@ "base_pr57_commit": "cd350f76c9bc01489ec83568bded532cb69be938", "base_pr58_commit": "bc2f7ed4c20dc18898305ab17165c0c995cbb804", "files": { - "Makefile": "97620e0205736d9c0fce736e8ac6ab67f8ed0e490c381f6cac152cc6a003dca7", - "NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f", - "README.md": "fd92de31aece76b1f5ff897e6e0dbc38dd3bf67c140579bbcb03a1a11a792668", + "Makefile": "0afb0751eaa8bf66c75d8f084405c97322af9204244dae752f101c9e3e504490", + "NOTICE": "e891051aa7858815850030c9531a88794ba0f39436fbd03cc0f2607a76da8b74", + "README.md": "b09d3d0a9bbddd2c93b8ebf650963ed911f661bc88db18a824331923f2af3b74", "certificates/joint-dual-compiler.json": "516c4d85158553dabd0a98216a064b2a7397957a9d5dd0df1d6e5aec53a4e805", "certificates/joint-dual-profiles-23.json": "159fa8fee175fc1d24f63e72d3c2f1dc9f4fcd78b938c5e7d2f735fd0fd37209", "certificates/joint-dual-profiles-25.json": "8d190ce42d097e828c5756918c52f2963df576cf4c6600b0fc7f2b7fdb6ad223", diff --git a/scripts/partial_gauge/README.md b/scripts/partial_gauge/README.md new file mode 100644 index 0000000000..7dae95e122 --- /dev/null +++ b/scripts/partial_gauge/README.md @@ -0,0 +1,46 @@ +# Selected partial-gauge complex producer + +Run `python3 scripts/partial_gauge_producer.py` from the repository root. +Python's standard library and a C++17 compiler are required. The command +regenerates the selected h = 24 scalar DAG, compatible carrier matching, +backward lifted frames, physical word and partial source gauges. It compares +every field of `certificates/partial-gauge-complex-input.json` and performs +independent finite checks. Intermediate graphs are temporary unless +`--work-dir DIRECTORY` is supplied; `--output FILE` saves the compact report. + +The selected counts are 146,284 additions, 120,097 matched carriers, +34,307 auxiliary roles and 6,341 selected partial source gauges. + +`interval.py` extends the existing `PairedTriple` and +`PairedExclusionCircuit` implementations. `cube.py` overrides the triple +assembly with the selected pair-first cube. `scalar.py` retains only the +selected h = d = 24 rational-center construction. `match.cpp`, `lift.py`, +`word.py` and `select.py` build the actual finite program. The superseded +whole-birth selection is omitted: the physical word supplies only operations, +sources, root roles and the retained-center closure. Final readouts use +`selection.json` in **reverse selection order**. + +`verify.py` independently checks every scalar DAG addition and output support, +the signed coefficient identity and divisor 21, nondegeneracy and old-frame +containment, dependency and carrier nesting, an exact support replay of M, +the center-phase closure and selected untouched roles. It executes the reverse +readout order, checks actual subspace containment and recounts target-data +transitions. It also recounts every positive-rank internal transition directly +from the physical word. Zero-rank no-ops have different literal multiplicities +in the per-role replay; the complete selected histogram, including its zero +bin, is reproduced by the deterministic construction and compared to the +certificate. Partial first transitions retain rank r minus dim(sigma), and +the selected source exterior is m minus h plus dim(sigma). + +Boolean readout support is the conservative support of the exact rational +matrix C = J M; it is used only to impose sufficient frame constraints. +The scalar identity is checked from exact root supports, not inferred from +Boolean cancellation. These finite checks do not establish the inherited +analytic, semantic-precision or fixed-tape interfaces. + +Adapted from `round6_work/complex_{interval,cube}_experiment.py`, +`complex_terminal_counts.cpp`, `complex_maximal_lift.py`, +`complex_deferred_readouts.py`, `complex_partial_deferred_readouts.py`, and +the preceding `round5_complex_rational_centers.py` in the round-six handoff. +The cube override derives from the retained `scripts/paired_triple_circuit.py`. +Copyright 2026 icekylinx, Apache-2.0; see the repository NOTICE and source registry. diff --git a/scripts/partial_gauge/__init__.py b/scripts/partial_gauge/__init__.py new file mode 100644 index 0000000000..070066d031 --- /dev/null +++ b/scripts/partial_gauge/__init__.py @@ -0,0 +1,3 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +"""Selected round-six complex producer and finite verification.""" diff --git a/scripts/partial_gauge/binary.py b/scripts/partial_gauge/binary.py new file mode 100644 index 0000000000..775921796c --- /dev/null +++ b/scripts/partial_gauge/binary.py @@ -0,0 +1,16 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +"""Read the selected scalar DAG and frame-label binary formats.""" +from pathlib import Path +from collections import defaultdict,Counter +import struct,array,json,argparse + +def load(path): + blob=Path(path).read_bytes();h,v,n,q=struct.unpack_from('<4I',blob);at=16 + def take(code,num): + nonlocal at + a=array.array(code);nb=a.itemsize*num;a.frombytes(blob[at:at+nb]);at+=nb;return a + args=take('I',2*n);core=take('Q',n);cover=take('Q',n);roots=take('I',q);kind=take('I',q);active=take('B',n) + lab=Path(str(path).replace('.bin','.labels')).read_bytes();rank=array.array('I');rank.frombytes(lab[:4*n]);types=lab[4*n:] + assert at==len(blob) and len(types)==n + return h,v,n,q,args,core,cover,roots,kind,active,rank,types diff --git a/scripts/partial_gauge/cube.py b/scripts/partial_gauge/cube.py new file mode 100644 index 0000000000..0186c1beda --- /dev/null +++ b/scripts/partial_gauge/cube.py @@ -0,0 +1,92 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +"""Pair-first cube override of the retained PairedTriple recursion.""" +from itertools import combinations +from collections import defaultdict +from .interval import IntervalTriple + +def cube_values(self,G,groups,out_coarse,one,two,w): + (a,a2),(b,b2),(c,c2)=[groups[g] for g in G] + def piece(*points): + p=tuple(sorted(points)) + if not p:return out_coarse[G] + if len(p)==1: + u=p[0];omit=tuple(g for g in G if u not in groups[g]);return one[u][omit] + if len(p)==2: + omit=tuple(g for g in G if not set(p)&set(groups[g]));return two[p][omit] + return w.get(p,0) + def plane(z): + val=lambda *p:piece(*(p+(() if z is None else (z,)))) + F=val();Sa,Sa2,Sb,Sb2=[val(x) for x in (a2,a,b2,b)] + e=lambda u,v:val(u,v) + FSa,FSa2,FSb,FSb2=[self.add(F,x) for x in (Sa,Sa2,Sb,Sb2)] + Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2) + Y3=self.add(FSa2,e(a,b2));Y4=self.add(FSb2,e(a,b)) + return {(a2,b2):self.add(e(a2,b2),Y1),(a2,b):self.add(e(a2,b),Y2), + (a,b2):self.add(Y3,Sb),(a,b):self.add(Y4,Sa2)} + F=plane(None);V={z:plane(z) for z in (c,c2)} + return {tuple(sorted((u,v,z))):self.add(F[u,v],V[z][u,v]) for u,v in F for z in (c,c2)} + +class CubeTriple(IntervalTriple): + cube_values=cube_values + def triple(self,pts,w): + subsets=[s for k in range(4) for s in combinations(pts,k)] + if len(pts)<=self.base: + return {s:self.total([v for t,v in w.items() if not set(s)&set(t)]) for s in subsets} + groups=self.grouping(pts);ng=len(groups) + group_of={u:i for i,g in enumerate(groups) for u in g} + coarse_parts=defaultdict(list) + for t,v in w.items():coarse_parts[tuple(sorted({group_of[u] for u in t}))].append(v) + coarse={s:self.total(xs) for s,xs in coarse_parts.items()} + out_coarse=self.triple(list(range(ng)),coarse) + # Contract one surviving point and aggregate by the other point groups. + one={} + for u in pts: + g=group_of[u];others=[j for j in range(ng) if j!=g] + pieces=defaultdict(list) + for t,v in w.items(): + if u not in t:continue + rest=[a for a in t if a!=u] + if any(group_of[a]==g for a in rest):continue + pieces[tuple(sorted({group_of[a] for a in rest}))].append(v) + coeff={s:self.total(xs) for s,xs in pieces.items()} + edges={s:coeff.get(s,0) for s in combinations(others,2)} + weights={j:coeff.get((j,),0) for j in others} + total,single,pair=self.block(others,edges,weights) + const=coeff.get((),0) + one[u]={():self.add(const,total)} + one[u].update({(j,):self.add(const,x) for j,x in single.items()}) + one[u].update({s:self.add(const,x) for s,x in pair.items()}) + # Contract two surviving points. The remaining degree is at most one. + two={} + for u,v in combinations(pts,2): + i,j=group_of[u],group_of[v] + if i==j:continue + others=[k for k in range(ng) if k not in (i,j)] + vals=[self.total([w.get(tuple(sorted((u,v,a))),0) for a in groups[k]]) for k in others] + total,leave,_=self.vector([w.get((u,v),0)]+vals,False) + two[u,v]={():total}|{(k,):x for k,x in zip(others,leave[1:])} + + result={};cube_cache={} + for excluded in subsets: + E=set(excluded);G=tuple(sorted({group_of[a] for a in E})) + survivors=[u for i in G for u in groups[i] if u not in E] + assert len(survivors)<=3 + pieces={():out_coarse[G]} + for u in survivors: + omit=tuple(i for i in G if i!=group_of[u]) + pieces[u,]=one[u][omit] + for u,v in combinations(survivors,2): + omit=tuple(i for i in G if i not in (group_of[u],group_of[v])) + pieces[u,v]=two[u,v][omit] + if len(survivors)==3:pieces[tuple(survivors)]=w.get(tuple(survivors),0) + if len(survivors)==3 and all(len(groups[g])==2 for g in G): + if G not in cube_cache:cube_cache[G]=self.cube_values(G,groups,out_coarse,one,two,w) + result[excluded]=cube_cache[G][tuple(sorted(survivors))] + continue + if len(survivors)==3: + a,b,c=survivors + order=[(),(a,),(b,),(a,b),(c,),(a,c),(b,c),(a,b,c)] + else:order=[s for k in range(len(survivors)+1) for s in combinations(survivors,k)] + result[excluded]=self.total([pieces[s] for s in order]) + return result diff --git a/scripts/partial_gauge/interval.py b/scripts/partial_gauge/interval.py new file mode 100644 index 0000000000..ba6581b02b --- /dev/null +++ b/scripts/partial_gauge/interval.py @@ -0,0 +1,70 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +"""Cyclic intervals and core-aware pairs, adapted from Avi Eisenberg PR62.""" +from pathlib import Path +from itertools import combinations +import sys +from paired_triple_circuit import PairedTriple +from paired_exclusion_circuit import PairedExclusionCircuit + +def interval_sums(add,values): + nz=[(i,x) for i,x in enumerate(values) if x] + n=len(nz) + if not n:return 0,[0]*len(values) + if n==1: + result=[nz[0][1]]*len(values);result[nz[0][0]]=0 + return nz[0][1],result + v=[x for _,x in nz];states={(a,1):x for a,x in enumerate(v)} + for length in range(2,n): + for a in range(n):states[a,length]=add(states[a,length-1],v[(a+length-1)%n]) + total=add(states[0,n-1],v[-1]) + out=[total]*len(values) + for j,(i,x) in enumerate(nz):out[i]=states[(j+1)%n,n-1] + return total,out + +class IntervalTriple(PairedTriple): + def vector(self,values,two=True): + if two:return super().vector(values,two) + total,one=interval_sums(self.add,values) + return total,one,{} + + def block(self,points,edges,weights): + if len(points)<=2: + return PairedExclusionCircuit.block(self,points,edges,weights) + groups=self.grouping(points);ng=len(groups) + edge=lambda a,b:edges[tuple(sorted((a,b)))] + coarse={(i,j):self.total([edge(a,b) for a in groups[i] for b in groups[j]]) + for i,j in combinations(range(ng),2)} + wt={i:self.total([weights[a] for a in g]+[edge(a,b) for a,b in combinations(g,2)]) + for i,g in enumerate(groups)} + total,outside,far=self.block(list(range(ng)),coarse,wt) + strips={};sums={} + for i,g in enumerate(groups): + other=[j for j in range(ng) if j!=i] + for a in g: + carry=self.total([weights[u] for u in g if u!=a]) + vals=[self.total([edge(u,v) for u in g if u!=a for v in groups[j]]) for j in other] + st,one=interval_sums(self.add,[carry]+vals) + strips[a]={j:z for j,z in zip(other,one[1:])};sums[a]=st + out={};single={a:self.add(outside[i],sums[a]) for i,g in enumerate(groups) for a in g} + for i,g in enumerate(groups): + for a,b in combinations(g,2):out[a,b]=outside[i] + for i,j in combinations(range(ng),2): + if len(groups[i])==len(groups[j])==2: + (a,a2),(b,b2)=groups[i],groups[j] + F=far[i,j];Sa,Sa2,Sb,Sb2=strips[a][j],strips[a2][j],strips[b][i],strips[b2][i] + FSa,FSa2=self.add(F,Sa),self.add(F,Sa2) + FSb,FSb2=self.add(F,Sb),self.add(F,Sb2) + Y1=self.add(FSb,Sa);Y2=self.add(FSa,Sb2) + Y3=self.add(FSa2,edge(a,b2));Y4=self.add(FSb2,edge(a,b)) + out[a,b]=self.add(edge(a2,b2),Y1) + out[a,b2]=self.add(edge(a2,b),Y2) + out[a2,b]=self.add(Y3,Sb) + out[a2,b2]=self.add(Y4,Sa2) + else: + for a in groups[i]: + left=self.add(far[i,j],strips[a][j]) + for b in groups[j]: + cross=self.total([edge(u,v) for u in groups[i] if u!=a for v in groups[j] if v!=b]) + out[a,b]=self.add(left,self.add(strips[b][i],cross)) + return total,single,out diff --git a/scripts/partial_gauge/lift.py b/scripts/partial_gauge/lift.py new file mode 100644 index 0000000000..5b66ec11bc --- /dev/null +++ b/scripts/partial_gauge/lift.py @@ -0,0 +1,144 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +#!/usr/bin/env python3 +"""Construct maximal nondegenerate backward frames containing every old frame. +Existing carrier dependencies are included before the backward pass. Exact F2 +linear algebra only; the general Gauss compiler permits alternating residuals. +""" +from pathlib import Path +from collections import Counter +import json,argparse +from .binary import load + +def basis(rows): + b={} + for x in rows: + for p,y in sorted(b.items(),reverse=True): + if x>>p&1:x^=y + if x: + p=x.bit_length()-1 + for k,y in list(b.items()): + if y>>p&1:b[k]=y^x + b[p]=x + return tuple(b[p] for p in sorted(b,reverse=True)) + +def perp(rows,h): + rows=basis(rows);piv={r.bit_length()-1:r for r in rows};out=[] + for j in range(h): + if j in piv:continue + x=1<>j&1:x|=1<

>31: + j=use&0x7fffffff;x=roots[j];k=kind[j] + normal=(full^cover[x]) if k else (core[x]|(full^cover[x])) + direct[donor].append(normal) + else:succ[donor].append(use//2) + order=sorted((x for x in range(1,n) if active[x]),key=lambda x:(oldrank[x],x)) + place={x:i for i,x in enumerate(order)} + assert all(place[x]>j&1) + elif types[x]==2:U=tuple(1<>j&1) + else:raise ValueError('Unselected center type') + key=(capann,U) + if key not in repaircache: + M=safe_subspace(C,U);repaircache[key]=perp(M,h) + A=repaircache[key];d=h-len(A);repairs+=1 + ann[x]=A;nr[x]=d;assert d>=oldrank[x] + dimhist[d-oldrank[x]]+=1 + degree=[0]*n + for x in order: + if args[2*x]: + degree[args[2*x]]+=1;degree[args[2*x+1]]+=1 + for x in roots:degree[x]+=1 + H=Counter() + for x in order: + r=nr[x] + if args[2*x]: + H[r]+=degree[x]-1;H[h-r]+=1 + for y in (args[2*x],args[2*x+1]):assert r>=nr[y];H[r-nr[y]]+=1 + else: + H[r]+=degree[x]-1;H[1]+=1;H[r-1]+=1 + loss=0 + for x,k in zip(roots,kind): + r=nr[x] + if k:H[r]+=1;H[h-r]+=1;loss+=r + else:assert r<=h-1;H[h-1-r]+=1;H[1]+=1 + for donor,use in arcs.items(): + target=roots[use&0x7fffffff] if use>>31 else use//2 + value=target if use>>31 else args[2*target+(use&1)] + ru,rv=nr[donor],nr[value] + rt=(h-1 if use>>31 else nr[target]) + # Root uses have a direct physical edge to their output frame, not + # necessarily to the value's newly lifted producer frame. + old_target_rank=nr[target] + H[h-ru]-=1;H[rv]-=1 + if use>>31: + H[h-1-rv]-=1;H[h-1-ru]+=1 + else:H[rt-rv]-=1;H[rt-ru]+=1 + assert min(H.values())>=0 + R=meta['R'];mass=sum(r*c for r,c in H.items());assert mass==h*R+loss,(mass,h*R+loss) + out={k:meta[k] for k in ['h','v','c','q','R','matched']} + out.update(loss=loss,histogram=[H[i] for i in range(h+1)],rank_sum=mass, + copied_centers_already=True,repairs=repairs,distinct_caps=len(capcache),distinct_repairs=len(repaircache), + dimension_gains=dict(dimhist),lift='Backward chosen-successor intersection; maximal nondegenerate complement containing old orthonormal frame; old matched dependencies preserved') + return out,ann diff --git a/scripts/partial_gauge/match.cpp b/scripts/partial_gauge/match.cpp new file mode 100644 index 0000000000..9275aaa029 --- /dev/null +++ b/scripts/partial_gauge/match.cpp @@ -0,0 +1,43 @@ +// Copyright 2026 icekylinx. Apache-2.0. +// OpenAI GPT-6 Astra and Codex assistance; retained matcher credits in NOTICE. +#include +#include +#include +#include +#include +#include +#include +using U=uint32_t;using V=uint64_t; +templatevoid readv(std::ifstream&f,std::vector&v){f.read((char*)v.data(),v.size()*sizeof(T));assert(f);} +int main(int argc,char**argv){assert(argc==3);std::ifstream f(argv[1],std::ios::binary);U hdr[4];f.read((char*)hdr,16);assert(f);U h=hdr[0],v=hdr[1],n=hdr[2],q=hdr[3]; +std::vector>args(n);std::vectorcore(n),cover(n);std::vectorroots(q),kind(q);std::vectoractive(n);readv(f,args);readv(f,core);readv(f,cover);readv(f,roots);readv(f,kind);readv(f,active); +std::vectorranks(n),degree(n),begin(n+1);V c=0,inputs=0,loss=0; +for(U x=1;xtypes(n);readv(labels,ranks);readv(labels,types);for(U x:roots)degree[x]++;for(U x=1;xuses(begin.back()),cursor(begin.begin(),begin.end()-1);for(U x=1;xU{return e>>31?roots[e&0x7fffffff]:e/2;}; +auto before=[&](U a,U b){U x=nd(a),y=nd(b);if(ranks[x]!=ranks[y])return ranks[x]>31?V(n)+(a&0x7fffffff):x,oy=b>>31?V(n)+(b&0x7fffffff):y;return oxdonors;for(U x=1;xleftmatch(n),rightmatch(uses.size()),distance(n,UINT32_MAX),queue;V matches=0;U phase=0,inf=UINT32_MAX,shortest=inf; +while(true){queue.clear();shortest=inf;for(U x:donors){if(!leftmatch[x]){distance[x]=0;queue.push_back(x);}else distance[x]=inf;}for(U at=0;at=shortest)continue;adjacency(x,[&](U j){U y=rightmatch[j];if(!y)shortest=distance[x]+1;else if(distance[y]==inf){distance[y]=distance[x]+1;queue.push_back(y);}return false;});}if(shortest==inf)break; +auto aug=[&](auto&&self,U x)->bool{bool ok=adjacency(x,[&](U j){U y=rightmatch[j];if((!y&&distance[x]+1==shortest)||(y&&distance[y]==distance[x]+1&&self(self,y))){leftmatch[x]=j+1;rightmatch[j]=x;return true;}return false;});if(!ok)distance[x]=inf;return ok;};V gained=0;for(U x:donors)if(!leftmatch[x]&&aug(aug,x)){matches++;gained++;}std::cerr<<"h="<hist(h+1);for(U x=1;x=ranks[y]);hist[r-ranks[y]]++;}}else hist[1]+=degree[x];} +for(U j=0;j>31?target:args[target][e&1];assert(value==args[donor][0]||value==args[donor][1]);if(value==args[donor][0])changed++;U ru=ranks[donor],rv=ranks[value],rt=ranks[target];assert(rt>=ru&&ru>=rv);hist[h-ru]--;hist[rv]--;hist[rt-rv]--;hist[rt-ru]++;} +std::vectorterminal(h+1); +for(U x=1;x=0);sum+=r*hist[r];}assert(sum==h*R+2*loss); + +std::cout<<"{\"h\":"<=2: + types.append(1);ranks.append(s.bit_count());lookup[s]=x + else: + types.append(2);ranks.append(cover[x].bit_count());lookup[s]=x + return x + def total(xs,center=None): + xs=[x for x in xs if x] + while len(xs)>1: + xs=[add(xs[i],xs[i+1],center) if i+1=0 + Y=Counter() + for ranks in target_ranks: + prev=0 + for r in list(reversed(ranks))+[h-1]:assert r>=prev;Y[r-prev]+=1;prev=r + result={k:d[k] for k in ['h','v','R','q','c','matched','loss']} + result.update(selected_roles=len(selected),selected_rank_histogram=dict(birth), + remaining_internal_histogram=[H[r] for r in range(h+1)], + source_data_histogram={h-1:v},target_data_histogram=dict(Y), + copied_centers_already=True,phase1_operations=len(word['phase1']), + total_M_operations=len(ops),untouched_non_source_roles=len(candidates), + selection='Descending first-frame rank; intersect all incident latest target frames; retain maximal nondegenerate summand', + partial_first_transition_histogram=dict(residual),distinct_caps=len(cache), + repaired_caps=repaired, + scalar_readout='Exact rational C=J M; Boolean support is a safe superset only', + chronological_contract='Nondeferred reads at0; source V; center-closed M phase1; copied centers at0; selected partial-gauge reads in reverse selection order; remaining M; side scatter; inverse M/V atfull F') + return result,dict(base_word=Path(wordfile).name,selected=selected) diff --git a/scripts/partial_gauge/verify.py b/scripts/partial_gauge/verify.py new file mode 100644 index 0000000000..a1afefe66d --- /dev/null +++ b/scripts/partial_gauge/verify.py @@ -0,0 +1,125 @@ +# Copyright 2026 icekylinx. Apache-2.0. +# Prepared with OpenAI GPT-6 Astra and Codex assistance; see NOTICE. +"""Independent checks of the generated DAG, lifted frames and physical word.""" +from collections import Counter +from functools import lru_cache +from itertools import combinations +from .binary import load +from .lift import basis, perp, contained, nondeg + + +def verify(path, matching, ann, lift, word, selected, record): + h,v,n,q,args,core,cover,roots,kind,active,oldrank,types=load(path) + triples=list(combinations(range(h),3)); full=(1<>j&1) + else: + assert types[x]==2 + old=tuple(1<>j&1) + assert len(old)==oldrank[x] and includes(basis(old),F) + if a: + assert includes(A,tuple(ann[a])) and includes(A,tuple(ann[b])) + for j,t in enumerate(triples): + assert supports[roots[j]]==all_inputs & ~(point[t[0]]|point[t[1]]|point[t[2]]) + at=v + for a,b in combinations(range(h),2): + others=[i for i in range(h) if i not in (a,b)] + others.sort(key=lambda i:((i^1) in (a,b),i)) + for i in others: + assert supports[roots[at]]==point[a]&point[b]&~point[i];at+=1 + for a in range(h): + assert kind[at] and supports[roots[at]]==all_inputs^point[a];at+=1 + assert at==q + # Every input appears in h-3 disjoint centers: exact divisor 21. For + # overlap k, twice the signed output coefficient is 2-(3-k)+[k=0]-[k=2]. + assert h-3==21 + assert [2-(3-k)+(k==0)-(k==2) for k in range(4)]==[0,0,0,2] + for donor,use in matching['matching_arcs']: + if use>>31: + j=use&0x7fffffff;x=roots[j] + normal=full^cover[x] if kind[j] else core[x]|(full^cover[x]) + assert includes(basis([normal]),tuple(ann[donor])) + else:assert includes(tuple(ann[use//2]),tuple(ann[donor])) + R=record['R']; values=[0]*R; current=[0]*R; first=[None]*R + H=Counter();phase=set(word['phase1']); touched=set(map(int,word['sources'].values())) + for x,s in word['sources'].items(): + values[s]=supports[int(x)];current[s]=1;H[1]+=1 + last=[-1]*R + for i,(a,b,x) in enumerate(word['ops']): + assert a!=b + if i in phase: + assert all(last[s]<0 or last[s] in phase for s in (a,b)) + touched.update((a,b)) + for s in (a,b): + if first[s] is None:first[s]=x + r=h-len(ann[x]);assert r>=current[s] + H[r-current[s]]+=1;current[s]=r;last[s]=i + assert not values[a]&values[b] + values[a]|=values[b] + assert values[a]==supports[x] + for j,(x,s) in enumerate(zip(roots,word['rootroles'])): + assert values[s]==supports[x] + if kind[j]: + assert last[s]<0 or last[s] in phase + H[current[s]]+=1 + else: + H[h-1-current[s]]+=1;current[s]=h-1 + for r in current:H[h-r]+=1 + assert all(H[r]==lift['histogram'][r] for r in range(1,h+1)) + co=[0]*R;tid={sum(1<>31 else args[2*(u//2)+(u&1)] + if value==aa:p,o=o,p + else:assert value==bb + assert u not in assign;assign[u]=o + ops.append((p,o,x)) + else:p=R;R+=1;sources[x]=p + free=[u for u in uses[x] if u not in incoming] + assert free + for j,u in enumerate(free): + assert u not in assign + if j==0:assign[u]=p + else: + s=R;R+=1;assign[u]=s;ops.append((s,p,x)) + assert R==mt['R'],(R,mt['R']) + rootroles=[assign[(1<<31)|j] for j in range(q)] + prev=[-1]*R;pred=[];first=[None]*R + for i,(a,b,x) in enumerate(ops): + pred.append((prev[a],prev[b]));prev[a]=prev[b]=i + if first[a] is None:first[a]=x + if first[b] is None:first[b]=x + centerroles=[rootroles[j] for j in range(q) if kind[j]] + stack=[prev[s] for s in centerroles if prev[s]>=0];phase=set() + while stack: + i=stack.pop() + if i in phase:continue + phase.add(i);stack.extend(p for p in pred[i] if p>=0) + touched=set(sources.values()) + for i in phase:touched.update(ops[i][:2]) + triples=list(combinations(range(h),3));tid={sum(1<= 0, 'Target physical path retreats') + if increment: + yhist[increment] += 1 + current[target] = rank + for rank in current: + require(rank <= h-1, 'Target frame exceeds its output hyperplane') + if rank < h-1: + yhist[h-1-rank] += 1 + local = dict(aux=aux, data=xhist+yhist, center=Counter({h-1: len(schedule.ret)})) + require(sum(r*n for r,n in local['data'].items()) == 2*v*(h-1), + 'Physical data path rank mass mismatch') + exits = Counter(h-rank for rank in schedule.f) + require(all(0 < rank <= h for rank in exits), 'Invalid physical exit nullity') + require(sum(exits.values()) == roles, 'Missing physical exit') + return h, v, roles, local, exits + + +def reconstruct(input_path=INPUT): + record = json.loads(Path(input_path).read_text()) + folder, sources = frozen_sources(record) + ledger = json.loads((folder/'bit-ledger-result.json').read_text()) + for flag in ('complete_forward_F2', 'complete_reflected_F2', + 'reflected_frame_continuity', 'all_scalar_gates_equal_frame_keys', + 'histogram_matches_external'): + require(ledger[flag] is True, 'Pinned physical ledger lacks '+flag) + h, v, roles, local, exits = local_ranks(folder) + require((ledger['h'], ledger['roles'], ledger['formal_basis']) == (h, roles, 2*v+roles), + 'Physical ledger dimensions differ') + require({kind: encoded(hist) for kind,hist in local.items()} == ledger['rank_histograms'], + 'Reconstructed physical ranks differ from the pinned reflected ledger') + m, N = h*h, v*v + W = 2*N+2*v*roles + whole = Counter() + for hist in local.values(): + for rank, count in hist.items(): + whole[rank] += 2*v*count + # Each role's exterior I-(I-sigma) tensor Q has rank m-(h-dim sigma). + for nullity, count in exits.items(): + whole[m-nullity] += 2*v*count + # The original entrance projector is one rank-(h-1)^2 edge per bank pair. + whole[(h-1)**2] += 2*N + whole[1] += N # physical copy correction + mass = sum(rank*count for rank,count in whole.items()) + require(mass == ledger['recursive_rank'], 'Whole-projector rank mass changed') + require(all(0 < rank < m and count > 0 for rank,count in whole.items()), + 'Invalid whole-projector child') + result = dict(dimensions=[h,h], m=m, v=v, N=N, R=roles, W=W, + rank_mass=mass, deficit=W*m-mass, max_child=max(whole), + local_rank_histograms={kind: encoded(hist) for kind,hist in local.items()}, + exit_nullity_histogram=encoded(exits), + whole_projector_histogram=encoded(whole)) + for key, value in result.items(): + require(value == record[key], 'Round-six expected profile differs: '+key) + result['checks'] = dict(source_hashes_equal=True, physical_local_ranks_reconstructed=True, + physical_ledger_ranks_equal=True, whole_profile_equal=True, + full_upstream_audits_repeated=False) + result['provenance'] = dict(pr97=sources['pr97'], underlying=sources['underlying'], + source_manifest=record['source_manifest'], + source_manifest_sha256=record['source_manifest_sha256']) + result['scope'] = ('Incremental rank accounting from pinned physical chains and ledger; ' + 'scalar complete-basis replay and rational geometry remain inherited checks.') + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--input', type=Path, default=INPUT) + parser.add_argument('--output', type=Path) + args = parser.parse_args() + result = reconstruct(args.input) + text = json.dumps(result, indent=2, sort_keys=True)+'\n' + if args.output: + args.output.write_text(text) + else: + print(text, end='') + + +if __name__ == '__main__': + main() diff --git a/scripts/partial_gauge_network.py b/scripts/partial_gauge_network.py new file mode 100644 index 0000000000..53b7e06b96 --- /dev/null +++ b/scripts/partial_gauge_network.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +"""Exact deferred-word moments and partial-gauge semantic assembly. + +Copyright 2026 icekylinx. Apache-2.0. +Substantial OpenAI GPT-6 Astra and Codex assistance. +PR97 physical bit words: Zhihao Chen, based on Swapnil Jain's witness. +Semantic/bulk assembly: PR23 (Zhihao Chen) and RaD; see SOURCES.json. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from math import comb +from pathlib import Path +import json +import sys + +from certify import require +from copied_centers_network import grid_upper +from partial_swap_network import moment +from partial_gauge_bit import reconstruct +from structured_bulk_assembly import assembly, halving, js + +ROOT = Path(__file__).resolve().parents[1] +COARSE = Q(15513, 125000000) +ATOM = Q(1, 1000) +OLD = Q(384599, 10**10) +AB = (1-ATOM)*COARSE+ATOM*OLD +AC = Q(92651, 10**9) +PHASE_STOP = Q(1, 10**6) +ASSEMBLY_BIT = min(AB, (1-PHASE_STOP)*AC-Q(1, 10**10)) +KAPPA = Q(7237, 78125000) + + +def coarse_moment(p): + def log_upper(x): + power = 0 + while x >= 2: + x /= 2 + power += 1 + def small(y): + z = (y-1)/(y+1) + return 2*sum((z**(2*j+1)/(2*j+1) for j in range(24)), Q(0)) + 2*z**49/(49*(1-z*z)) + return grid_upper(power*small(Q(2))+small(x)) + total, logs = Q(0), {} + for t, n in p['child_multiplicities'].items(): + require(0 < t < p['m'] and n > 0, 'Shrinking positive bit children') + logs[t] = log_upper(Q(p['m'],t)) + u = COARSE*logs[t] + require(0 < u < 3, 'Coarse exponential enclosure') + total += n*t*grid_upper(1+u+u*u/(2*(1-u/3))) + upper = total/(p['W']*p['m']) + mass = Q(p['total_rank'],p['W']*p['m']) + require(mass < 1 and upper < 1, 'Both stopped-recurrence moments') + require(0 < OLD <= COARSE < ATOM < 1 and ATOM > AB, 'Stopped-adapter exponents') + return dict(saving=COARSE, exponent=1-COARSE, moment_upper=upper, + strict_gap=1-upper, rank_moment=mass, logarithm_upper_bounds=logs, + rounding_denominator=1 << 100, + stopped_adapter=dict(atom_exponent=ATOM, base_ordinary_saving=OLD, + effective_saving=AB, coarse_toll_exponent=1-ATOM, + coarse_toll_subordinate_gap=ATOM-COARSE)) + + +def complex_profile(row): + h, v, R, ell = (row[k] for k in ('h','v','R','loss')) + require((h,v,ell) == (24,comb(24,3),24*23), 'Complex dimensions') + require(R == row['c']+row['q']-row['matched'], 'Compatible role count') + selected = {int(r):n for r,n in row['selected_rank_histogram'].items()} + require(sum(selected.values()) == row['selected_roles'] == 6341, 'Selected partial gauges') + require(row['copied_centers_already'], 'Copied-center convention') + require(sum(row['partial_first_transition_histogram'].values()) == sum(selected.values()), 'Charged first residuals') + m, N, W = h*h, v*v, 2*v*v+2*v*R + C = Counter({m-h:2*v*(R-sum(selected.values())), (h-1)**2:2*N, 1:N}) + for r,n in selected.items(): + require(0 < r < h and n > 0, 'Nonzero shrinking exterior gauges') + C[m-h+r] += 2*v*n + for name in ('source_data_histogram','target_data_histogram'): + for r,n in row[name].items(): + C[int(r)] += 2*v*n + for r,n in enumerate(row['remaining_internal_histogram']): + if r: + C[r] += 2*v*n + C = dict(sorted((r,n) for r,n in C.items() if n)) + require(all(0 < r < m and n > 0 for r,n in C.items()), 'Shrinking complex children') + s = sum(r*n for r,n in C.items()) + require(s == W*m-N+2*v*ell, 'Complete complex rank mass') + return dict(dimensions=[h,h],m=m,N=N,W=W,L=2*v*ell,total_rank=s, + deficit=W*m-s,maxchild=max(C),child_multiplicities=C) + + +def finite_bridge(bit, phase, row, previous): + m,W,s,N = (phase[k] for k in ('m','W','total_rank','N')) + h,v,R = (row[k] for k in ('h','v','R')) + local = 4*(row['c']+v)+10*v+4*h*v+4*h*h+8*h+8+2*h + local += 8*R*v*(row['total_M_operations']+16) + G = N+2*v*local + E = 64*(W+m+G+1)**3 + charge = 2*G*W*W+8*s+4*W+4+32*m + B, r = s+E, phase['maxchild'] + C0 = 32*m*B*B + require(charge < E and 2*B*(m-r) >= s+E and 2*B+18 < C0, 'Semantic induction and charge') + dc,dp = halving(bit['m'],bit['maxchild']),halving(m,r) + wc,wp = bit['W'].bit_length(),W.bit_length() + old_bit = previous['finite_bridge']['bit'] + old = old_bit['halving_degree']*old_bit['wire_bits'] + require(old == 252, 'Inherited ordinary leaf row stock') + coeff,degree = wc*dc+old+wp*dp,40000 + require(Q(degree) > Q(coeff*51,25), 'Sufficient product row stock') + return dict(bit_coarse=dict(m=bit['m'],W=bit['W'],maxchild=bit['maxchild'], + halving_degree=dc,wire_bits=wc),ordinary_leaf_row_degree=old, + complex=dict(m=m,W=W,s=s,maxchild=r,halving_degree=dp,wire_bits=wp, + scalar_group_upper=G,local_group_upper=local,coefficient_bound=h+4, + coefficient_denominator_divides=2*(h-3)), + semantic=dict(E=E,literal_charge=charge,strict_literal_gap=E-charge, + B=B,C0=C0,C1=1,induction_gap=2*B*(m-r)-s-E,fixed_odd_divisor=h-3, + exact_grid='One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding'), + rows=dict(coefficient=coeff,degree=degree,suffix_slope=4*degree, + degree_gap=Q(degree)-Q(coeff*51,25), + contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse')) + + +def certificate(): + require(not sys.flags.optimize, 'Run without -O') + def read(name): + return json.loads((ROOT/'certificates'/name).read_text()) + raw = reconstruct() + row = read('partial-gauge-complex-input.json') + expected = read('partial-gauge-input.json') + previous = read('copied-centers-network.json') + require(Q(previous['bit']['saving']) == OLD, 'Inherited leaf saving') + C = {int(r):n for r,n in raw['whole_projector_histogram'].items()} + bit = dict(dimensions=raw['dimensions'],m=raw['m'],W=raw['W'],N=raw['N'], + total_rank=raw['rank_mass'],deficit=raw['deficit'],maxchild=max(C),child_multiplicities=C) + require(sum(r*n for r,n in C.items()) == bit['total_rank'], 'Bit rank mass') + require(bit['W']*bit['m']-bit['total_rank'] == bit['deficit'], 'Bit deficit') + phase = complex_profile(row) + bm = coarse_moment(bit) + cm = moment(phase['m'],phase['W'],phase['child_multiplicities'],AC,True) + require(bm['strict_gap'] == Q(expected['bit_moment_gap']), 'Saved coarse moment') + require(cm['strict_gap'] == Q(expected['complex_moment_gap']), 'Saved complex moment') + require(js(phase['child_multiplicities']) == expected['complex_children'], 'Saved complex children') + bridge = finite_bridge(bit,phase,row,previous) + assembled = assembly(ASSEMBLY_BIT,AC,bridge,KAPPA,beta=PHASE_STOP) + assembled['parameters']['actual_bit_saving'] = AB + require(ASSEMBLY_BIT <= AB, 'Supported assembly movement saving') + require(js(bridge) == expected['finite_bridge'], 'Saved finite bridge') + require(js(assembled) == expected['assembly'], 'Saved exact assembly') + require(len(assembled['strict_constraints']) == 47 and len(assembled['margins']) == 7, 'Complete strict constraints') + sources = sorted(p for p in (ROOT/'certificates').glob('partial-gauge-*.json') + if p.name != 'partial-gauge-network.json') + sources += sorted((ROOT/'scripts').glob('partial_gauge*.py')) + sources += sorted(p for p in (ROOT/'scripts/partial_gauge').rglob('*') + if p.is_file() and '__pycache__' not in p.parts) + sources += sorted((ROOT/'notes').glob('partial-gauge-*.tex')) + sources += sorted(p for p in (ROOT/'references/partial-gauge').rglob('*') + if p.is_file() and '__pycache__' not in p.parts) + sources += [ROOT/p for p in ('scripts/copied_centers_network.py', + 'scripts/partial_swap_network.py','scripts/structured_bulk_assembly.py', + 'certificates/copied-centers-network.json','certificates/stopped-product-network.json', + 'scripts/paired_triple_circuit.py','scripts/paired_exclusion_circuit.py')] + return dict(status='Conditional partial-gauge multiplication witness',kappa=KAPPA, + bit=dict(counts=bit,**bm),complex=dict(counts=phase,**cm), + finite_bridge=bridge,assembly=assembled, + predecessor_commit='948ce1510df750f4c18b96bdaef436a86f8bf834', + source_sha256={str(p.relative_to(ROOT)):sha256(p.read_bytes()).hexdigest() for p in sources}, + scope='Exact moments, stopped bit saving and semantic assembly. Finite producer/frame checks ' + 'are separate; common-basis, fixed-tape and analytic transfer remain written proof dependencies.') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output',type=Path,default=ROOT/'certificates/partial-gauge-network.json') + args = parser.parse_args() + args.output.write_text(json.dumps(js(certificate()),indent=2,sort_keys=True)+'\n') + print('PASS kappa=7237/78125000 = 9.26336e-5; both moments, stopped saving, p^40000 stock, 47 strict constraints') + + +if __name__ == '__main__': + main() diff --git a/scripts/partial_gauge_producer.py b/scripts/partial_gauge_producer.py new file mode 100644 index 0000000000..2d91d92b8e --- /dev/null +++ b/scripts/partial_gauge_producer.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Regenerate and verify the selected h=24 partial-gauge complex producer. + +Standard-library Python and C++17; generated DAGs and words are temporary. +Copyright 2026 icekylinx, Apache-2.0. Adapted from the credited round-six handoff. +""" +import argparse +import json +import os +from pathlib import Path +import shlex +import subprocess +import sys +import tempfile +from partial_gauge.scalar import build +from partial_gauge.lift import run as lift_run +from partial_gauge.word import run as word_run +from partial_gauge.select import run as select_run +from partial_gauge.verify import verify + +ROOT=Path(__file__).resolve().parents[1] + + +def regenerate(work, expected, compiler): + if sys.flags.optimize:raise ValueError('Run without -O; finite assertions must remain enabled') + def stage(message):print(message,file=sys.stderr,flush=True) + def save(name,data): + path=work/name;path.write_text(json.dumps(data,separators=(',',':'))+'\n');return path + stage('Building the actual interval/cube scalar DAG') + scalar=build(24,base=2,central_disjoint=24,output_prefix='complex_cube',output_dir=work) + dag=work/'complex_cube_24.bin';matcher=work/'matcher' + subprocess.run([*shlex.split(compiler),'-O3','-std=c++17',str(ROOT/'scripts/partial_gauge/match.cpp'),'-o',str(matcher)],check=True) + stage('Constructing compatible carrier matching') + matching=json.loads(subprocess.check_output([str(matcher),str(dag),str(dag.with_suffix('.labels'))],text=True)) + matchfile=save('matching.json',matching) + stage('Lifting exact binary frames backward through dependencies and carriers') + lifted,ann=lift_run(dag,matchfile);liftfile=save('lifted.json',lifted);annfile=save('annihilators.json',ann) + stage('Constructing physical M and its retained-center dependency closure') + word=word_run(dag,matchfile,annfile,liftfile);wordfile=save('word.json',word) + stage('Selecting partial source gauges with reverse readouts') + result,selection=select_run(dag,annfile,liftfile,wordfile) + result=json.loads(json.dumps(result)) + assert result==expected, 'Regenerated selected certificate differs' + save('selection.json',selection) + stage('Checking scalar coefficients, actual frames, physical word and readout chains') + checks=verify(dag,matching,ann,lifted,word,selection['selected'],result) + return dict(regenerated_from_source=True,certificate_equal=True,selected=result,checks=checks) + + +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--certificate',type=Path,default=ROOT/'certificates/partial-gauge-complex-input.json') + p.add_argument('--work-dir',type=Path) + p.add_argument('--output',type=Path) + p.add_argument('--cxx',default=os.environ.get('CXX','c++')) + a=p.parse_args();expected=json.loads(a.certificate.read_text()) + if a.work_dir: + a.work_dir.mkdir(parents=True,exist_ok=True);result=regenerate(a.work_dir.resolve(),expected,a.cxx) + else: + with tempfile.TemporaryDirectory(prefix='partial-gauge-') as directory: + result=regenerate(Path(directory),expected,a.cxx) + encoded=json.dumps(result,indent=2)+'\n' + if a.output:a.output.write_text(encoded) + else:print(encoded,end='') + + +if __name__=='__main__':main() diff --git a/scripts/stopped_product/README.md b/scripts/stopped_product/README.md new file mode 100644 index 0000000000..6c18be051f --- /dev/null +++ b/scripts/stopped_product/README.md @@ -0,0 +1,36 @@ +# Selected rational-center producer + +Run from the repository root: + +```sh +python3 scripts/stopped_product_producer.py --output /tmp/stopped-product-producers.json +``` + +Only the new aligned complex producer at h=24 is rebuilt. It retains all +24 disjoint-point sums and decodes the total by exact division by21. The +pair-star input order is aligned with global pairs. Its generator adapts +`structured_bulk.complex`, preserving exact support, output orthogonality, +binary frame nesting and nondegeneracy checks. Rational decoder and scatter +coefficients are checked with `Fraction`; their only odd denominator is21. +The unchanged deterministic matcher compares every count and histogram +entry against `stopped-product-complex-input.json`. + +The h23 bit record is compared with the preceding validated copied-center +input. No old bit DAG, matching, or corner is regenerated. Both copied-center +histogram transformations reuse the established exact rank-mass checker. + +All DAGs, labels and the compiled matcher are temporary by default; +`--work-dir` retains them. Python assertions must be enabled. Standard-library +Python and a C++17 compiler suffice. No binary archive is an input. + +The odd-grid extension is a written recursive invariant, not a claim proved +by the finite scalar tests. With dyadic root inputs, K=G(D+1) supplies enough +odd-divisor reserve along the active chain. A completed child preserves its +incoming odd valuation; it does not generally make rational child inputs +dyadic. Only the completed outer dyadic operator restores the original +dyadic grid. No child return is rounded. + +Copyright 2026 icekylinx, Apache-2.0. New selected alignment, rational centers +and integration were prepared with OpenAI GPT-6 Astra/Codex assistance. +Underlying paired producers and deterministic carrier matching retain the +previous contributors' attribution in `NOTICE` and `SOURCES.json`. diff --git a/scripts/stopped_product/__init__.py b/scripts/stopped_product/__init__.py new file mode 100644 index 0000000000..f7a6e90661 --- /dev/null +++ b/scripts/stopped_product/__init__.py @@ -0,0 +1 @@ +"""Selected stopped-product inputs and rational producer; icekylinx, 2026.""" diff --git a/scripts/stopped_product/complex.py b/scripts/stopped_product/complex.py new file mode 100644 index 0000000000..ef1af25507 --- /dev/null +++ b/scripts/stopped_product/complex.py @@ -0,0 +1,228 @@ +"""Selected aligned rational-center producer, h=24 with all centers disjoint. + +Copyright 2026 icekylinx, Apache-2.0. AI-assisted adaptation of the research +round-five handoff, using the credited retained PairedTriple circuit; see NOTICE. +Adapted from structured_bulk.complex: align pair-star inputs and permit the +fixed rational divisor21; retain all exact support/frame/scalar checks. + +Builds a concrete scalar addition DAG, its nondegenerate binary frames, and +the unmixed carrier histogram. No historical audit suite is invoked. +""" +import json, struct, array +from itertools import combinations +from pathlib import Path +from partial_swap.binary import write_array +from paired_triple_circuit import PairedTriple + +def build(h, prefix, central_disjoint, base=2): + assert (h, central_disjoint, base) == (24,24,2) + d=central_disjoint + assert 0= 2: + x /= 2 + power += 1 + def small(y): + z = (y-1)/(y+1) + return 2*sum((z**(2*j+1)/(2*j+1) for j in range(32)),Q(0)) + 2*z**65/(65*(1-z*z)) + return up(power*small(Q(2))+small(x)) + + +def exp_upper(u): + require(0 <= u < 3,'Exponential enclosure') + return up(1+u+u*u/(2*(1-u/3))) + + +def bit_certificate(row): + physical = reconstruct() + h,v,R = (row[k] for k in ('h','v','R')) + require((h,v,R) == (23,comb(23,3),28866),'Bit local dimensions') + for key in ('v','R','local_rank_histograms','exit_nullity_histogram'): + require(row[key] == physical[key],'Inherited physical bit ledger: '+key) + ell = row['center_loss'] + require(ell == h*(h-1),'Copied-center loss') + m,W,H = 3*h-2,2*v+3*R,Counter() + for part in row['local_rank_histograms'].values(): + for r,n in part.items(): + H[int(r)] += 3*n + for nullity,n in row['exit_nullity_histogram'].items(): + H[m-int(nullity)] += 3*n + require(all(0 < r < m and n > 0 for r,n in H.items()),'Proper bit children') + mass = sum(r*n for r,n in H.items()) + require(W*m-mass == 2*v-3*ell,'Three-stage bit telescoping') + logs = {r:log_upper(Q(m,r)) for r in H} + good = sum(Q(r*n,W*m)*exp_upper(COARSE*logs[r]) for r,n in H.items()) + fallback,edges = 32*m*m,sum(H.values()) + extra = BAD*Q(fallback*edges,W*m)*exp_upper(COARSE*log_upper(Q(m))) + rank_upper = Q(mass)+BAD*fallback*edges + require(good+extra < 1 and rank_upper < W*m,'Both contaminated moments') + require(Q(2*m**3,2**80) < BAD,'Fixed-prime bad-class fraction') + require(ATOM > AB and ATOM < 1-AB,'Subordinate adapter and row-borrowing tolls') + return dict(m=m,local_dimension=h,roles_per_vertex=W, + ideal_rank_mass_per_vertex=mass,ideal_deficit=2*v-3*ell, + ideal_child_multiplicities=dict(sorted(H.items())),maxchild=max(H), + coarse_saving=COARSE,effective_saving=AB,atom_exponent=ATOM, + ordinary_leaf_saving=OLD,bad_fraction=BAD, + fallback_children_per_edge=fallback,edge_count_per_vertex=edges, + good_moment_upper=good,added_bad_moment_upper=extra, + strict_gap=1-good-extra,rank_mass_upper_per_vertex=rank_upper, + log_upper_bounds=logs,rounding_denominator=GRID, + row_stock='O(w log e) internally borrowed radix-q digits, restored at the outer boundary', + prime_choice='Fixed odd q > 2^80 avoiding the finite rational denominator and rank-witness primes') + + +def complex_certificate(row): + h,v,R,ell = (row[k] for k in ('h','v','R','loss')) + require((h,v,R,ell) == (24,comb(24,3),28705,552),'Complex local dimensions') + require(R == row['c']+row['q']-row['matched'],'Compatible roles') + selected = {int(r):n for r,n in row['selected_rank_histogram'].items()} + require(sum(selected.values()) == row['selected_roles'] == 4599,'Partial gauges') + m,w,C = 3*h-2,2*v+3*R,Counter() + C[m-h] += 3*(R-sum(selected.values())) + for r,n in selected.items(): + C[m-h+r] += 3*n + for key in ('source_data_histogram','target_data_histogram'): + for r,n in row[key].items(): + C[int(r)] += 3*n + for r,n in enumerate(row['remaining_internal_histogram']): + if r: + C[r] += 3*n + C = dict(sorted((r,n) for r,n in C.items() if r and n)) + require(all(0 < r < m and n > 0 for r,n in C.items()),'Proper complex children') + rank = sum(r*n for r,n in C.items()) + require(w*m-rank == 2*v-3*ell,'Three-stage complex telescoping') + n = m//2 + vertices = 2**(m-1+(n-1)**2)*prod(2**(2*i)-1 for i in range(1,n)) + exact = moment(m,w,C,AC,True) + return dict(m=m,N=vertices*v,W=vertices*w,total_rank=vertices*rank, + deficit=vertices*(w*m-rank),vertices_per_stage=vertices,maxchild=max(C), + group_order_bits=vertices.bit_length(),per_vertex=dict(W=w,rank=rank, + deficit=w*m-rank,child_multiplicities=C),**exact) + + +def finite_bridge(c,row): + m,W,s,N,V = (c[k] for k in ('m','W','total_rank','N','vertices_per_stage')) + h,v,R = (row[k] for k in ('h','v','R')) + local = 4*(row['c']+v)+10*v+4*h*v+4*h*h+8*h+8+2*h + local += 8*R*v*(row['total_M_operations']+16) + router = 64*(m+1)**3*W**2 + G = N+3*V*local+router + E = 64*(W+m+G+1)**3 + charge = 2*G*W*W+8*s+4*W+4+32*m + B,C0,r = s+E,32*m*(s+E)**2,c['maxchild'] + require(charge < E and 2*B*(m-r) >= s+E and 2*B+18 < C0,'Finite semantic charge') + dp,wp = halving(m,r),W.bit_length() + old_coarse,old_atom = 9909,252 + coefficient,degree = dp*wp+old_coarse+old_atom,160000 + require(Q(degree) > Q(51*coefficient,25),'External product row reserve') + return dict(bit_uniform=dict(coarse_saving=COARSE,atom_beta=ATOM, + old_atom_saving=OLD,ordinary_saving=AB, + selector_stock='O(w log e) internal borrowed rows; restored by the uniform old-supplier wrapper', + external_stock='No q-adic group-size factor is inserted into the external polynomial row stock'), + conservative_old_coarse_row_reserve=old_coarse,ordinary_leaf_row_degree=old_atom, + complex=dict(m=m,W=W,s=s,N=N,maxchild=r,invocations_per_stage=V,stages=3, + halving_degree=dp,wire_bits=wp,scalar_group_upper=G,local_group_upper=local, + finite_group_router_upper=router,coefficient_bound=h+4, + coefficient_denominator_divides=2*(h-3)), + semantic=dict(E=E,literal_charge=charge,strict_literal_gap=E-charge, + B=B,C0=C0,C1=1,induction_gap=2*B*(m-r)-s-E,fixed_odd_divisor=h-3, + exact_grid='One common dyadic grid times 21^(-K), K=G*(D_complex+1); no child rounding'), + rows=dict(coefficient=coefficient,complex_coefficient=dp*wp,degree=degree, + suffix_slope=4*degree,degree_gap=Q(degree)-Q(51*coefficient,25), + contract='Finite complex group role stock plus conservative fixed legacy bit reserves; q-adic selectors borrowed internally and restored; one prefix and one padding; sequential reuse')) + + +def certificate(): + require(not sys.flags.optimize,'Run without -O') + def read(name): + return json.loads((ROOT/'certificates'/name).read_text()) + expected = read('three-stage-cover-input.json') + bit = bit_certificate(read('three-stage-cover-bit-input.json')) + row = read('three-stage-cover-complex-input.json') + phase = complex_certificate(row) + bridge = finite_bridge(phase,row) + previous = read('copied-centers-network.json') + require(Q(previous['bit']['saving']) == OLD,'Retained ordinary leaf') + result = assembly(ASSEMBLY_BIT,AC,bridge,KAPPA,beta=PHASE_STOP) + result['parameters']['actual_bit_saving'] = AB + require(ASSEMBLY_BIT <= AB,'Supported assembly bit saving') + for actual,key in ((bit['strict_gap'],'bit_moment_gap'),(phase['strict_gap'],'complex_moment_gap'), + (result['minimum_margin'],'assembly_minimum'),(result['absorption_gap'],'absorption_gap')): + require(actual == Q(expected[key]),'Saved exact '+key) + require(js(bit['ideal_child_multiplicities']) == expected['bit_child_multiplicities'],'Saved bit children') + require(js(phase['per_vertex']['child_multiplicities']) == expected['complex_child_multiplicities'],'Saved complex children') + require(phase['vertices_per_stage'] == expected['complex_group_order'],'Finite group order') + require(bridge['rows']['degree'] == expected['row_degree'] and bridge['rows']['coefficient'] == expected['row_coefficient'],'Saved row bound') + require(KAPPA == Q(expected['kappa']) and len(result['strict_constraints']) == 47 and len(result['margins']) == 7,'Complete assembly') + sources = sorted(p for p in (ROOT/'certificates').glob('three-stage-cover-*.json') + if p.name != 'three-stage-cover-network.json') + sources += sorted((ROOT/'scripts').glob('three_stage_cover*.py')) + sources += sorted(p for folder in ('scripts/three_stage_cover','references/three-stage-cover') + for p in (ROOT/folder).rglob('*') if p.is_file() and '__pycache__' not in p.parts) + sources += sorted((ROOT/'notes').glob('three-stage-cover-*.tex'))+[ROOT/'notes/general-clifford-frames.tex'] + sources += [ROOT/p for p in ('scripts/partial_gauge_bit.py','certificates/partial-gauge-bit-input.json', + 'references/partial-gauge/pr97/SOURCE.json','scripts/partial_swap_network.py', + 'scripts/structured_bulk_assembly.py','certificates/copied-centers-network.json', + 'certificates/stopped-product-network.json','certificates/partial-gauge-network.json', + 'scripts/partial_gauge/binary.py','scripts/partial_gauge/lift.py','scripts/partial_gauge/word.py', + 'scripts/partial_gauge/match.cpp')] + return dict(status='Conditional three-stage cover multiplication witness',kappa=KAPPA, + bit=bit,complex=phase,finite_bridge=bridge,assembly=result, + predecessor_commit='cf60442983c153a3a0f5272ea4713f99eba13c86', + source_sha256={str(p.relative_to(ROOT)):sha256(p.read_bytes()).hexdigest() for p in sources}, + scope='Exact local inventories, strict moments, contaminated fallback charge and semantic assembly. ' + 'Local finite reconstruction is checked separately; group geometry, uniform weighted routing, ' + 'borrowed rows and inherited analytic/tape contracts are written proof dependencies.') + + +def main(): + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--output',type=Path,default=ROOT/'certificates/three-stage-cover-network.json') + args = p.parse_args() + args.output.write_text(json.dumps(js(certificate()),indent=2,sort_keys=True)+'\n') + print('PASS kappa=3146011/10000000000 = 3.146011e-4; both moments, rare-class fallback, finite router, 47 strict constraints') + + +if __name__ == '__main__': + main() diff --git a/scripts/three_stage_cover_producer.py b/scripts/three_stage_cover_producer.py new file mode 100644 index 0000000000..9e7a21a758 --- /dev/null +++ b/scripts/three_stage_cover_producer.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Regenerate and verify the selected pinned PR117 generalized-subspace complex producer. + +Standard-library Python and C++17; generated DAGs and words are temporary. +Copyright 2026 icekylinx, Apache-2.0. Adapted from the credited round-six handoff. +""" +import argparse +import json +import os +from pathlib import Path +import shlex +import subprocess +import sys +import tempfile +from importlib.util import spec_from_file_location, module_from_spec +import hashlib +from three_stage_cover.lift import run as lift_run +from partial_gauge.word import run as word_run +from three_stage_cover.select import run as select_run +from three_stage_cover.verify import verify + +ROOT=Path(__file__).resolve().parents[1] + + +def regenerate(work, expected, compiler): + if sys.flags.optimize:raise ValueError('Run without -O; finite assertions must remain enabled') + def stage(message):print(message,file=sys.stderr,flush=True) + def save(name,data): + path=work/name;path.write_text(json.dumps(data,separators=(',',':'))+'\n');return path + stage('Replaying the pinned PR117 scalar DAG') + reference=ROOT/'references/three-stage-cover/pr117' + source=json.loads((reference/'SOURCE.json').read_text()) + assert source['commit']=='cbb05ce504d571546d9b7794c186a613c659c3bf' + for name,digest in source['files'].items(): + assert hashlib.sha256((reference/name).read_bytes()).hexdigest()==digest, 'Source binding differs: '+name + witness=reference/'dag.json.gz' + assert hashlib.sha256(witness.read_bytes()).hexdigest()=='3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b' + spec=spec_from_file_location('pr117_replayed',reference/'replayed.py') + module=module_from_spec(spec);spec.loader.exec_module(module) + scalar=module.build(witness,work/'selected') + dag=work/'selected.bin';matcher=work/'matcher' + subprocess.run([*shlex.split(compiler),'-O3','-std=c++17',str(ROOT/'scripts/partial_gauge/match.cpp'),'-o',str(matcher)],check=True) + stage('Constructing compatible carrier matching') + matching=json.loads(subprocess.check_output([str(matcher),str(dag),str(dag.with_suffix('.labels'))],text=True)) + matchfile=save('matching.json',matching) + stage('Lifting exact binary frames backward through dependencies and carriers') + lifted,ann=lift_run(dag,matchfile);liftfile=save('lifted.json',lifted);annfile=save('annihilators.json',ann) + stage('Constructing physical M and its retained-center dependency closure') + word=word_run(dag,matchfile,annfile,liftfile);wordfile=save('word.json',word) + stage('Selecting partial source gauges with reverse readouts') + result,selection=select_run(dag,annfile,liftfile,wordfile) + result=json.loads(json.dumps(result)) + assert result==expected, 'Regenerated selected certificate differs' + save('selection.json',selection) + stage('Checking scalar coefficients, actual frames, physical word and readout chains') + checks=verify(dag,matching,ann,lifted,word,selection['selected'],result) + return dict(source_pin_verified=True,regenerated_from_source=True,certificate_equal=True,selected=result,checks=checks) + + +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--certificate',type=Path,default=ROOT/'certificates/three-stage-cover-complex-input.json') + p.add_argument('--work-dir',type=Path) + p.add_argument('--output',type=Path) + p.add_argument('--cxx',default=os.environ.get('CXX','c++')) + a=p.parse_args();expected=json.loads(a.certificate.read_text()) + if a.work_dir: + a.work_dir.mkdir(parents=True,exist_ok=True);result=regenerate(a.work_dir.resolve(),expected,a.cxx) + else: + with tempfile.TemporaryDirectory(prefix='three-stage-cover-') as directory: + result=regenerate(Path(directory),expected,a.cxx) + encoded=json.dumps(result,indent=2)+'\n' + if a.output:a.output.write_text(encoded) + else:print(encoded,end='') + + +if __name__=='__main__':main()