diff --git a/research/three-swap-cap2-physical-ceiling/.gitattributes b/research/three-swap-cap2-physical-ceiling/.gitattributes new file mode 100644 index 0000000000..b4b48a4e41 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/.gitattributes @@ -0,0 +1,2 @@ +# Preserve immutable scientific evidence bytes, including CRLF. +** -text diff --git a/research/three-swap-cap2-physical-ceiling/EVIDENCE.json b/research/three-swap-cap2-physical-ceiling/EVIDENCE.json new file mode 100644 index 0000000000..1058ea3fe0 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/EVIDENCE.json @@ -0,0 +1,56 @@ +{ + "schema": "cap2-physical-ceiling-retained-bytes/v1", + "files": { + "evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md": "f02e31783fac029ba63cc4b1175d6e6b89f1a064cda2307024c47de5b44ff2c1", + "evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json": "da9c41102d4801b06db91cf5ab8fc24c1df103400bbdbb4c55a5792284ff7540", + "evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b", + "evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b", + "evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "evidence/outputs/new-approach-ceilings-20261023/FILES.json": "2bd64afd859fb006f1f592844003b2ca364f2846efb1415fc803c22904d56633", + "evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md": "5f8bc6e9518672eff5de557bc8eca9607069b4d081e498a6ef4749bd03bc70bc", + "evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md": "1be3bbe4d4969ab29f221081eb9a880022d07bb3899cd1ffc236b4f217e80af2", + "evidence/outputs/new-approach-ceilings-20261023/REPORT.md": "59b259d876b8eebcaf0a20e20144bbd6b994bc795026fefa0bf2be25cf1f4fcc", + "evidence/outputs/new-approach-ceilings-20261023/SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "evidence/outputs/new-approach-ceilings-20261023/check_screen.py": "de8f2ac5ea2105ef8dd50c0b4755f3eb89ba4ab76977f018b2d1881a8845afd0", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-TEMPLATE-CLOSURE.md": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__HIGHER-MOMENT.md": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedArithmetic.lean": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "evidence/outputs/new-approach-ceilings-20261023/frozen/notes__three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "evidence/outputs/new-approach-ceilings-20261023/frozen/research__gl2-swap-cut-corollary__README.md": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9", + "evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054", + "evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md": "d512aaffbf0fbe53918de2850ae725b9375e1f060018bc9759def4be55572999", + "evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319", + "evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319", + "evidence/outputs/new-approach-verification-20261023/FREEZE.json": "22deada00ef988bdc99b7fd01480fc86136111a8483513d00ce2ae0eea711975", + "evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py": "4f372d4dba50e8fa96820f8287241d6accaa44149229a5544387dacd96b3ec8e", + "evidence/physical-interface/FILES.json": "d8e8fb46b628664881946502020ccf7a93f97c07cff77bc1a51f3ed35ac1cc5c", + "evidence/physical-interface/REPORT.md": "71bb4f5ab05bf4da2887ccdcb32ff1ee00994347591f9954d22fca515cb86bd2", + "evidence/physical-interface/SOURCES.json": "446fff2e65151972205503e7e713da6e47b89d62be59a4b51937fea9fa2cafdd", + "evidence/physical-interface/source/certificates__frontier4470__CLAIM.json": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232", + "evidence/physical-interface/source/certificates__selected-result.json": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375", + "evidence/physical-interface/source/notes__batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "evidence/physical-interface/source/notes__batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "evidence/physical-interface/source/notes__general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "evidence/physical-interface/source/notes__three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "evidence/physical-interface/source/research__coxeter-root-tariff__PROOF.md": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8", + "evidence/physical-interface/source/research__gl2-swap-cut-corollary__README.md": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9", + "evidence/physical-interface/source/research__kappa-rebuild__bit__README.md": "351a9111292f3d406f94fd3c0f78867c8f421887f5073c0fb8fcef8a1377b02e", + "evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "evidence/physical-interface/source/research__kappa-round6-compiler-tightening-20261022__README.md": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba", + "evidence/physical-interface/source/research__mixed-gl2-block-tariff__README.md": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0", + "evidence/physical-interface/source/research__rank2-swap-batching__README.md": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054", + "evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json": "0026e1286fb9377ed5862fe91c109f34be038d2058fb50cba951f6cd362108d6", + "evidence/physical-interface/source/research__rank2-swap-batching__TASK.json": "fefb528b755540d19b5f65ac13bed14689461d0d2741441e84d88cc068c0c3e7", + "evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" + } +} diff --git a/research/three-swap-cap2-physical-ceiling/README.md b/research/three-swap-cap2-physical-ceiling/README.md new file mode 100644 index 0000000000..fa88e42a19 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/README.md @@ -0,0 +1,200 @@ +# Three-SWAP cap-two physical interface and direct-comparator ceiling + +**Source-pinned research package.** The physical interpretation of Nick Petalas's +[#5083](https://github.com/CrocSwap/integer-mult-bounds/pull/5083) needs a stronger +price gate than its sound restricted formal-word comparison. With reversed BIT +generators the target is an ordinary swap, and the retained source supplies a +direct implementation. Beating that explicit recipe requires + +``` +B < (2F + 6Q - Delta)/4, Delta = wNew - wDirect. +``` + +This is a scoped necessary comparison against a constructive upper recipe. +The recipe is not asserted optimal. No actual cap-two supplier, bound eligible +caller, changed P/T inventory, universal physical obstruction or new κ follows. +The selected record remains unchanged. The retained independent review checks +the exact arithmetic and orientation; it does not certify a physical supplier. + +## Result and physical boundary + +The formal source has owner-rank profile `(2,2,1,2,2)`, price `c1+4c2`, and +comparator `3c1+3c2`. Its formal saving `2c1-c2` is credited to Nick Petalas. +That theorem and its formal-word checker are not duplicated or rerun here. +Ross Richardson's GL2(F2)/S3 bridge identifies `a=(12), b=(23), s=(13)`; +David Arias's rank-priced theorem and the retained group/cut lineage remain +predecessor work. + +The missing attaining ABI is + +``` +Cap2(g,{i,j}): (u0,u1,u2,dirty...) + -> (rho_f(g)u_i, rho_f(g)u_j, all other original fields unchanged), g=a or b. +``` + +Each owner is an arbitrary independent payload function on the same complete +address range. Two original inputs require two independent transformed outputs; +the unselected active owner, arbitrary dirty owners, untouched rows and every +spectator must each be restored. A sum of owners, a zero input or a discarded +owner does not meet this ABI. Entry/exit charts, atom order, orientation, +weights, width lifting, buffers, copies, reset and all outputs must be explicit. +Scalar owner rank, address width, logical volume, column multiplicity and native +recursive-child rank are separate dimensions. The existing BIT supplier's +width-`rf` call acts on one role at volume `V/W`; putting two owners in ROW +values increases volume to `2V/W`. It does not establish the cap-two discount. + +For unweighted reversed generators, write `C=C_f`, `C^2=I`. Source convention +reverses atom positions, without reversing digits inside an atom. Then + +``` +(x,y,z) --F12--> (Cy,Cx,z) --F23--> (Cy,Cz,x) --F12--> (z,y,x). +``` + +Thus `aba` produces ordinary `J13` and restores the middle chunk. The source's +`J_A=R_tail F_A R_tail` recipe gives one width-`f` reversed call and two +width-`floor(f/2)` calls, all on the same complete logical volume. Put `F,Q` +for their complete prices, `B` for the complete width-`f` cap-two transaction, +and `wNew,wDirect` for costs outside these complete calls only. The candidate +cost is `F+4B+wNew`; the available direct upper recipe costs `3F+6Q+wDirect`. +Their strict comparison gives the displayed threshold. In-call work must not +be charged again in `Delta`; unknown outside work is unknown. + +Uniform prices must hold for both labels and every selected owner pair. +Otherwise use the actual sum, initially `F_a+2B_a+2B_b`, and any further +pair-dependent terms. The unweighted identity does not identify different +ancestor-dependent weight arrays. Weighted jobs require matched actual weights, +reversed pairing, orientation, precision and complete returned inventory. +For raw-F targets the word has the wrong endpoint: the particular wrapper +adds six half-width calls and loses against three direct F calls when `B>=F`. +A proved caller layout absorbing reversals would be a changed premise. +For ordinary-J generators the direct three-target competitor is already `3J`. + +## Exact conditional tariff screen + +Under the separately declared hypothetical same-volume model + +``` +F=K*f^(1-C), Q=K*floor(f/2)^(1-C), B=2^(1-C)*F, +K>0, H_0=0, Delta=0, 0<=C<=17/5000, +``` + +the nominal cap-two price loses. The exact integer inequality +`399^5000 < 2^4983 * 200^5000` proves `2^(1-C)>399/200`. +The necessary price satisfies `B/F<333/266`, while the hypothetical nominal +price is `B/F>399/200`; the normalized recursive disadvantage exceeds +`19767/6650`. Even widths attain the underlying bound; odd floors strengthen +it, and width one is covered with `Q=0`. The checker includes sign reversal +outside the screened regime. These conclusions reject this tariff/comparator +combination, not every cap-two implementation. A sufficiently favorable actual +outside-cost difference or different complete B could change the full decision. + +## Evidence, provenance and reproduction + +The scientific packets under `evidence/` are exact retained bytes: + +- [Physical ABI and feasibility report](evidence/physical-interface/REPORT.md), + its complete source snapshots and original manifests. +- [Direct-comparator derivation](evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md), + exact checker/receipts, candidate interface and baseline obligation ledger, + with all 16 scientific snapshots. +- [Independent direct-comparator review](evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md), + unchanged direct-only checker and both frozen direct receipts. + +`EVIDENCE.json` binds all 51 retained files. Original reports and proposed drafts +retain historical local status and worker names; they are evidence of that +checkpoint, not current publication text or instructions. The full original +`FREEZE.json` is retained with SHA256 +`22deada00ef988bdc99b7fd01480fc86136111a8483513d00ce2ae0eea711975`. +Its unrelated centre-p2 entries are not vendored or replayed in this package. +The direct-only checker authenticates only this package's direct source packet. + +The originating catalogue card `bit-new-register-model` and selected record +remain pinned to canonical main `81e9bd69e4a5b00ba9c713a1620e36d576d5522e`. +The scope is explicitly **changed** to a physical ABI/orientation/price audit. +Root supplied the bounded overlap checkpoint and owns the final live/publication +check; this package does not claim a complete current board survey or novelty. +It complements #5083 instead of claiming its formal construction again. + +The original #5083 source head +`d2b3f35275cab6fbf18bee40e3fb411496732e54` was not an ancestor of that canonical +base. Provenance-only merge `ea40685a28ebf1489f74e91e39b143930dbfee53` uses +`git merge -s ours --no-ff` to retain that exact history, with an unchanged tree. +The separate arithmetic/source head +`20bb93cd990d2ff683e4d0fc56b87a42cd5d3296` was already ancestral. +`SOURCES.json` keeps original paths and original head pins as provenance, and +pins every retained live input at its same path in ancestor commit +`a84a22d3f6e0ce75a9e433c6438f01cf25ed384c`. No silent source repin or scientific +rewrite is used. Package `.gitattributes` disables text conversion to preserve +scientific bytes, including CRLF. + +Standard-library Python 3.12; run either from the repository root: + +```sh +python3 -I -W error -B research/three-swap-cap2-physical-ceiling/verify.py +python3 -I -O -W error -B research/three-swap-cap2-physical-ceiling/verify.py +python3 scripts/research_package.py --package research/three-swap-cap2-physical-ceiling +``` + +Both direct commands print `PASS_CAP2_PHYSICAL_CEILING_PACKAGE` in about two +seconds each locally, with a 180-second registered cap each. The adapter copies +unchanged scientific code and packets into a private temporary layout matching +their original relative paths. It captures stdout, compares the author result +and independent generated direct receipt byte for byte with frozen receipts, +checks all original manifests and retained freeze entries, and rejects a real +corruption of a frozen source in both unchanged checkers. It verifies package +bytes before and after. Scratch results are removed. No Git, network, compiler, +Lean, native execution or third-party library is needed for direct replay. + +The retained author controls cover 40 exact rational factor/sign cases, +64 floor cases, five complete-tariff scenarios, six semantic rejections and +three reserve controls. The independent review adds exact orientation/dirty +spectator cases and independent rational economics. Normal/optimized results +must equal their corresponding frozen receipts. This bounded check does not +execute the source author's formal-word verifier or admit all-width physical +implementations. + +For a committed package, also use the repository's byte/source-history preflight +and official exporter. Transport integrity and ancestry availability are separate +from mathematical validation. Root retains local validation receipts and the +checked Git-free export; publication and hosted CI remain separate actions. + +## Remaining obligations and stopping rule + +No eligible chronological occurrence or autonomous output inventory is bound. +No actual complete `F,Q,B,wNew,wDirect` bill, strict child contraction, finite +work, preparation/routing/storage/cleanup, precision/rounding amplification, +ordinary BIT stock, outer rows, both paid tails or funded compiler reserve is +supplied. In the complex ABI, Fourier rank and exact Clifford phases differ +from scalar owner rank and binary permutation labels; a BIT-only improvement +does not establish a changed complex supplier. The retained #4610 obligations +remain partial/conditional. No root search, changed histogram, emitter, physical +fixture or new P/T/κ is reported. + +Stop implementation expansion until the complete bill for one actual occurrence +passes the strict direct-recipe comparison. A positive relaxed moment must also +retain `T<=U`, `P>=L`, hence `M<=U-L`, and the strict reserve screen +`L<(1-e)U`; passing an optimistic bound is not admission. + +## Open next questions + +The structured questions in `TASK.json` give relevance, first steps and blockers. +First name one eligible caller, actual cap-two ABI and complete prices, and test +the strict inequality. A failure stops that candidate; unknown prices remain a +blocker. Only after a pass should a separately scoped physical fixture +with width two or larger distinguish ordinary/reversed orientation using +independent owner impulses and dirty spectators. A finite fixture still needs +a uniform exact operator/address argument. Then audit the changed full complex +inventory, finite work, both tails, compiler reserve and outer transfer. + +## Credit and license + +Prepared by **Chris R / Clear1nsight**, with substantial **OpenAI Codex** +assistance in research, independent review and packaging. Predecessor authors +are credited for their source work, not described as commissioning clients. +Nick Petalas owns #5083's formal word; David Arias, Ross Richardson, Adam Gall +and the retained group/cut lineage retain their mathematical credit. The source +BIT, native, row-cover, Clifford, precision/compiler and analytic contributors +include Cao Yifan, Cinna Davis, zxv, Dugongue, Jacob Alan Sussman, eumemic and +their predecessors. The frozen reports retain fuller attribution. Source +extraction, economic derivation and the independent review are retained with +their original attribution and scope. Apache-2.0, with all source notices kept. diff --git a/research/three-swap-cap2-physical-ceiling/SOURCES.json b/research/three-swap-cap2-physical-ceiling/SOURCES.json new file mode 100644 index 0000000000..65f7a3844c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/SOURCES.json @@ -0,0 +1,564 @@ +{ + "schema_version": 1, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/rank2-swap-batching/README.md", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/rank2-swap-batching/README.md", + "git_blob": "431363d53d9d5b6f1832698cc7332244e0e4efd0", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "path": "research/gl2-swap-cut-corollary/README.md", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/gl2-swap-cut-corollary/README.md", + "git_blob": "c34c1460063ee4690c934d3c3fb3d81896f8931c", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "path": "notes/batched-bit-rows.tex", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:notes/batched-bit-rows.tex", + "git_blob": "cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "path": "notes/three-stage-cover-bit.tex", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:notes/three-stage-cover-bit.tex", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "git_blob": "12af6aa9377fa0ab84d485a37df0fe59e907e03c", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/PROOF-SOURCES.json", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/PROOF-SOURCES.json", + "git_blob": "d7b3f9898131162d614cd860efc02e072c2ac407", + "sha256": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedVerification.lean", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/TightenedVerification.lean", + "git_blob": "5f957dfa9e24e6e367a3e5856d09d5f1c82a7d09", + "sha256": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedCapacity.lean", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/TightenedCapacity.lean", + "git_blob": "8208fc777979386874ead1abca640bf61f88d718", + "sha256": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedArithmetic.lean", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/TightenedArithmetic.lean", + "git_blob": "ccc77d5fa2a5c500bf333e262a654c88e0780277", + "sha256": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8" + }, + { + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/pr4359-p7-padding/TENSOR.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/pr4359-p7-padding/TENSOR.md", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/kappa-round6-compiler-tightening-20261022/README.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-round6-compiler-tightening-20261022/README.md", + "git_blob": "6f822f33cc5c29a9fe4a2ca4312b7acbfbd011e3", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + }, + { + "path": "research/higher-moment-strictification/README.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/higher-moment-strictification/README.md", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/higher-moment-strictification/vendor/FINITE-TEMPLATE-CLOSURE.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/higher-moment-strictification/vendor/FINITE-TEMPLATE-CLOSURE.md", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/rank2-swap-batching/TASK.json", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/rank2-swap-batching/TASK.json", + "git_blob": "e3bf3f5f045190ac1a538aa0ea0ff422ea6588d0", + "sha256": "fefb528b755540d19b5f65ac13bed14689461d0d2741441e84d88cc068c0c3e7" + }, + { + "path": "research/rank2-swap-batching/SOURCES.json", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/rank2-swap-batching/SOURCES.json", + "git_blob": "8a315b46f25205c9a7537966f4604de271cdc1a2", + "sha256": "0026e1286fb9377ed5862fe91c109f34be038d2058fb50cba951f6cd362108d6" + }, + { + "path": "research/coxeter-root-tariff/PROOF.md", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/coxeter-root-tariff/PROOF.md", + "git_blob": "c67d51701a3dccf1028f8213502979372dbd73b3", + "sha256": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8" + }, + { + "path": "research/mixed-gl2-block-tariff/README.md", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/mixed-gl2-block-tariff/README.md", + "git_blob": "0e70d9afe37947ca267a93892b791e5ea27c19e8", + "sha256": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0" + }, + { + "path": "research/ut3-rank-bounded-block-calls/README.md", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:research/ut3-rank-bounded-block-calls/README.md", + "git_blob": "dc0d1bac91fcebecc9fed4e8c3d26a11acca3ef5", + "sha256": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" + }, + { + "path": "certificates/frontier4470/CLAIM.json", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:certificates/frontier4470/CLAIM.json", + "git_blob": "bbf9f0bd346945fe1713a7e4c6cc1701f7cc0585", + "sha256": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232" + }, + { + "path": "notes/general-clifford-frames.tex", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:notes/general-clifford-frames.tex", + "git_blob": "0367eeb005298601f28a673861d6f71bf1d0ebbb", + "sha256": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54" + }, + { + "path": "notes/batched-complex-rows.tex", + "usage": "provenance", + "pin": "head:d2b3f35275cab6fbf18bee40e3fb411496732e54:notes/batched-complex-rows.tex", + "git_blob": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4", + "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c" + }, + { + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-rebuild/bit/bit_native_binding.py", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/kappa-rebuild/bit/README.md", + "usage": "provenance", + "pin": "head:20bb93cd990d2ff683e4d0fc56b87a42cd5d3296:research/kappa-rebuild/bit/README.md", + "git_blob": "10132fe535b4c44714d57bea377637f130f7ec7c", + "sha256": "351a9111292f3d406f94fd3c0f78867c8f421887f5073c0fb8fcef8a1377b02e" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/EVIDENCE.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/EVIDENCE.json", + "git_blob": "1058ea3fe029363deda8773f7dd113ff460842ef", + "sha256": "b670cc75811f6d42190029ef9cd2f65e67a588d5d147e2c9e3f47693aa7c5c1b" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md", + "git_blob": "6ea670d07cc0c342fe066cf2159cfe00be88cf3b", + "sha256": "f02e31783fac029ba63cc4b1175d6e6b89f1a064cda2307024c47de5b44ff2c1" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json", + "git_blob": "2c2f618e158ce3b659ae7684e003289fb2493cec", + "sha256": "da9c41102d4801b06db91cf5ab8fc24c1df103400bbdbb4c55a5792284ff7540" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json", + "git_blob": "a38d05875cdd63ee84358e316af78d6e91428a1e", + "sha256": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json", + "git_blob": "a38d05875cdd63ee84358e316af78d6e91428a1e", + "sha256": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md", + "git_blob": "d08bf79849717f7f69d5e73e81dc5d0cff695e61", + "sha256": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json", + "git_blob": "2744e54b585d33c320cdf077a58ccbee225ddf43", + "sha256": "2bd64afd859fb006f1f592844003b2ca364f2846efb1415fc803c22904d56633" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md", + "git_blob": "b54ca7757aee90183994564d7015aeb69e7a0745", + "sha256": "5f8bc6e9518672eff5de557bc8eca9607069b4d081e498a6ef4749bd03bc70bc" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md", + "git_blob": "41ff38d0ce80377ab1baedae45bc7cfffe317f53", + "sha256": "1be3bbe4d4969ab29f221081eb9a880022d07bb3899cd1ffc236b4f217e80af2" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md", + "git_blob": "fb0a96a578da6622a1d691e5a4db581f6f2618f4", + "sha256": "59b259d876b8eebcaf0a20e20144bbd6b994bc795026fefa0bf2be25cf1f4fcc" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json", + "git_blob": "9a6a33af17d4dec972cd077e8222250a47d5bd13", + "sha256": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py", + "git_blob": "b641c664bd799d6ba36238280606c6049065f54c", + "sha256": "de8f2ac5ea2105ef8dd50c0b4755f3eb89ba4ab76977f018b2d1881a8845afd0" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json", + "git_blob": "0fdb65f946d557c13d8e2781b9151e2a8ddee5c3", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md", + "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-TEMPLATE-CLOSURE.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-TEMPLATE-CLOSURE.md", + "git_blob": "9917ac5543608047fd368e5e75f0851310f53584", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__HIGHER-MOMENT.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__HIGHER-MOMENT.md", + "git_blob": "0a736ca89e1eafb73a30e1f2589cc45e6b5f76c3", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json", + "git_blob": "d7b3f9898131162d614cd860efc02e072c2ac407", + "sha256": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md", + "git_blob": "6f822f33cc5c29a9fe4a2ca4312b7acbfbd011e3", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md", + "git_blob": "8ecfd3e4d0bcb449ecb1e150c4f1f4fbb39ca656", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedArithmetic.lean", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedArithmetic.lean", + "git_blob": "ccc77d5fa2a5c500bf333e262a654c88e0780277", + "sha256": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean", + "git_blob": "8208fc777979386874ead1abca640bf61f88d718", + "sha256": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean", + "git_blob": "5f957dfa9e24e6e367a3e5856d09d5f1c82a7d09", + "sha256": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py", + "git_blob": "12af6aa9377fa0ab84d485a37df0fe59e907e03c", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py", + "git_blob": "340e1f0ffb8a1a9c38fbbd9119580b6d23e01b59", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex", + "git_blob": "cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__three-stage-cover-bit.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__three-stage-cover-bit.tex", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__gl2-swap-cut-corollary__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__gl2-swap-cut-corollary__README.md", + "git_blob": "c34c1460063ee4690c934d3c3fb3d81896f8931c", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md", + "git_blob": "431363d53d9d5b6f1832698cc7332244e0e4efd0", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md", + "git_blob": "4af01d751667b2fe8aa120168eccd8862010ecfa", + "sha256": "d512aaffbf0fbe53918de2850ae725b9375e1f060018bc9759def4be55572999" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json", + "git_blob": "6796516026417ee451b854fef39f671e2f525aa4", + "sha256": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json", + "git_blob": "6796516026417ee451b854fef39f671e2f525aa4", + "sha256": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json", + "git_blob": "4cdefc0418084af45ba850e4eff3f2e2dc3a7a03", + "sha256": "22deada00ef988bdc99b7fd01480fc86136111a8483513d00ce2ae0eea711975" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py", + "git_blob": "e977984c430f9dc71db6dba3328ff475f1666987", + "sha256": "4f372d4dba50e8fa96820f8287241d6accaa44149229a5544387dacd96b3ec8e" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json", + "git_blob": "4e0a3cdca2d9aaf353bee58991c06bc24992b799", + "sha256": "d8e8fb46b628664881946502020ccf7a93f97c07cff77bc1a51f3ed35ac1cc5c" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md", + "git_blob": "91fc60feb831613e163e658ae54160788d519320", + "sha256": "71bb4f5ab05bf4da2887ccdcb32ff1ee00994347591f9954d22fca515cb86bd2" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json", + "git_blob": "5080a044669f39ffc874686d7a8eb8d9eaf486ca", + "sha256": "446fff2e65151972205503e7e713da6e47b89d62be59a4b51937fea9fa2cafdd" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json", + "git_blob": "bbf9f0bd346945fe1713a7e4c6cc1701f7cc0585", + "sha256": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex", + "git_blob": "cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-complex-rows.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-complex-rows.tex", + "git_blob": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4", + "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__general-clifford-frames.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__general-clifford-frames.tex", + "git_blob": "0367eeb005298601f28a673861d6f71bf1d0ebbb", + "sha256": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__coxeter-root-tariff__PROOF.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__coxeter-root-tariff__PROOF.md", + "git_blob": "c67d51701a3dccf1028f8213502979372dbd73b3", + "sha256": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__gl2-swap-cut-corollary__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__gl2-swap-cut-corollary__README.md", + "git_blob": "c34c1460063ee4690c934d3c3fb3d81896f8931c", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md", + "git_blob": "10132fe535b4c44714d57bea377637f130f7ec7c", + "sha256": "351a9111292f3d406f94fd3c0f78867c8f421887f5073c0fb8fcef8a1377b02e" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py", + "git_blob": "f4c4082d89969ea311219d9af8013082d599f6f1", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-round6-compiler-tightening-20261022__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-round6-compiler-tightening-20261022__README.md", + "git_blob": "6f822f33cc5c29a9fe4a2ca4312b7acbfbd011e3", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__mixed-gl2-block-tariff__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__mixed-gl2-block-tariff__README.md", + "git_blob": "0e70d9afe37947ca267a93892b791e5ea27c19e8", + "sha256": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md", + "git_blob": "431363d53d9d5b6f1832698cc7332244e0e4efd0", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json", + "git_blob": "8a315b46f25205c9a7537966f4604de271cdc1a2", + "sha256": "0026e1286fb9377ed5862fe91c109f34be038d2058fb50cba951f6cd362108d6" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json", + "git_blob": "e3bf3f5f045190ac1a538aa0ea0ff422ea6588d0", + "sha256": "fefb528b755540d19b5f65ac13bed14689461d0d2741441e84d88cc068c0c3e7" + }, + { + "path": "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md", + "usage": "input", + "pin": "head:a84a22d3f6e0ce75a9e433c6438f01cf25ed384c:research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md", + "git_blob": "dc0d1bac91fcebecc9fed4e8c3d26a11acca3ef5", + "sha256": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/TASK.json b/research/three-swap-cap2-physical-ceiling/TASK.json new file mode 100644 index 0000000000..8ec08d0135 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/TASK.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 7, + "base_commit": "81e9bd69e4a5b00ba9c713a1620e36d576d5522e", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Audit the PR5083 physical cap-two ABI, reversed/ordinary orientation and direct-comparator price ceiling.", + "scope_change_reason": "The source formal word is predecessor work; this package changes the card to its missing physical interface and complete price comparison, without another formal census or emitter.", + "bottleneck_link": "A cap-two scalar owner rank is not recursive child rank or address width; any BIT saving must beat a physical direct recipe and then change the binding complex supplier.", + "budget_minutes": 60, + "stop_rule": "Stop implementation expansion until one actual eligible caller and complete bill pass the strict direct-comparator inequality; unknown costs remain blockers.", + "outcome": "negative-result", + "evidence": "Retained physical-interface report, direct-comparator proof, exact scientific receipt, and frozen independent direct-only review replay; see README.", + "author": "Chris R / Clear1nsight, with substantial OpenAI Codex assistance", + "ai_assistance": "Substantial OpenAI Codex assistance in source analysis, independent arithmetic review, packaging and verification.", + "open_questions": [ + { + "question": "Can one eligible caller bind the cap-two ABI to actual complete same-volume prices below the direct recipe threshold?", + "why_it_matters": "Formal strict subadditivity alone does not beat the direct physical comparator.", + "first_step": "Name one chronological occurrence and complete F,Q,B,wNew,wDirect bill; test B<(2F+6Q-Delta)/4.", + "blocked_by": "No actual cap-two physical supplier, complete bill or bound eligible occurrence is supplied." + }, + { + "question": "If a complete bill passes, can the resulting full complex inventory fund finite work, both tails, compiler reserve and outer transfer?", + "why_it_matters": "A BIT local gain does not establish an improvement of the binding complex supplier or kappa.", + "first_step": "Construct the autonomous target and paid inventories for that one source-bound occurrence.", + "blocked_by": "The first physical/comparator gate and all ordinary/outer obligations remain." + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/VERIFY.json b/research/three-swap-cap2-physical-ceiling/VERIFY.json new file mode 100644 index 0000000000..3b096e42e8 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/VERIFY.json @@ -0,0 +1,87 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/three-swap-cap2-physical-ceiling/EVIDENCE.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-TEMPLATE-CLOSURE.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__HIGHER-MOMENT.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedArithmetic.lean", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__three-stage-cover-bit.tex", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__gl2-swap-cut-corollary__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json", + "research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-complex-rows.tex", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__general-clifford-frames.tex", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__coxeter-root-tariff__PROOF.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__gl2-swap-cut-corollary__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-round6-compiler-tightening-20261022__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__mixed-gl2-block-tariff__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json", + "research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Authenticate immutable physical/economic source manifests; replay exact author and independent direct-only checks against frozen receipts; reject corrupted scientific input; leave package unchanged." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Repeat all source, receipt and corruption controls with Python optimization enabled." + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md new file mode 100644 index 0000000000..6ea670d07c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/BASELINE-OBLIGATIONS.md @@ -0,0 +1,185 @@ +# Baseline obligations for a changed complete complex profile + +Status: source-bound ledger and screening interface, local only. No new supplier, +native word, compiler theorem, numerical root, κ, or complete multiplication +theorem is established. This ledger does not repackage the existing 54+4 map as +a theorem. Synced sources and other workers' outputs remain unchanged. + +## Source and freshness + +The scientific comparator is Cao Yifan's #4610 at +`20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`, frozen in +`complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/`. +The selected record remains #4470, κ=`60403/20000000`=.00302015. +#4610's developed comparison .0030217758 is partial/conditional and is not the +selected result. Its raw crossing is unchanged; no additional crossing digits +were computed here. + +Frozen governance is read from `small-coupled-frame-optimum-20261023` (base +`f259dabc7d70e0db8d6d36bfda888f008bbfecc1`). The monitor's +`canonical-guidance-check-0821.json` records observed main +`81e9bd69e4a5b00ba9c713a1620e36d576d5522e` at 08:21:04 UTC and identical +governing/selected blobs against `4c0a359d88f22f05189d51f48387750b801a45d4`. +Root supplied the intervening frozen-guidance equivalence. This is delegated +freshness evidence, not a local checkout of all files at observed main. + +## Screening quantities and types + +Declare an exact domain `D=[a,b]` with `0<=a<=b<1`. Write +`H_r(C)=r^(1-C)` for positive integer **recursive-child rank**, and `H_0=0`. +For an actual complete independent productive inventory T and complete paid +recursive inventory P, + +``` +T_t(C) = sum_r T[r] H_r(C), P_t(C) = sum_r P[r] H_r(C), +M(C) = T_t(C)-P_t(C). +``` + +Each credit needs a distinct arbitrary original input, the complete requested +endpoint, an autonomous whole-job normalization, and all-positive-column lifting. +Correlated contents in distinct physical owners are allowed; duplicated inputs, +owned zeros, scratch, intermediate outputs, copied sources and erased fields earn +no extra productive credit. Helper owners are retained once, not replaced with +an average rank or recredited at each transport. + +Every charge carries dimension type, multiplicity, owner/occurrence identity, +orientation, entry/exit charts and the actual child ABI. Scalar projector rank, +address rank, owner count, field volume, column multiplicity, and recursion rank +are different dimensions. An owner-rank-two invocation is not priced as H_2 +unless a source-bound physical reduction proves that exact recursive call. + +A legitimate reward upper bound U and recursive-cost lower bound L give + +``` +T_t(C)<=U(C), P_t(C)>=L(C) => M(C)<=U(C)-L(C). +``` + +The inequalities must hold simultaneously for the declared candidate and C. +A speculative target profile without a proved inventory can be used only as an +explicit optimistic premise of an exclusion. It supplies no admitted positive +moment. An implementation's constructive upper bill is not a lower bound on all +other implementations. A lower bound can reject only the policy/class whose +assumptions establish it. + +Point enclosures apply at that point. For a nonnegative rank histogram, H_r is +nonincreasing in C, so on [a,b] a valid interval exclusion is +`M(C)<=upper(T_t(a))-lower(P_t(b))`. The difference M need not be monotone. +Unknown credits/costs are never replaced by zero to issue an admission decision. + +## Required reserve before a retained-route GO + +A positive raw M is only the first screen. With a declared source contraction +reserve e>0, the retained first-ratio test is **strict** `P_t/T_t<1-e`. +Thus a necessary optimistic condition is + +``` +L(C) < (1-e) U(C), +R_e(C) := (1-e)U(C)-L(C) > 0. +``` + +If R_e<=0 the specified reserve cannot pass. If R_e>0 this lower/upper screen is +inconclusive: it does not prove the true inventory ratio or either paid tail. +For uniform exclusion, use `(1-e)upper(T_t(a))-lower(P_t(b))<=0`. +This reserve-adjusted screen is stronger than merely bounding M by U-L. + +When a changed caller has exactly the same **proved complete** target inventory +as a pinned baseline, and its total paid change is a saving G(C), the exact +first-ratio gate is + +``` +P_new=P_old-G, +G(C) > P_old(C)-(1-e)T(C). +``` + +This uses the actual invoice, not the distance between raw crossings. Changed +helper returns, autonomous output counts or ranks invalidate target cancellation. + +## Frozen #4610 route and its source-specific numbers + +The source `arithmetic.py:38-52` binds 18 FULL calls, 15*112 thin queries, its +actual chronological IDLE events and rank-145 diagonal. It records 64,404 paid +calls, 10,928 productive fields and rank-mass surplus 752. Local profiles are +`P={1:2201,2:412,3:510,4:127,5:40,8:8}` and +`H={4:28,7:7,8:47,9:326}`; these do not replace the complete controller bill. + +At claimed κ=.0030217758 the source tests C=.00302177581. It chooses +`t=1-C, u=1/5, v=1024, c=20, b=21`, reserve `e=10^-11`, and requires + +``` +alpha=P_t/T_t < 1-e, +gamma=P_(t+u)/(c^u T_t) < 97/100, +delta=B*b/(c^C T_t) < 97/100, +alpha^v + 2*gamma^v + 2*delta^v < 1. +``` + +Both original splitting and productive completion tails are paid. The frozen +certificate bounds the complete expression by +`1/(1+1024/10^11)+4/2^32 < 1`. These are sufficient conditions for this +route, not universal conditions for every supplier or compiler. + +The separated unit has ambient `145^1024`, maximum paid rank `20^1024`, and +minimum productive rank `21^1024`. The logarithmic stage uses +`theta_bar=63/64`, power p=1000 and eta=`t*(145^1024)^(-C)`; it needs + +``` +2*(20^1024)^64 <= (145^1024)^63, +(63/64)^1000 < eta, +(145^1024)^C < 2^1000. +``` + +For gap d=`(C-κ)/7=1/700000000000`, the saved finite threshold is +`j=55099`, `H=38569300000000000`, with `(H+1)^1000<2^j`. +The uniform supplier saving is `κ+6d`; outer parameters are +`b_outer=κ+5d`, `a=κ+4d`, `q=κ+3d`, `epsilon=1-d`, `beta=1-3d`, +`r0=d/10`, `stop=layout=d`. All values here are transcribed from frozen +source/receipt, not independently recomputed certificates. + +A changed profile first rebinds this route. Changes to ambient, maximum target, +helpers, cutoff, floor, moment tails or separation require new inequalities and +source/exit compiler applicability. The retained tensor/compiler definitions +identify ambient with maximum productive rank; e.g. ambient 41 with maximum +target 40 needs a proved, charged extension. A numerical eta check using 41 +does not supply it. Keep this route unless Astra explicitly justifies another. + +## Inherited complete costs and mandatory rebindings + +| Layer | Costs/premises retained | What invalidates automatic reuse | +|---|---|---| +| Native caller | Every FULL, thin, IDLE, helper return, signed chart, phase, scalar bridge, initial/final boundary, arbitrary dirty spectator | Changed local word, entry/exit or chronology; local adjacent-pair equality is not the complete caller | +| Recursive bill | All actual children, added corrections, paid completion and disjoint split remainders; original helper owners once | Omitted recursive wrapper, copied input credit, unproved independent output, rank-type substitution | +| Owned storage | Distinct bank per live unit, suspended lifetimes, temporaries, safe erasure, source complements | Shared or reused bank without lifetime/ownership proof; center retention alone is not productive credit | +| Ordinary finite work | Scalars, compensation, coefficient preparation, monomial/address movement, gather/scatter, setup and physical fixed-tape scans | Arithmetic rank count treated as an actual movement bill; arbitrary permutation priced as free RAM access | +| Precision | Coefficient/denominator heights, fixed fine grid, prefix/suffix amplification, rounded kernels, returned Gaussian semantics | New non-dyadic division or recoding; saved C1=1 positivity is not its semantic proof | +| Finite compiler | Integer batch replication, Pascal matching, acyclic chronology, actual-owner completion, source arrays used once, complement/exit rank bounds | Fractional routing, different paid positions merged in suspended copy, changed ambient binding | +| Ordinary BIT | Actual atom=1/250, after-cover saving=69/20000, derived saving=8590884599/2500000000000, admitted saving=17/5000, row stock and prime rule | A better ordinary bound alone does not repair the complex caller or its missing cost/precision premises | +| Outer transfer | Nine complete cost rows, geometry, support, records, log absorption, fixed halo, stock, prime avoidance and recovery | Changed supplier ABI/alphabet invalidates affected row premises; old positive ledger numbers do not price new work | + +The source raw scalar bound 181,098,496 and local routing/scalar caps 4,802,000 / +158,168 are bounds for its word, not constants for a changed word. All must be +recounted when their dependencies change. The current 54 strict predicates plus +four functional guards are source-bound inventory. The source comparison uses +an older ~.00173097 baseline, so a new claim must separately show final funded +κ>.0030217758. #4544's cancellation implication is not a universal import rule. + +PR5027's different p19 conditional construction is retained as a control: its +fully paid corrected-C inverse template adds **4256 H1**, not 19*336 H1 on top +of its existing bill. It keeps all 7752 helpers once under an explicit optimistic +target premise, yet its independently checked moment is negative throughout +[.0030217758,.00339999]. That rejects only that hypothetical invoice via its +unchanged route. It is not an obstruction to other callers or a #4610 theorem. + +## Open next questions + +1. Obtain one nonduplicative candidate from Astra with the exact complete output + inventory and smallest typed paid invoice. Freeze the changed premise before + any implementation or compiler/Lean expansion. +2. Establish a legitimate U and L for that candidate, with scoped domain and + explicit unknowns. Test the raw and reserve-adjusted necessary conditions. +3. Only after a favorable complete bill, rebind both tails, compiler applicability, + finite constants, ordinary/outer interfaces and independent κ validation. + +Credit Cao Yifan (#4610), Cinna Davis (#4470/#5027 and supplier/controller +lineage), Cayden Burkart, zxv, Jacob Alan Sussman, Dugongue/mdumitrean, Dillon, +JoyboyBrian and the source-pinned compiler, Clifford, BIT, precision and analytic +contributors. Substantial OpenAI Codex assistance. This is local source analysis; +no public action, scientific code execution or new κ claim occurred. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json new file mode 100644 index 0000000000..2c2f618e15 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CANDIDATE-INTERFACE.json @@ -0,0 +1,63 @@ +{ + "schema": "new-approach-complete-cost-screen/v1", + "status": "MISSING_PHYSICAL_PRICES_AND_ELIGIBLE_CALLER", + "candidate": "PR5083 reversed-generator interpretation with ordinary J targets", + "source_head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "domain": {"C_closed_interval": ["0", "17/5000"], "tau": "1-C", "H_zero": "0"}, + "cost_dimensions": { + "scalar_owner_rank": "number of independent owner fields acted on by formal invocation", + "address_width_f": "atom width of one complete source BIT call", + "logical_volume_V": "complete payload volume, including retained untouched ranges and spectators", + "column_multiplicity": "declared independently; not inferred from owner count", + "recursive_child_rank": "actual native child ABI only; no scalar-owner-rank identification" + }, + "physical_requirements": { + "eligible_chronological_occurrence": null, + "same_complete_autonomous_output_inventory": null, + "entry_exit_chart_and_orientation": null, + "uniform_a_b_and_owner_pair_tariffs": null, + "matched_actual_weights_and_ancestor_dependence": null, + "owned_helpers_credited_once": null, + "outside_call_costs_complete": null + }, + "actual_prices": { + "F_complete_same_volume_width_f_call": null, + "Q_complete_same_volume_width_floor_f_over_2_call": null, + "B_complete_two_owner_call_at_width_f": null, + "wNew_outside_complete_calls": null, + "wDirect_outside_complete_calls": null, + "Delta": "wNew-wDirect" + }, + "necessary_complete_recipe_comparison": "F+4B+wNew < 3F+6Q+wDirect", + "equivalent_strict_threshold": "B < (2F+6Q-Delta)/4", + "power_price_model_only": { + "hypothesis": "F=K*f^tau, Q=K*floor(f/2)^tau, B=2^tau*F, K>0, Delta=0", + "admitted_native_price": false, + "uniform_result": "NO_GAIN_AGAINST_RETAINED_DIRECT_RECIPE", + "necessary_B_over_F_strict_upper": "333/266", + "nominal_B_over_F_strict_lower": "399/200", + "normalized_recursive_deficit_strict_lower": "19767/6650" + }, + "moment_interface": { + "actual_recursive_target_inventory": null, + "actual_recursive_paid_inventory": null, + "guaranteed_independent_reward_upper_U": null, + "legitimate_scoped_recursive_lower_L": null, + "simultaneous_bound": "M(C)<=U(C)-L(C)", + "retained_alpha_reserve_e": "1/100000000000", + "necessary_reserve_screen": "L(C)<(1-e)*U(C)", + "point_or_uniform_interval_proof": null, + "both_paid_tail_and_compiler_bindings": null + }, + "separate_cost_bills": { + "fixed_tape_and_address_routing": null, + "owned_storage_and_safe_erasure": null, + "scalar_and_coefficient_preparation": null, + "precision_and_rounding_amplification": null, + "ordinary_BIT_stock_and_outer_rows": null + }, + "decision": "STOP_BEFORE_IMPLEMENTATION_UNTIL_ACTUAL_COMPLETE_BILL_GATE", + "physical_fixture_executed": false, + "compiler_or_Lean_run": false, + "new_kappa": null +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json new file mode 100644 index 0000000000..a38d05875c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT-OPTIMIZED.json @@ -0,0 +1,149 @@ +{ + "B_over_F_strict_necessary_cap": "333/266", + "C_domain": [ + "0", + "17/5000" + ], + "algebra_cases": 40, + "compiler_run": false, + "floor_cases_tau_one": 64, + "hypothetical_power_tariff_only": true, + "independent_output_inventory_verified": false, + "native_or_author_formal_replay_run": false, + "new_kappa": null, + "nominal_new_minus_direct_over_F_strict_lower": "19767/6650", + "physical_supplier_verified": false, + "raw_positive_but_reserve_closed_control": { + "reserve_adjusted_upper": "-1/2", + "status": "EXCLUDED_FOR_DECLARED_RESERVE" + }, + "semantic_rejections": [ + "H_scalar2_as_native_price", + "unproved_output_inventory", + "volume_to_width_substitution", + "orientation_mismatch", + "unequal_label_prices", + "missing_finite_work" + ], + "sources": [ + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/rank2-swap-batching/README.md", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/gl2-swap-cut-corollary/README.md", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/batched-bit-rows.tex", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/PROOF-SOURCES.json", + "sha256": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedVerification.lean", + "sha256": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedCapacity.lean", + "sha256": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedArithmetic.lean", + "sha256": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/pr4359-p7-padding/TENSOR.md", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/README.md", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/README.md", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/vendor/FINITE-TEMPLATE-CLOSURE.md", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + } + ], + "status": "PASS_SCOPED_DIRECT_COMPARATOR_AND_RESERVE_CONTROLS", + "synthetic_tariff_cases": { + "break_even": { + "B_strict_threshold": "5/4", + "difference": "0", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "6", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "formal_gain_but_direct_loss": { + "B_strict_threshold": "5/4", + "difference": "1", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "7", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "negative_outside_cost_can_change_decision": { + "B_strict_threshold": "7/4", + "difference": "-1", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "5", + "status": "ECONOMIC_INEQUALITY_ONLY" + }, + "positive_outside_cost_closes_gain": { + "B_strict_threshold": "6/5", + "difference": "0", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "6", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "synthetic_positive": { + "B_strict_threshold": "5/4", + "difference": "-1/5", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "29/5", + "status": "ECONOMIC_INEQUALITY_ONLY" + } + }, + "uniform_x_strict_lower": "399/200" +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json new file mode 100644 index 0000000000..a38d05875c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/CHECK-RESULT.json @@ -0,0 +1,149 @@ +{ + "B_over_F_strict_necessary_cap": "333/266", + "C_domain": [ + "0", + "17/5000" + ], + "algebra_cases": 40, + "compiler_run": false, + "floor_cases_tau_one": 64, + "hypothetical_power_tariff_only": true, + "independent_output_inventory_verified": false, + "native_or_author_formal_replay_run": false, + "new_kappa": null, + "nominal_new_minus_direct_over_F_strict_lower": "19767/6650", + "physical_supplier_verified": false, + "raw_positive_but_reserve_closed_control": { + "reserve_adjusted_upper": "-1/2", + "status": "EXCLUDED_FOR_DECLARED_RESERVE" + }, + "semantic_rejections": [ + "H_scalar2_as_native_price", + "unproved_output_inventory", + "volume_to_width_substitution", + "orientation_mismatch", + "unequal_label_prices", + "missing_finite_work" + ], + "sources": [ + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/rank2-swap-batching/README.md", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/gl2-swap-cut-corollary/README.md", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/batched-bit-rows.tex", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/PROOF-SOURCES.json", + "sha256": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedVerification.lean", + "sha256": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedCapacity.lean", + "sha256": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/TightenedArithmetic.lean", + "sha256": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/pr4359-p7-padding/TENSOR.md", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/README.md", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/README.md", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/vendor/FINITE-TEMPLATE-CLOSURE.md", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8" + } + ], + "status": "PASS_SCOPED_DIRECT_COMPARATOR_AND_RESERVE_CONTROLS", + "synthetic_tariff_cases": { + "break_even": { + "B_strict_threshold": "5/4", + "difference": "0", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "6", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "formal_gain_but_direct_loss": { + "B_strict_threshold": "5/4", + "difference": "1", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "7", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "negative_outside_cost_can_change_decision": { + "B_strict_threshold": "7/4", + "difference": "-1", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "5", + "status": "ECONOMIC_INEQUALITY_ONLY" + }, + "positive_outside_cost_closes_gain": { + "B_strict_threshold": "6/5", + "difference": "0", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "6", + "status": "NO_GAIN_AGAINST_DIRECT_RECIPE" + }, + "synthetic_positive": { + "B_strict_threshold": "5/4", + "difference": "-1/5", + "direct_recipe_upper_tariff": "6", + "new_adjusted_tariff": "29/5", + "status": "ECONOMIC_INEQUALITY_ONLY" + } + }, + "uniform_x_strict_lower": "399/200" +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md new file mode 100644 index 0000000000..d08bf79849 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md @@ -0,0 +1,211 @@ +# A direct-target price screen for the cap-two proposal + +**Scoped conditional economic result.** Nick Petalas's #5083 correctly compares +its five-call cap-two word with the six-call word in its restricted formal +alphabet. That comparison is not sufficient for its proposed BIT physical +interpretation: the source also has a direct ordinary-swap implementation. +For the reversed primitive interpretation, a candidate must satisfy + +``` +c2 < (2*cF + 6*cHalf - Delta)/4, +``` + +to beat that direct recipe. This can be substantially stronger than `c2<2*cF`. +Here cF,cHalf and c2 are actual complete, identically typed prices; Delta is +only the new minus direct overhead not already inside those prices. No +physical cap-two supplier or completed output inventory is supplied by this +note. There is no new κ and no impossibility claim for changed interfaces. + +## Exact source and ownership + +The #5083 formal source is frozen at +`d2b3f35275cab6fbf18bee40e3fb411496732e54`, with its README, the #2415 +product-preserving GL2/S3 bridge, and two unchanged BIT notes in `frozen/`. +`SOURCES.json` binds exact bytes. The source author establishes the five-call +formal result; its formal replay is not rerun here. + +The physical interface/source extraction is owned by sibling worker +`sol_1337_contact_frontier`; it supplied the exact reversed/ordinary distinction, +whole-volume interpretation and source snapshots. This note independently +derives the economic comparison, its sharp price boundary and exact rational +controls. Astra selected this paired question. The monitor's bounded 08:28–08:33 +checkpoint found no newer competing physical owner; this is delegated overlap +evidence, not a complete or current survey. + +## The three distinct comparisons + +**Formal a/b-only model.** #5083 gives scalar-owner-rank profile +`(2,2,1,2,2)`, total price `c1+4*c2`. Its comparator is `3*c1+3*c2`. +They have the same formal endpoint `diag(s,s,s,I_dirty)`. The difference is +`2*c1-c2` under the source tariff `0<=c1<=c2<=2*c1`. This is credited source +work, not the new result of this note. Scalar owner rank is not address width +or recursive-child rank. + +**Ordinary-swap interpretation.** Under the source #2415 bridge, `a=(12)`, +`b=(23)`, `s=(13)`. If the implemented primitive is an ordinary interchange J +of any two equal chunks, the target (13) is itself an available J of the same +width. Three target roles cost at most `3*cJ`. Taking c1=cJ, the formal word +costs at least `5*cJ` when c2>=cJ. This is a changed physical alphabet, so it +does not contradict #5083's exact minimum in its restricted formal alphabet. +It does show that the restricted six-call comparator is unsuitable here. + +**Reversed-swap interpretation.** The actual source BIT primitive is + +``` +F_A(H,D)=(A*C_f*D, C_f*A^-1*H), C_f^2=I. +``` + +Use unweighted a=F_12 and b=F_23 on three whole equal address chunks. +Writing C=C_f, the chronological actions are + +``` +(x,y,z) -> (C*y,C*x,z) -> (C*y,C*z,x) -> (z,y,x). +``` + +Thus aba is ordinary J_13; the two reversals cancel. The analogous bab has +the same endpoint. This calculation includes the middle chunk unchanged. +The source #2415 group isomorphism supplies the formal label correspondence; +it does not supply a rank-two physical implementation. + +The source `notes/three-stage-cover-bit.tex:172-187` constructs +`J_A=R_tail F_A R_tail`. Each R_tail is one unweighted reversed call on +first/last floor(f/2) atoms, fixing the middle atom. Therefore its explicit +recursive tariff is at most + +``` +cJ(f) <= cF(f)+2*cF(floor(f/2)). +``` + +These calls preserve complete spectators; they are on the same logical volume +V. The source `notes/batched-bit-rows.tex:9-25` separately defines a larger +address-width child on exactly V/W, and repeats separate calls explicitly. +Concatenating two role owners changes volume to 2V/W, so a larger address-width +tariff is not a justified price for the cap-two owner invocation. + +## Sharp threshold against this recipe + +Fix the same required complete target, volume, address chunk width, orientation, +precision and spectators for the two programs. Let + +``` +F = complete price of one unweighted reversed width-f call, +Q = complete price of one unweighted reversed width-floor(f/2) call, +B = complete price of the proposed cap-two owner call at width f, +wNew,wDirect = costs outside those complete calls only, +Delta = wNew-wDirect. +``` + +The proposed word has tariff `F+4B+wNew`. The direct recipe has constructive +upper tariff `3F+6Q+wDirect`. Therefore beating that available recipe requires + +``` +F+4B+wNew < 3F+6Q+wDirect, +B < (2F+6Q-Delta)/4. (1) +``` + +Equation (1) is exact for the stated tariffs and tight as a comparison to this +recipe: equality is break-even, either strict side reverses the ordering. It +does not assert this direct recipe is optimal. If another direct implementation +is cheaper, the necessary price is even lower. Costs already inside F,Q,B must +not be charged again in Delta. Unknown overhead prevents a complete physical +decision; it is not silently set to zero. The useful free grant Delta=0 is an +explicit recursive accounting comparison, not a proof of zero physical overhead. + +The uniform tariff is an explicit hypothesis for both labels and every selected +owner pair. Without it the five-call subtotal is `F_a+2*B_a+2*B_b`, with further +pair-dependent prices if necessary. The unweighted calculation does not identify +different ancestor-dependent weight arrays; such jobs need a fresh matched bill. +If the actual required targets are raw F rather than J, this word has the wrong +endpoint. Wrapping its three J targets to become F adds six half-width reversal +calls, unless a proved caller layout absorbs them. That particular wrapped +recipe costs `F+4B+6Q` before outside work and loses against `3F` for B>=F. + +Even a constructive upper bound B<=2F from separate role calls is insufficient +to prove strict improvement, and it is not a lower bound on a novel supplier. +If a larger-alphabet physical cap-two implementation also applies directly to +J_13, two roles can be batched directly and the comparator improves again to +`F+ B` (with F now the complete rank-one J price), subject to its actual ABI. + +## Exact conditional power-tariff screen + +This subsection assumes a declared **accounting model**, not a source physical +claim: at fixed logical volume, F=K*f^tau, Q=K*floor(f/2)^tau, +and a hypothetical cap-two owner invocation is priced B=2^tau*F. +K>0, `tau=1-C`, `H_0=0`, and Delta=0 for the recursive comparison. +In particular, the expression B here is a hypothetical tariff; it is not an +identification of scalar owner rank two with recursive child rank two. + +Put x=2^tau. For every integer f>=2, + +``` +Q/F <= 1/x, +(new - direct-upper)/F >= 1+4x-(3+6/x) + = 2*(2x-3)*(x+1)/x. (2) +``` + +The bound is attained at even f, so it is sharp uniformly over integer widths +for this tariff model. At odd f the floor only strengthens exclusion. At f=1, +Q=0 and direct cost is 3F, which is cheaper still in the screened domain. +The exact transition in (2) is x=3/2, equivalently +`C=log2(4/3)`. This is a tariff/comparator transition, not a κ ceiling. +For x<3/2 the sign can reverse, preventing a universal rejection. + +Declare the screen domain **0<=C<=17/5000=.0034**. Then +`tau>=4983/5000`. The exact integer inequality + +``` +399^5000 < 2^4983 * 200^5000 +``` + +proves x>399/200 throughout the domain, without floating point, logarithm +evaluation or extraction of the unchanged #4610 crossing. Consequently + +``` +B/F > 399/200, +necessary break-even B/F < 1/2+3/(2x) < 333/266, +(new-direct-upper)/F > 19767/6650 > 0. (3) +``` + +The last expression follows because 4x-2-6/x increases for x>0 and its value at +399/200 is 19767/6650. Thus the nominal concave-power price is decisively too +expensive even though it is strictly below 2F. A new physical B must be far +cheaper than that nominal price, or a proved outside-call advantage must pay +the difference. For nonzero Delta the exact threshold remains (1); a negative +Delta of sufficient magnitude could change the complete decision. None is +proved in the inspected physical interface. + +## Smallest next test and stopping rule + +Before any emitter or native/compiler expansion, provide one actual eligible +caller occurrence with the same autonomous target and spectators, and actual +complete F,Q,B,wNew,wDirect tariffs. Test (1) on that one occurrence, keeping +every dimension, column multiplier and owned/helper credit explicit. Include +the direct J competitor; do not compare only to the restricted six-call word. +Reject expansion if the complete strict inequality fails. If B or overhead is +unknown, retain the missing cost as a blocker. An inequality pass licenses only +the next physical test, not native correctness, compiler or κ admission. + +The independent exact checker verifies source hashes, the integer power bound, +the rational factorization, equality and both sign controls, floor cases at +tau=1, and rejection of scalar/address rank confusion and missing complete-cost +declarations. It executes no author formal-word verifier, native program, +compiler, parameter/root scan or Lean campaign. + +## Open next questions and credit + +1. Does any actual caller require the a/b-only representation while excluding + the direct J recipe? Specify its eligible occurrence and binding; do not + assume the formal restricted alphabet is the physical instruction set. +2. Can a physical cap-two invocation beat (1), including its complete returned + jobs, finite work, actual payload volume, precision and restoration? +3. Only after that gate, does a changed full supplier inventory improve the + retained #4610 complex moment with funded compiler reserve and outer transfer? + +Credit Nick Petalas (#5083 formal word and tariff), Ross Richardson (#2415 +GL2/S3 bridge), David Arias (#2738 rank-priced theorem), and the source BIT, +physical/compiler contributors retained in the frozen notes. The sibling +physical worker supplied exact source-interface extraction and corrected the +initial ordinary/reversed ambiguity before this result was frozen. Cao Yifan, +Cinna Davis, zxv, Jacob Alan Sussman and their predecessors retain the compiler +and selected-result credit. Substantial OpenAI Codex assistance. Local only; +publication and independent scientific acceptance are separate. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json new file mode 100644 index 0000000000..2744e54b58 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/FILES.json @@ -0,0 +1,31 @@ +{ + "status": "LOCAL_ONLY_UNCOMMITTED", + "files": { + "BASELINE-OBLIGATIONS.md": "f02e31783fac029ba63cc4b1175d6e6b89f1a064cda2307024c47de5b44ff2c1", + "CANDIDATE-INTERFACE.json": "da9c41102d4801b06db91cf5ab8fc24c1df103400bbdbb4c55a5792284ff7540", + "CHECK-RESULT-OPTIMIZED.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b", + "CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b", + "DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "HANDOFF-1166-PROPOSED.md": "5f8bc6e9518672eff5de557bc8eca9607069b4d081e498a6ef4749bd03bc70bc", + "PR-BODY-PROPOSED.md": "1be3bbe4d4969ab29f221081eb9a880022d07bb3899cd1ffc236b4f217e80af2", + "REPORT.md": "59b259d876b8eebcaf0a20e20144bbd6b994bc795026fefa0bf2be25cf1f4fcc", + "SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "check_screen.py": "de8f2ac5ea2105ef8dd50c0b4755f3eb89ba4ab76977f018b2d1881a8845afd0", + "frozen/4610__ARITHMETIC.json": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "frozen/4610__FINITE-PRECOMPILATION.md": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "frozen/4610__FINITE-TEMPLATE-CLOSURE.md": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9", + "frozen/4610__HIGHER-MOMENT.md": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "frozen/4610__PROOF-SOURCES.json": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3", + "frozen/4610__ROUND6-README.md": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba", + "frozen/4610__TENSOR.md": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "frozen/4610__TightenedArithmetic.lean": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8", + "frozen/4610__TightenedCapacity.lean": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d", + "frozen/4610__TightenedVerification.lean": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1", + "frozen/4610__arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "frozen/4610__endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "frozen/notes__batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "frozen/notes__three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "frozen/research__gl2-swap-cut-corollary__README.md": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9", + "frozen/research__rank2-swap-batching__README.md": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + } +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md new file mode 100644 index 0000000000..b54ca7757a --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/HANDOFF-1166-PROPOSED.md @@ -0,0 +1,8 @@ +HANDOFF +Research discussion / PR / artifact: LOCAL-ONLY, outputs/new-approach-ceilings-20261023/REPORT.md and DIRECT-COMPARATOR-PROOF.md. Concrete candidate #5083 https://github.com/CrocSwap/integer-mult-bounds/pull/5083; no public PR for this ceiling result yet. +Exact commit: Scientific source #5083 d2b3f35275cab6fbf18bee40e3fb411496732e54 and compiler comparator #4610 20bb93cd990d2ff683e4d0fc56b87a42cd5d3296. Local result uncommitted; publication commit pending root's coordinated gate. +What is established: Against the retained direct ordinary-target recipe, the reversed-generator candidate needs complete B<(2F+6Q-Delta)/4, stronger than formal B<2F. In an explicitly hypothetical same-volume power tariff, all C in [0,.0034] give necessary B/F<333/266 while nominal B/F>399/200, with recursive deficit>19767/6650 F. Exact normal/optimized controls and 16 source hashes pass; the source-bound #4610 compiler/reserve ledger is reconstructed without new root digits. +What remains uncertain: No actual cap-two physical supplier, eligible paid occurrence, autonomous native output inventory, complete outside-call overhead or changed complex invoice is provided. No universal physical obstruction, optimal direct recipe, compiler admission, new κ, hosted CI or independent scientific acceptance is claimed. Economic independent review and upstream package preflight are pending. +Smallest useful next task: Bind one eligible actual caller and actual same-volume complete F,Q,B,wNew,wDirect prices, with matched orientation/weights and all outputs; test the strict direct-target threshold. Stop if it fails or costs remain unknown. Only then consider root's next physical fixture and the retained compiler reserve/outer transfer. +Reproduction command and expected runtime: python3 -I -B outputs/new-approach-ceilings-20261023/check_screen.py; repeat with -O. Standard library, comfortably below one second per mode here, reads 16 self-contained frozen scientific sources and writes only stdout; no native/formal/compiler/Lean run. Publication package path and exact resource timing must be updated at packaging. +Predecessor credit: Nick Petalas #5083; Ross Richardson #2415; David Arias #2738; retained group/cut lineage; sibling physical worker's exact source/interface extraction and orientation correction; Cao Yifan, Cinna Davis, zxv, Jacob Alan Sussman and BIT/native/compiler/precision/analytic predecessors. Substantial OpenAI Codex assistance; Apache-2.0. Root owns all public writes. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md new file mode 100644 index 0000000000..41ff38d0ce --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/PR-BODY-PROPOSED.md @@ -0,0 +1,59 @@ +## Change and mathematical scope + +The #5083 cap-two word's strict-subadditivity condition compares against its +restricted formal disjoint word. Its reversed-BIT interpretation produces an +ordinary target with an available direct recipe, so that comparator is too weak +for a physical gain. Derive the exact necessary complete-price threshold +`B<(2F+6Q-Delta)/4`, preserving orientation, same-volume cost types, actual output +equality, uniform pair/label prices and every outside-call cost. + +Under an explicitly hypothetical normalized power tariff, exact integers show +the nominal cap-two price loses against the direct recipe throughout +`0<=C<=.0034`: necessary `B/F<333/266`, nominal `B/F>399/200`, and recursive +deficit `>19767/6650 F`. This is a scoped tariff screen; no actual cap-two +supplier, optimal direct recipe, universal physical lower bound, new invoice or +κ is claimed. The accompanying source-bound ledger states what a changed #4610 +profile must rebind through the frozen compiler route. + +## Task and overlap + +Root-assigned independent ceiling/complete-cost contribution, paired by Astra +with #5083. The physical worker owns ABI/source extraction and an eligible +occurrence; this result owns the independent price comparison and exact bounded +controls. Formal source is #5083 `d2b3f35275cab6fbf18bee40e3fb411496732e54`; +compiler comparator is #4610 `20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`. +Selected #4470 remains .00302015. Frozen guidance base is f259dabc…, with +root/monitor canonical-equivalence evidence through observed 81e9bd69… at +08:21 UTC. Refresh live overlap and set the exact publication base before +submission. No new public reservation is claimed by these local drafts. + +## Validation + +Local standard-library normal and optimized checker receipts are byte-identical: +16 immutable source hashes, one exact integer-power inequality, 40 rational +factor/sign cases, 64 floor cases, five synthetic complete-price cases, six +semantic rejection controls and three strict-reserve controls. Positive cases +are explicitly synthetic tariff checks. No author formal verifier, native +fixture, compiler/Lean build, root scan, selected cold replay or hosted CI ran. +The physical source owner found no interface/comparator mismatch. Separate +economic review remains pending unless attached later. Package registration, +isolated publication commit and export/source-history preflight must precede a +public PR; this text does not claim they occurred. + +## Credit + +Nick Petalas #5083 supplies the formal word and price theorem; Ross Richardson +#2415 the GL2/S3 bridge; David Arias #2738 the rank-priced theorem, with retained +cut/model predecessors. The sibling physical worker supplied exact BIT-source +extraction and the corrected reversed/ordinary distinction. Cao Yifan, Cinna +Davis, zxv, Jacob Alan Sussman and retained BIT/native/compiler/precision/analytic +contributors keep their source attribution. Substantial OpenAI Codex assistance; +Apache-2.0. The source 54+4 map is credited and is not a new theorem here. + +## Open next questions + +Bind one actual eligible caller, complete autonomous outputs and the actual +F,Q,B,Delta price. Test the direct-target threshold before implementation. +Only a favorable complete bill justifies the next physical test and then +source-bound compiler reserve, ordinary/outer transfer and independent κ +validation. Missing cap-two pricing, layout, weights or overhead stays missing. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md new file mode 100644 index 0000000000..fb0a96a578 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/REPORT.md @@ -0,0 +1,93 @@ +# Changed-profile ceilings and the cap-two direct-target screen + +**Local finding: #5083's formal strict-subadditivity test is insufficient for +its retained BIT interpretation.** With reversed generators and the ordinary +target they produce, the source has an explicit direct recipe. The candidate's +complete cap-two price B must satisfy + +`B < (2F+6Q-Delta)/4`, + +where F is the complete width-f reversed-call tariff, Q the complete +floor(f/2)-width tariff on the same logical volume, and Delta only the new minus +direct overhead outside those calls. This is exact relative to that recipe; +the direct recipe is a constructive upper bound, not an optimum claim. + +The [proof](DIRECT-COMPARATOR-PROOF.md) distinguishes the source a/b-only formal +comparison, ordinary J generators, reversed F generators, and actual raw-F +targets. It retains pair/label price equality and unweighted/weighted boundaries. +The [baseline ledger](BASELINE-OBLIGATIONS.md) reconstructs the unchanged #4610 +paid chronological-product, completion/splitting, logarithmic compiler, finite +template and ordinary/outer obligations. Neither artifact extracts new digits +from the unchanged crossing or claims a new theorem from the 54+4 source map. + +In a separately declared hypothetical accounting model `F=K f^(1-C)`, +`Q=K floor(f/2)^(1-C)` and `B=2^(1-C)F`, with outside overhead difference +Delta=0, the proposed word loses throughout **0<=C<=17/5000**. Exact integers +prove `2^(1-C)>399/200`, so the necessary cap-two price is +`B/F<333/266`, while the nominal tariff is strictly larger than `399/200`. +The recursive cost disadvantage exceeds `19767/6650 * F`. Even widths attain +the underlying exact comparison; odd-width floors strengthen it. This is a +scoped tariff/comparator result, not an actual supplier lower bound. Unknown +overhead or a different actual complete B can change the full physical decision. + +## Evidence and reproducibility + +`SOURCES.json` authenticates 16 immutable scientific references, all now retained +in `frozen/`: four #5083/interface references at +`d2b3f35275cab6fbf18bee40e3fb411496732e54` and 12 #4610/compiler references at +`20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`. The selected record remains +#4470, .00302015; the developed #4610 comparator remains partial/conditional +.0030217758. Root/monitor freshness evidence is declared separately in the +baseline ledger; no complete current-main checkout is claimed. + +Run from any location with standard-library Python: + +``` +python3 -I -B outputs/new-approach-ceilings-20261023/check_screen.py +python3 -I -O -B outputs/new-approach-ceilings-20261023/check_screen.py +``` + +The two saved receipts are byte-identical. The checker verifies all 16 source +hashes, the integer-power bound, 40 rational factor/sign cases, 64 exact +tau=1 floor cases, five synthetic complete-tariff scenarios, six semantic +rejections and three reserve controls. It checks a positive synthetic tariff, +break-even rejection, a formal gain that loses against the direct recipe, +outside-cost changes, dimension/orientation/weight-price declarations and a +positive raw moment with a closed compiler reserve. It performs no numerical +logarithm/exponential evaluation, profile-root search, author formal-word replay, +native fixture, physical execution, compiler or Lean campaign. + +The reserve interface is `T<=U`, `P>=L`, hence `M<=U-L`. A declared strict +alpha reserve e additionally needs `L<(1-e)U`; a positive relaxed upper margin +does not admit the true inventory or either paid tail. The required retained +compiler and outer steps are in the baseline ledger. + +The sibling physical source owner checked the draft interface/comparator wording +and found no mismatch; it did not rerun this economic checker. A separate +verification worker has been asked for an independent economic/algebra review. +That review is pending unless a later review artifact is attached. No external +post, branch/commit, registered upstream package, hosted CI or scientific +acceptance is claimed by these local files. + +## Decision and smallest useful next task + +Do not implement the nominal power-priced cap-two proposal as a κ attempt. +First bind one eligible occurrence, actual autonomous target inventory and +actual same-volume complete F,Q,B,wNew,wDirect bill. Compare with the direct +J recipe and test the exact inequality above. Unknown cap-two or outside cost +is a missing premise; it is not zero. If the complete inequality fails, stop +that candidate. If it passes, the next physical fixture remains separately +gated by root, followed by the retained compiler reserve and independent κ +validation. Ordinary BIT improvement by itself does not remove the binding +complex-supplier bottleneck. + +Open next questions: identify a genuinely eligible restricted caller; supply a +complete cap-two price below the direct threshold; then demonstrate a changed +full complex profile with both paid tails and funded compiler/outer reserve. +No universal physical obstruction follows from this scoped economic result. + +Credit Nick Petalas, Ross Richardson, David Arias and the source group/cut +lineage; the sibling physical worker for exact source/interface extraction; +Cao Yifan, Cinna Davis, zxv, Jacob Alan Sussman and the retained native, BIT, +precision/compiler and analytic contributors. Substantial OpenAI Codex +assistance. Apache-2.0. Publication remains subject to root's coordinated gate. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json new file mode 100644 index 0000000000..9a6a33af17 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/SOURCES.json @@ -0,0 +1,117 @@ +{ + "status": "LOCAL_SOURCE_BOUND_ANALYSIS", + "files": [ + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "upstream_path": "research/rank2-swap-batching/README.md", + "snapshot": "frozen/research__rank2-swap-batching__README.md", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054", + "provenance": "coded-port-adapter-ceiling-20261023/outputs/three-swap-cap2-feasibility-20261023/source/research__rank2-swap-batching__README.md" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "upstream_path": "research/gl2-swap-cut-corollary/README.md", + "snapshot": "frozen/research__gl2-swap-cut-corollary__README.md", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9", + "provenance": "coded-port-adapter-ceiling-20261023/outputs/three-swap-cap2-feasibility-20261023/source/research__gl2-swap-cut-corollary__README.md" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "upstream_path": "notes/batched-bit-rows.tex", + "snapshot": "frozen/notes__batched-bit-rows.tex", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "provenance": "coded-port-adapter-ceiling-20261023/outputs/three-swap-cap2-feasibility-20261023/source/notes__batched-bit-rows.tex" + }, + { + "commit": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "upstream_path": "notes/three-stage-cover-bit.tex", + "snapshot": "frozen/notes__three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "provenance": "coded-port-adapter-ceiling-20261023/outputs/three-swap-cap2-feasibility-20261023/source/notes__three-stage-cover-bit.tex" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/arithmetic.py", + "snapshot": "frozen/4610__arithmetic.py", + "sha256": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/arithmetic.py" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "snapshot": "frozen/4610__ARITHMETIC.json", + "sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/ARITHMETIC.json" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/PROOF-SOURCES.json", + "snapshot": "frozen/4610__PROOF-SOURCES.json", + "sha256": "e7c2e674486df4a386fae934df1d41609f9a3bfd2d257a3a36725273778e2bc3", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/PROOF-SOURCES.json" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/TightenedVerification.lean", + "snapshot": "frozen/4610__TightenedVerification.lean", + "sha256": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/TightenedVerification.lean" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/TightenedCapacity.lean", + "snapshot": "frozen/4610__TightenedCapacity.lean", + "sha256": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/TightenedCapacity.lean" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/TightenedArithmetic.lean", + "snapshot": "frozen/4610__TightenedArithmetic.lean", + "sha256": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/TightenedArithmetic.lean" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py", + "snapshot": "frozen/4610__endpoint.py", + "sha256": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/endpoint.py" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/pr4359-p7-padding/TENSOR.md", + "snapshot": "frozen/4610__TENSOR.md", + "sha256": "b2eba86cb979b4dc2a045f2e74bbd29e4d9e5ec87d6a2bc23ba7b54f1f58e3e3", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/TENSOR.md" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/kappa-round6-compiler-tightening-20261022/README.md", + "snapshot": "frozen/4610__ROUND6-README.md", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/ROUND6-README.md" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/higher-moment-strictification/README.md", + "snapshot": "frozen/4610__HIGHER-MOMENT.md", + "sha256": "ebe80b68ff026ce90f71f274c31744f4c0b36132d15ebb7e39cf2d5df4df270d", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/HIGHER-MOMENT.md" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/higher-moment-strictification/vendor/FINITE-TEMPLATE-CLOSURE.md", + "snapshot": "frozen/4610__FINITE-TEMPLATE-CLOSURE.md", + "sha256": "3f8508c63862dd83968bd30df91b08ba5afcee1e10db15ca546cdff0caef95d9", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/FINITE-TEMPLATE-CLOSURE.md" + }, + { + "commit": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "upstream_path": "research/higher-moment-strictification/vendor/FINITE-PRECOMPILATION.md", + "snapshot": "frozen/4610__FINITE-PRECOMPILATION.md", + "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8", + "provenance": "complementary-consumer-feasibility-20261023/outputs/retained-centre-compiler-obligations/frozen/FINITE-PRECOMPILATION.md" + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py new file mode 100644 index 0000000000..b641c664bd --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/check_screen.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Bounded exact economic checks. No native/compiler execution or root search. + +Apache-2.0. Substantial OpenAI Codex assistance. See source/credit in proof. +""" +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def authenticate(): + receipt = [] + for item in json.loads((HERE / "SOURCES.json").read_text())["files"]: + path = HERE / item["snapshot"] if item["snapshot"] else ROOT / item["provenance"] + actual = sha256(path.read_bytes()).hexdigest() + need(actual == item["sha256"], "Changed source: " + str(path)) + receipt.append({"commit": item["commit"], "path": item["upstream_path"], "sha256": actual}) + return receipt + + +def comparison(case): + """Exact tariff gate only, never a physical-admission verdict.""" + need(case["price_unit"] == "complete_native_call_price", "Rank powers alone are not complete native prices") + need(case["same_complete_target"] is True, "Independent complete target equality required") + need(case["same_volume_and_width"] is True, "Owner volume cannot be substituted for address width") + need(case["same_orientation_and_precision"] is True, "Orientation/precision mismatch") + need(case["uniform_label_and_pair_prices"] is True, "Label/pair-dependent tariffs require their actual sum") + need(case["outside_overhead_complete"] is True, "Unknown outside-call bill") + f, q, b, delta = (Q(case[k]) for k in ("F", "Q", "B", "Delta")) + need(f > 0 and q >= 0 and b >= 0, "Nonnegative complete prices required") + old_upper = 3 * f + 6 * q + new = f + 4 * b + delta + threshold = (2 * f + 6 * q - delta) / 4 + need((new < old_upper) == (b < threshold), "Threshold algebra") + return {"new_adjusted_tariff": str(new), "direct_recipe_upper_tariff": str(old_upper), + "B_strict_threshold": str(threshold), "difference": str(new - old_upper), + "status": "ECONOMIC_INEQUALITY_ONLY" if new < old_upper else "NO_GAIN_AGAINST_DIRECT_RECIPE"} + + +def reserve_screen(u_upper, l_lower, epsilon): + u, l, e = Q(u_upper), Q(l_lower), Q(epsilon) + need(u > 0 and l >= 0 and 0 < e < 1, "Invalid simultaneous U,L,reserve") + bound = (1 - e) * u - l + return {"reserve_adjusted_upper": str(bound), + "status": "EXCLUDED_FOR_DECLARED_RESERVE" if bound <= 0 else "INCONCLUSIVE_OPTIMISTIC_SCREEN"} + + +def main(): + sources = authenticate() + # Entire C domain [0,17/5000], tau>=4983/5000. Exact integers only. + need(399 ** 5000 < 2 ** 4983 * 200 ** 5000, "Uniform power-tariff lower bound") + x = Q(399, 200) + floor_price_cap = Q(1, 2) + Q(3, 2) / x + deficit = 4 * x - 2 - 6 / x + need(floor_price_cap == Q(333, 266), "Break-even rational cap") + need(deficit == Q(19767, 6650) > 0, "Nominal tariff deficit") + algebra_cases = 0 + for n in range(1, 41): + z = Q(n, 10) + value = 1 + 4 * z - (3 + 6 / z) + need(value == 2 * (2 * z - 3) * (z + 1) / z, "Factored price difference") + need((value > 0) == (z > Q(3, 2)), "Scoped transition sign") + algebra_cases += 1 + need(1 + 4 * Q(7, 5) < 3 + 6 / Q(7, 5), "Below-transition reversal control") + need(1 + 4 * Q(3, 2) == 3 + 6 / Q(3, 2), "Break-even control") + # tau=1 exact floor tests, including H_0=0 at f=1. + floor_cases = 0 + for f in range(1, 65): + half = f // 2 + direct = 3 * f + 6 * half + new = 9 * f + need(new > direct, "Known separate-owner tariff must lose") + if f % 2 == 0: + need(new - direct == 3 * f, "Even-width sharpness") + else: + need(new - direct == 3 * f + 3, "Odd-width floor strengthening") + floor_cases += 1 + template = {"price_unit": "complete_native_call_price", "same_complete_target": True, + "same_volume_and_width": True, "same_orientation_and_precision": True, + "uniform_label_and_pair_prices": True, + "outside_overhead_complete": True, "F": "1", "Q": "1/2", "B": "6/5", "Delta": "0"} + cases = {} + for name, patch in [("synthetic_positive", {}), ("break_even", {"B": "5/4"}), + ("formal_gain_but_direct_loss", {"B": "3/2"}), + ("positive_outside_cost_closes_gain", {"Delta": "1/5"}), + ("negative_outside_cost_can_change_decision", {"B": "3/2", "Delta": "-2"})]: + cases[name] = comparison(dict(template, **patch)) + need(cases["synthetic_positive"]["status"] == "ECONOMIC_INEQUALITY_ONLY", "Positive synthetic control") + need(cases["break_even"]["difference"] == "0", "Strict inequality rejects equality") + need(cases["formal_gain_but_direct_loss"]["status"] == "NO_GAIN_AGAINST_DIRECT_RECIPE", "Wrong comparator control") + need(cases["positive_outside_cost_closes_gain"]["difference"] == "0", "Outside cost charged once") + need(cases["negative_outside_cost_can_change_decision"]["status"] == "ECONOMIC_INEQUALITY_ONLY", "No universal overhead exclusion") + rejected = [] + for name, patch in [("H_scalar2_as_native_price", {"price_unit": "H_scalar_rank"}), + ("unproved_output_inventory", {"same_complete_target": False}), + ("volume_to_width_substitution", {"same_volume_and_width": False}), + ("orientation_mismatch", {"same_orientation_and_precision": False}), + ("unequal_label_prices", {"uniform_label_and_pair_prices": False}), + ("missing_finite_work", {"outside_overhead_complete": False})]: + try: + comparison(dict(template, **patch)) + except ValueError: + rejected.append(name) + else: + raise ValueError("Failed semantic rejection: " + name) + raw_positive_reserve_closed = reserve_screen(100, "199/2", "1/100") + need(raw_positive_reserve_closed["status"] == "EXCLUDED_FOR_DECLARED_RESERVE", "Raw positive moment is not reserve") + need(reserve_screen(100, 99, "1/100")["status"] == "EXCLUDED_FOR_DECLARED_RESERVE", "Strict reserve equality control") + need(reserve_screen(100, 98, "1/100")["status"] == "INCONCLUSIVE_OPTIMISTIC_SCREEN", "U,L passing is not admission") + out = {"status": "PASS_SCOPED_DIRECT_COMPARATOR_AND_RESERVE_CONTROLS", + "C_domain": ["0", "17/5000"], "hypothetical_power_tariff_only": True, + "uniform_x_strict_lower": "399/200", "B_over_F_strict_necessary_cap": str(floor_price_cap), + "nominal_new_minus_direct_over_F_strict_lower": str(deficit), + "algebra_cases": algebra_cases, "floor_cases_tau_one": floor_cases, + "synthetic_tariff_cases": cases, "semantic_rejections": rejected, + "raw_positive_but_reserve_closed_control": raw_positive_reserve_closed, + "sources": sources, "physical_supplier_verified": False, + "independent_output_inventory_verified": False, "compiler_run": False, + "native_or_author_formal_replay_run": False, "new_kappa": None} + print(json.dumps(out, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json new file mode 100644 index 0000000000..0fdb65f946 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ARITHMETIC.json @@ -0,0 +1,241 @@ +{ + "compiler": { + "H": 38569300000000000, + "N": "2^38569300000000000", + "eta": { + "lower": "0.000000204535199106284215364833", + "upper": "0.000000204535199106284215364834" + }, + "gap": "1/700000000000", + "integer_test_exponent": 55099, + "logarithm_power": 1000, + "theta": "63/64", + "uniform_saving": "1057621533/350000000000", + "word_materialized": false + }, + "gain_over_PR4535": "4027/2500000000", + "kappa": "15108879/5000000000", + "local_helpers": { + "4": 28, + "7": 7, + "8": 47, + "9": 326 + }, + "local_paid": { + "1": 2201, + "2": 412, + "3": 510, + "4": 127, + "5": 40, + "8": 8 + }, + "margin_at_old_root_upper": [ + "78072058023577019965454984044224523228758899702419408235/196159429230833773869868419475239575503198607639501078528", + "1249152928377232319447279744707592371660142395238823308861/3138550867693340381917894711603833208051177722232017256448" + ], + "native_receipt_sha256": "eec3b14241430b6c9f5de3cbf0e3d45a172d8071d2dccd2b59d56a1fbac3d428", + "negative_controls": { + "closed_epsilon": [ + "epsilon_below_one", + "global_gamma_power_slack", + "actual_logarithmic_gamma_guard", + "source_axis_superpolynomial", + "gaussian_above_main", + "new_semantic_guard_with_C1_one" + ], + "closed_uniform": [ + "new_complex_uniform_saving_above_b" + ], + "old_BIT": [ + "actual_bit_above_effective" + ], + "unfunded_endpoint": [ + "main_transform_above_kappa", + "global_coordinate_router_above_kappa", + "fused_gaussian_above_kappa", + "group_bit_router_above_kappa", + "boundary_algebraic_matrix_above_kappa" + ] + }, + "nonrecursive": { + "local_routes": 4802000, + "local_scalar": 158168, + "raw_scalar_upper": 181098496 + }, + "ordinary_BIT": { + "admitted": "17/5000", + "after_cover": "69/20000", + "atom": "1/250", + "before_cover": "3459/1000000", + "ordinary_saving": "8590884599/2500000000000", + "prime_rule": "odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses" + }, + "outer": { + "functional_checks": { + "actual_new_BIT_stock_sublinear": "174299999999253/175000000000000", + "fixed_halo_explicit_metadata_branch": "13475000000001/175000000000", + "new_BIT_row_stock_sublinear_in_active_group": "697899999997009/700000000000000", + "new_semantic_group_guard": "3/700000000000" + }, + "margins": { + "boundary_algebraic_matrix": "1480670144797884756937/490000000000000000000000", + "fused_gaussian": "1480670144793654270811/490000000000000000000000", + "global_coordinate_router": "264405383/87500000000", + "group_bit_router": "185083768186706783851/61250000000000000000000", + "group_scans": "349999999999/350000000000", + "main_transform": "1480670144097884756937/490000000000000000000000", + "microbox_face_corrections": "13475000000001/175000000000", + "polynomial_products": "699999999999/700000000000", + "sparse_union_movement": "200543170144797884756937/490000000000000000000000" + }, + "parameters": { + "a": "264405383/87500000000", + "b": "423048613/140000000000", + "beta": "699999999997/700000000000", + "bit_saving": "17/5000", + "cap_xi": "445543170144097884756937/490000000000000000000000", + "complex_uniform_saving": "1057621533/350000000000", + "d": "1/700000000000", + "epsilon": "699999999999/700000000000", + "kappa": "15108879/5000000000", + "lambda_": "199395644839/200000000000", + "lambda_prime": "697884756937/700000000000", + "layout": "1/700000000000", + "q": "2115243063/700000000000", + "r0": "1/7000000000000", + "stop": "1/700000000000", + "tested_saving": "302177581/100000000000" + }, + "strict_checks": { + "actual_bit_above_effective": "33094617/87500000000", + "actual_logarithmic_gamma_guard": "1/700000000000", + "actual_logarithmic_group_guard": "44456829856952115243063/245000000000000000000000", + "alpha_logarithm_absorption": "1/7000000000000", + "boundary_algebraic_matrix_above_kappa": "2797884756937/490000000000000000000000", + "cap_above_band": "200543170144097884756937/490000000000000000000000", + "cap_below_cell": "44456829855202115243063/490000000000000000000000", + "cap_below_phase_cell_power": "534456829855902115243063/490000000000000000000000", + "complex_above_effective": "1/700000000000", + "complex_below_one_over_32": "3951951387/140000000000", + "complex_endpoint": "1/350000000000", + "epsilon_below_one": "1/700000000000", + "epsilon_positive": "699999999999/700000000000", + "fine_prime_halo_umbrella": "7/2", + "fused_gaussian_above_kappa": "2793654270811/490000000000000000000000", + "gaussian_above_main": "347884756937/245000000000000000000000", + "global_coordinate_router_above_kappa": "1/175000000000", + "global_gamma_power_slack": "9/7000000000000", + "group_below_dimension": "1/350000000000", + "group_bit_router_above_kappa": "436706783851/61250000000000000000000", + "group_gauge_power_slack": "44456829856917115243063/245000000000000000000000", + "group_key_fits_record": "1/350000000000", + "group_positive": "699999999997/700000000000", + "group_scans_above_kappa": "348942378469/350000000000", + "halo_covers_generic_inverse_radius": "5", + "improvement_over_user_baseline": "645402690400418148631/500000000000000000000000", + "lambda_above_internal": "1/1400000000000", + "lambda_above_sigma": "3/1400000000000", + "lambda_above_tau": "1/1400000000000", + "lambda_prime_above_lambda": "1/1400000000000", + "lambda_prime_above_leaf": "279576951387/98000000000000000000000", + "leaf_saving_above_effective": "139576951387/98000000000000000000000", + "main_transform_above_kappa": "2097884756937/490000000000000000000000", + "membership_arithmetic_fits_record": "1/700000000000", + "microbox_face_corrections_above_kappa": "3368617797309/43750000000", + "microbox_halo_volume": "55300000000003/700000000000", + "new_complex_uniform_saving_above_b": "1/700000000000", + "new_semantic_guard_with_C1_one": "1/700000000000", + "polynomial_products_above_kappa": "697884756939/700000000000", + "positive_layout_slack": "1/700000000000", + "q_below_effective": "1/700000000000", + "q_below_internal": "1/700000000000", + "q_below_leaf": "279576951387/98000000000000000000000", + "q_positive": "2115243063/700000000000", + "short_record_fallback": "139576951387/140000000000", + "source_axis_superpolynomial": "1/700000000000", + "sparse_union_movement_above_kappa": "199062500002797884756937/490000000000000000000000", + "stop_below_one": "699999999999/700000000000", + "stop_positive": "1/700000000000", + "strassen_integer_power_gap": "1951441519231", + "support_router_span": "3/700000000000", + "theta_positive_polynomial_power": "2", + "union_header_fits_record": "3/700000000000", + "union_tag_work_per_visit_fits_record": "3/700000000000" + } + }, + "paid": { + "1": 41298, + "16": 448, + "2": 7416, + "24": 448, + "3": 9180, + "32": 448, + "4": 2286, + "40": 448, + "48": 448, + "5": 720, + "56": 448, + "64": 448, + "72": 224, + "8": 144 + }, + "paid_calls": 64404, + "productive_fields": 10928, + "rank_mass_surplus": 752, + "raw_root_interval": [ + "302177587077/100000000000000", + "151088793539/50000000000000" + ], + "scope": "Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.", + "source_sha256": { + "research/fresh-helper-boundary/native.py": "9b55a2d3c3972148fae9d112e745d9244968166bd89bd900c938f429fc76ab29", + "research/higher-moment-strictification/verify.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326", + "research/joint-helper-lattice/CONTROLLER.json": "1f5d6aa267e4e66048818714b5d3b5eae17a58abe91d15deeaa34574f7391a5f", + "research/joint-helper-lattice/native_joint.py": "50869b1bcad7493e6b4cb2a4cd5d2fd9a193a5921100483fa2c3f2c999ddfd46", + "research/joint-helper-lattice/verify.py": "8eb13f77a94315f811612cb557a17edeecb6b9d9a75dfa238b112dd6520c336f", + "research/kappa-0023-productive-jobs/dependencies/kappa-next-regime/bit-compression/carrier-reuse/reference/joint_pair_dag.py": "8a0de761642d21919e969475c3f13e5d01a4bae7343c1e1f37c586d94b676a85", + "research/kappa-rebuild/architecture/mixed_target_probe.py": "011c3c9d0cf81103dc84d709a0e36793eb7c5ae3f23c85eac27650ef13afa04a", + "research/kappa-rebuild/bit/complex_controller_factor.py": "1de9aaf918e6a4f2f5448754c1f3c3da3b85e6257849ebd097af09859c4e5497", + "research/kappa-rebuild/bit/mixed_productive_bit.py": "b32291b0db7fc0d332ec444c70746ab0fb03351d2e50546f8bcb64060e3ff95e", + "research/kappa-round6-compiler-tightening-20261022/arithmetic.py": "960864e5427a1ca2c319a7b2dee292b6fe50bd5964830031e611591af10dac38", + "research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py": "d097e55f06c3f244f2074ffd7c1a0a5f3c4b4b6a6accf9619d1dde5c0ae85e15", + "research/query-thinned-controllers/RESULT.json": "6ebfc8c0f09166f4834e9d7427410cb31aefff2cd4d4ce588c8e52c9c70e9a0f", + "research/query-thinned-controllers/controller.py": "8b462d660487b1be4940357c4c7522967b1bfaede3c02b1c66109b85acae0fd2" + }, + "status": "PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE", + "strictification": { + "alpha": { + "lower": "0.999999999936687383304469699479", + "upper": "0.999999999936687383304469699480" + }, + "cutoff": 20, + "delta": { + "lower": "0.958285308639504859158849914083", + "upper": "0.958285308639504859158849914084" + }, + "floor": 21, + "gamma": { + "lower": "0.956217509753795293454516855483", + "upper": "0.956217509753795293454516855484" + }, + "normalized_paid_upper": "104857600097656251/104857601073741824", + "power": 1024, + "tail_offset": "1/5", + "tested": "302177581/100000000000" + }, + "targets": { + "145": 224, + "17": 448, + "25": 448, + "33": 448, + "4": 504, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "7": 126, + "73": 224, + "8": 846, + "9": 5868 + } +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md new file mode 100644 index 0000000000..4badb40f09 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__FINITE-PRECOMPILATION.md @@ -0,0 +1,313 @@ +# Finite precompilation of a mixed-target rule + +Status: constructive bridge under the precise native hypotheses below, +independently audited in `../transfer-audit/AUDIT.md`. This is a written +argument, not a formal proof or a completed integer-multiplication admission. +The companion finite scheduler checks actual integer flow and ordering. +The original immediate-normalization BIT interface failed hypothesis 3. +`../bit/DELAYED-COVER-BRIDGE.md` supplies the distinct delayed-cover +implementation, with a finite local-ring check and the native binding in +`../bit/BIT-P3-NATIVE-BINDING.json`. Its fixed rational cover routes are a +costed program schema, not dense coordinate gates in a plain native word. + +Substantial OpenAI assistance. Apache-2.0. The mixed-target asymptotic flow is +Jacob Alan Sussman's Theorem 1G, PR4268, with the detailed proof at commit +`563b4e6e913625637f36ba7869bf5fcd0dd4975a` of +[`wht-power-saving-lean`](https://github.com/jacobalansussman/wht-power-saving-lean). +The source, exact scheduling code and notices are preserved under `sources/`. +The contribution proposed here is clearing the finite flow into a single +uniform native supplier before applying the inherited outer theorem. + +## 1. What needs to be assumed + +Let a job of rank `s` apply a specified tensor operator to `s` selected +coordinate blocks of one array, fixing all other coordinates. A block has +an arbitrary positive tensor multiplicity `f`. A completed rank `s` job +therefore acts on `s*f` axes. All productive inputs are arbitrary. + +Fix one mixed unit with productive targets `W_k` of ranks `k`, a chronological +list of paid child ranks `r_j`, and a finite number of scalar and routing +passes. These assumptions are required, separately from the moment inequality: + +1. **An all-column native word.** At every integer column count `c`, the unit + computes exactly its independent rank `k*c` output jobs. Its paid rounds + are rank `r_j*c` jobs in the stated order. All borrowed data return to the + declared endpoint, and owned storage is explicitly initialized and erased. + Its finite operation count is uniform in `c`. +2. **Disjoint splitting and spectators.** A rank `a+b` job is a rank `a` job + followed by a rank `b` job on disjoint coordinates. The resulting programs + preserve arbitrary complete spectator fields and accept arbitrary data. +3. **Whole-job adapters.** Any job passed between two units has an explicitly + priced, permitted embedding into its destination. For the intended complex + application these are fixed monomial binary address maps and unit quadratic + phases, together with role permutations. The adapters must work at every + tensor multiplicity. Rank equality by itself is insufficient. +4. **Finite-program closure.** A finite composition of these words and + adapters is again a permitted finite supplier. Constantly many owned fields + may be supplied with their full cost and no productive output credit. + The eventual ordinary recursion must have the same arbitrary-input, + restoration, scalar and precision interface as the retained supplier. + +Put `m=max{k:W_k>0}`, `k_min=min{k:W_k>0}`, and +`r_max=max{r_j}`. Require `r_max g*S`, keeps one +external weight throughout the entire finite circuit, and lowers only its +final rank-one leaves. All rational matchers, role routes and their inverses +are fixed before choosing the odd prime and its exclusions. Every route +uses complete equal-multiplicity cover fibers and the retained, costed row +permutation primitive. This gives the same finite DAG argument in the +rational-cover program category. The BIT binding supplies the actual native +projectors; a rank count alone would not provide this implementation. + +## 2. Proposed conclusion + +Suppose the preceding hypotheses hold and the mixed balance has root +`tau` in `(0,1)`: + +``` +sum_j r_j^tau = sum_k W_k k^tau. +``` + +For every `z` with `tau=2`, a fixed number `B_N` of productive arrays, +and only rank-one paid children, whose number `P_N` satisfies + +``` +P_N < B_N * N^z. +``` + +Every productive output is the full rank-`N` job. The construction may have +an enormous finite scalar word, role inventory and owned-storage requirement. +Those quantities affect constants and the eventual input threshold. They are +not omitted and are not credited as extra output jobs. + +If this uniform supplier is admitted under the retained native, precision and +fixed-tape premises, the existing uniform recursion applies directly. A new +dynamic RAM-to-Turing-machine simulation is not being assumed here. + +## 3. The integer lockstep flow at a fixed rank + +This is the part of Theorem 1G used by the compiler. At one fixed top rank +`N`, its units, source jobs and exit jobs have integer multiplicities. +For a multi-index `a` on the target types define + +``` +c(a) = product_k k^(a_k), +u(a) = multinomial(|a|;a) * product_k W_k^(a_k). +``` + +The exact Pascal identity is + +``` +u(b) = sum_{k:b_k>0} W_k*u(b-e_k). +``` + +Let `G` be the largest `|a|` with `m*c(a)<=N`. A class is indexed by a +sequence of paid rounds `s` of length `d<=G`; its dilation is +`rho_s=product r_j`. It contains `u(a)` units at column `rho_s*c(a)` for +each `a` with `|a|=G-d` and `m*rho_s*c(a)<=N`. + +For one parent paid round, the Pascal bijection matches its job copies to +target roles of the child class, at exactly equal integer ranks. Missing +demands are top sources. Separation ensures every parent job is consumed. +The source ranks lie in `(N/m,N]`; only the deepest classes produce exit +jobs, all strictly smaller than `N` once `N` is outside the finite base range. + +Process a class in word order. At round `j`, suspend every unit of that +class, complete the entire child class fed by that round, and only then +advance the parents to round `j+1`. This forbids a unit from requiring both +an earlier and a later round of the same suspended parent. The resulting +dependency graph is finite and acyclic. Its edges carry complete array jobs, +not individual scalar values copied for free. + +These integer quantities exist before normalizing the sources to total +weight one. Let `S_s` be the number of source jobs of rank `s`, let +`S=sum_s S_s`, and let the ordered exit batches be `(e,t)` with `t` jobs +of rank `e` each. This finite integer flow is the compiler input. + +## 4. Clear every batch denominator constructively + +Induct on the integer top rank `N`. For each smaller rank `e` the compiler +has already constructed a uniform program on `B_e` arbitrary arrays, +computing full rank `e` with `P_e` paid rank-one calls. For a sufficiently +small rank use the ordinary sequential program: `B_e=1`, `P_e=e`. + +For the current flow choose an integer `a` divisible by every `B_e` needed +for an exit and every `B_(N-s)` needed for a nonzero source remainder. +The product of those finitely many positive integers is a valid choice; +their least common multiple is a smaller optional choice. Set + +``` +B_N = a*S. +``` + +Assign `a*S_s` of the input arrays to each source rank `s`. On each of those +arrays, first complete its `N-s` complementary coordinates using the +already-compiled smaller uniform program. All such batches are integral +because `a` is divisible by their program widths. This preliminary action +commutes with the intended `s`-coordinate job and fixes its input coordinates. + +Make `a` copies of the integer lockstep flow. Route its source arrays to +their exact input slots using permitted whole-array adapters. At a deepest +exit batch, `a*t` is divisible by `B_e`; replace that batch by copies of +the smaller uniform rank-`e` program. Restore its role ordering and adapters +before resuming the suspended parent class. Execute the finite DAG in the +lockstep order, and finally restore the original source-array ordering. + +Every array has now received its disjoint complementary job and source job, +hence the full rank-`N` transform. No copied scalar input or blank helper is +treated as another independent output. Every original array occurs exactly +once as a source; interior target slots are jobs on those arrays, not new +productive inputs. + +Induction removes all recursive calls: the only remaining paid children +have rank one. Clearing denominators multiplies productive arrays and paid +operations equally, so it preserves the per-array leaf count. In formulas, + +``` +P_N/B_N = (1/S) * [ + sum_s S_s * (P_(N-s)/B_(N-s)) + + sum_(ordered exit batches e,t) t * (P_e/B_e) +]. +``` + +Zero-rank terms vanish. Any plain rank-one exits are the ordinary base +program. Scalar and routing passes have their own analogous nonnegative +count and must be included in the asymptotic cost used to choose `N`. + +This construction uses full integer batches; it does not assume that +fractional pieces of a physical array can be routed at zero cost. Its exact +replication factors can be impractically large, which is acceptable for a +fixed finite supplier existence statement but must be disclosed. + +## 5. Why some fixed N has the required saving + +The independent audit sharpened this step to a direct count of paid leaves. +It does not require a running-time comparison between a RAM flow and native +tapes. Let `L(n)=P_n/B_n`, let `w_s=S_s/S`, and let `x_e` be the exit counts +normalized by the number S of source arrays. The actual integer compiler +satisfies + +``` +L(n) = sum_s w_s L(n-s) + sum_e x_e L(e), +sum_s w_s = 1, +sum_e x_e e^tau = sum_s w_s s^tau. +``` + +The last equality follows by canceling every internal matched job in the +exact tau-potential balance. The source ranks satisfy `n/m0`, concavity gives + +``` +n^z0 - sum_s w_s (n-s)^z0 >= eta * sum_s w_s s^z0. +``` + +Indeed, for `t=s/n` in `[1/m,1]`, +`1-(1-t)^z0 >= z0*t >= eta*t^z0`. For every sufficiently large n the +exit coefficient is less than `eta/2`. Every complement and exit has +smaller rank than n, so strong induction on the exact recurrence proves +`L(n)<=A*n^z0`, with finite A chosen to cover the smaller ranks. Eventually +`L(N)= 2`; +* `W` productive arrays, each receiving the **full** rank-`N` transform; +* `P` rank-one paid children; +* `U` copies of the mixed unit in the completely expanded finite word; +* at most `O=U` owned centers, conservatively one per mixed-unit instance. + +For every rational `z` strictly above the mixed root and below one, the +constructive count argument provides an `N` with `P < W*N^z`. +“Finite” here means fixed before the eventual multiplication input grows. +It can be astronomically large. Neither this note nor the receipts claim +to have materialized the winning near-threshold instance. The later +`../controller/EXPLICIT-TEMPLATE-BOUNDS.md` strengthens the existence +argument to the specified complex rank `N=2^276540184361`, with uniform +saving `0.002304`; no search for a successful rank is left unperformed. +The integer recursion defines its exact finite `W,P,U`, and the constants +below are computable functions of that finite result. + +The fully materialized, depth-zero `N=57` example has `W=2242`, `P=127570`, +and `U=1`. It is a useful independent check that complementary source jobs +are really paid: `57*2242-127570=224`. This small example is not claimed to +attain the limiting mixed exponent. + +## 2. Every column count and every complete spectator field + +The local logical identities were replayed in a free noncommuting operator +word algebra. Apart from rational scalar arithmetic, the checker uses only +composition and cancellation of an operator with its recorded inverse. +For any positive integer `f`, substitute the `f`-column physical operator +for each such generator. This extends to an algebra homomorphism on the +free word algebra and preserves the checked identities. + +This is not the false assertion that tensor power is additive on arbitrary +matrix sums. The role-level scalar word is unchanged. Each physical address +generator is replaced by its column lift, while its formal products and +linear combinations are evaluated on the same independent role arrays. + +A rank-zero native monomial has the form + +``` +|x> -> i^(a+q(x)) |M*x+b>, +``` + +with invertible binary `M` and a permitted quadratic phase `q`. Its column +lift has blockwise address map `M`, translation `b` in every column, and +phase `a*f + sum_j q(x_j)` modulo four. This explicitly retains the absolute +phase. A fixed coordinate matcher in the precompiler becomes the same +fixed permutation of `f`-axis blocks. All untouched axes remain complete +spectator fields. A rank-one leaf becomes the standard rank-`f` child. + +The retained exact Clifford normal form supplies the monomial factors +around each child. The independent p3 audit checks the whole main boundary, +including the output translations required by negative powers of `C_q`. +The fixed THREE/base selection is valid for every column count: THREE/base +and THREE/extra have identical entrance and exit operators; their difference +is an internal frame and its associated warps. No layer-dependent selector +is required for the endpoint contract. + +For any integer input width `e=N*f+r`, first apply the `r=2`, `B=P+E`, and `E>=64`, + +``` +2*B*(N-1) >= P+E, +2*B*f+P*f+E <= 2*B*N*f <= 2*B*e. +``` + +Induction gives `A(e)<=2B e`. Completed disjoint selected-axis pieces have +total width at most `d`. The retained prefix kernels, outer phases and +normalization add at most `18d`, giving + +``` +A_layer <= (2*B+18)*d < C0*d. +``` + +Every calculation remains on one fixed fine grid. A child is never rounded, +compressed, or re-encoded at return. The change is to the proof's bound on a +completed value, not to its stored representation. Other fields remain +parked while the child executes. This is why the linear semantic bound +survives a huge scalar word and why the older pathwise `C1>1` estimate is +unnecessary. + +The stopping rule can be any fixed rational `0=2N`, every internal call has the required positive `f`; +the completed-leaf estimate remains `8e` at the stopping leaves. No old +numerical cutoff is carried over. + +### An effective threshold, including enormous constants + +Suppose `d<=c*p^epsilon`, with fixed `c>=1` and rational +`epsilon=a/b` in `(0,1)`. Let `L` be the binary bit length of +`4*C0*ceil(c)` and choose + +``` +t = max(4, ceil(b*L/(b-a))), p0 = 2^t. +``` + +For all `p>=p0`, `p^(1-epsilon)>4*C0*c`, so the integer guard +`Delta=C0*d` is at most `p/4`. Signed components with `p+Delta` fractional +bits and `Delta+3` magnitude/sign bits have width + +``` +p+2*Delta+3 <= 2p. +``` + +The audit emits `p0` as a compressed power of two. It does not try to +allocate that many bits. This construction proves the eventual `O(p)` word +bound for the new finite template, including the current outer choice +`epsilon=99999/100000`. Huge fixed constants change `p0`, not `C1` or the +power in the final exponent inequalities. + +## 5. Productive stock, owned storage, and native tape closure + +For the ordinary uniform complex word, let + +``` +D(e)=0 if e=W^D(d)` for `K>=1`. Pad complete rows once to the next multiple +of `W^D(d)`. The padding factor is below two. Every descendant then has +exactly `1/W` of its parent's productive volume and enough divisibility for +its remaining depth, with complete active, control and spectator fields. +All-row endpoint correctness restores appended zero rows to zero. + +Owned storage contributes no factor to productive output credit. A safe +choice is one full center field per finite mixed-unit instance, namely +`O=U`. At an ordinary recursion node each such field has the same shape as +one productive role stream, of volume `V/W`. Initialize, retain and clear +it as its actual word prescribes. If simultaneously suspended units keep +live centers, they receive distinct banks. Reusing one bank per recursion +depth would not suffice. Owned-space scans and parking cost fixed multiples +of volume; paid calls on those banks are already in `P`. + +The integer audit checks row divisibility and one-time padding at several +floor-depth boundaries. It also gives an explicit sufficient threshold +for `q0= 1, +u >= C, sigma = t+u >= 1, +J = c^v, L = b^v. +``` + +The bases c,b and the power v are integers, so L and J are exact integer +ranks. All moments here are finite sums over the actual rank inventory. + +For any original paid rank R>J, write R=qJ+r with 0<=r= 1`; this is why sigma must be at +least one. Keeping the original P_t^v as an overcount for all unsplit calls +gives total original-paid charge at most + +``` +P_t^v + 2 P_(t+u)^v / J^u. +``` + +For a completion D=L−K with 0=1 and logarithm power p=1/q. +Its proof only needs the logarithmic factor to be increasing. The same +argument works for **any real p>0**, including p>1, which is useful when +the separated unit's ambient rank m is itself large. + +Assume the finite source/exit compiler in +[FINITE-PRECOMPILATION.md](vendor/FINITE-PRECOMPILATION.md). Write +`L(n)=P_n/B_n`, with ordinary base `L(n)=n` for `0<=n=m its exact +integer-batch construction gives + +``` +L(n) = sum_s w_s L(n−s) + sum_e x_e L(e), +sum_s w_s = 1, n/m < s <= n, +sum_e x_e e^t <= sum_s w_s s^t, +e <= r_max (n/m)^theta < n, +theta = log(r_max)/log(k_min) < 1. +``` + +Choose `theta < theta_bar=a/b < 1` and p>0 with + +``` +2^(b−a) r_max^b <= m^a, +theta_bar^p < eta = t m^(t−1), +m^(1−t) < 2^p. +``` + +Then **`L(n) <= n^t (1+log2(n))^p` for every integer n>=1**; define the +right side to be zero at n=0. + +For 2<=n=m put `A(n)=(1+log2(n))^p`. The shifted logarithm +condition gives `A(e) <= theta_bar^p A(n)` for every exit, hence + +``` +sum_e x_e e^t A(e) <= theta_bar^p A(n) sum_s w_s s^t. +``` + +For y=s/n>1/m, concavity of x^t gives +`1−(1−y)^t >= t y >= eta y^t`. Since A is increasing, the source complement +capacity obeys + +``` +n^t A(n) − sum_s w_s (n−s)^t A(n−s) + >= eta A(n) sum_s w_s s^t, +``` + +with zero-rank complements treated separately. The strict inequality +`theta_bar^p < eta` closes strong induction. This uses no concavity of A +and introduces no unknown multiplicative constant. + +This is available for every separated unit with the stated t-superpotential. +Choose rational theta_bar sufficiently close to one: since r_max max((1−t)*log2(m), log(eta)/log(theta_bar)) +``` + +satisfies the other two conditions. Thus the leaf-count estimate has the +general form `L(n) <= n^t (1+log2(n))^p` with an effective fixed p. At fixed +p, a target gap z−t requires a sufficient H of order +`(p/(z−t))*log(p/(z−t))`. This concerns normalized rank-one leaf counts in +the finite compiler; it does not bound full word size or physical runtime. + +The compiler's integral batch replication, arbitrary original arrays, +whole-job routing and finite owned-bank allocation are unchanged. With +N=2^H and desired uniform exponent z>t, the final sufficient condition is + +``` +(1+H)^p < 2^((z−t)H). +``` + +For the new p7 unit, take `theta_bar=6/7`, `p=13`. Exact tests give + +``` +10^7 < 15^6, +2*(10^150)^7 <= (121^150)^6, +eta > 0.144386809622024146828684313913 > (6/7)^13, +(121^150)^C < 6.907234273066686405887998346943 < 2^13. +``` + +The smaller logarithmic power 12 fails the stated eta condition. Let +`z−t = 1/700000000`, exactly the uniform-saving slack already used by +PR4416's outer point. The rank **N=2^349300000000** satisfies + +``` +349300000001^13 < 2^499. +``` + +The preceding grid point H=348600000000 fails its corresponding comparison +with 2^498. This is the first successful multiple of 700,000,000 for this +majorant: the function `(z−t)H ln(2) − p ln(1+H)` is strictly convex, starts +at zero with negative derivative, and has just one positive zero. This +does not certify a minimum native program. + +To separate the two contributions, retaining the older power majorant on +the new v=150 unit already gives `H0=37443877100` and +`H1=140829080288374101`. That is about a 115× reduction in the exponent +from the changed tail/rank separation alone. The logarithmic majorant then +reduces that exponent by a further factor of about 403,175. + +## 5. Complete consumer and finite constants + +The complex uniform saving is **376107/140000000**, approximately +0.00268647857142857. This is exactly PR4416's uniform endpoint; neither +its tested saving nor its outer parameters change. Put + +``` +kappa = 0.00268647, d=(0.00268648−kappa)/7 = 1/700000000, +uniform = kappa+6d, b_outer = kappa+5d, +a_outer = kappa+4d, q_outer = kappa+3d, +epsilon=1−d, beta=1−3d, r0=d/10, stop=layout=d, +ordinary_BIT_saving=0.0027. +``` + +The checker replays the byte-pinned PR4405/PR4416 parameter ledger and +requires exact equality with all saved p7 parameters, nine rows, 54 checks +and three extra guards. It separately executes only the historical +`check_ledger.py` ledger function and its comparison constants as another +oracle: all nine rows agree and all 63 predicates remain strict. Its derived +grid/backoff is recorded explicitly; the old m=73 admission code is not run. +The minimum nine-row saving minus κ is exactly +`524529867/122500000000000000`. + +Mutations close epsilon, remove layout funding, raise unfunded κ, close +the uniform gap, underfund BIT, add an old per-axis scan or make group width +equal to global dimension. Each must fail its relevant ledger. + +The newly compiled word supplies its **own** finite constants. If U counts +actual raw p7 instances, allocate U distinct owned centers. Let W be the +final productive width, P the paid rank-one count, and R the full native +record/normalizer count including completion, splits and compiler routes. +As in the pinned closure argument, use + +``` +G = 2490856*U + 8*R, Z = W+U, +E = 64*(Z+N+P+G+1)^3, +B_constant = P+E, C0 = 32*N*B_constant^2. +``` + +Pay actual coordinate movement separately. Retain every owned center until +its creating unit erases it; centers are excluded from productive W. +The fixed-word recurrence and eventual constant absorption have the source +form, with these newly expanded counts substituted. Numerical full-word +counts, denominator heights and practical precision thresholds are not +computed here. Neither a smaller N nor a favorable moment supplies an +independent proof of the inherited physical/analytic premises. + +## 6. Reproduction, provenance and coverage + +Python 3.12, standard library only, from the repository root: + +```sh +python3.12 -B research/higher-moment-strictification/verify.py +python3.12 -B scripts/research_package.py --package research/higher-moment-strictification --check-only +python3.12 -B scripts/research_package.py --package research/higher-moment-strictification +``` + +To generate a fresh receipt, use `verify.py --out /absolute/new/path.json`. +The saved [RESULT.json](RESULT.json) records all intervals, finite parameters, +integer comparisons, ledgers, controls and source/verifier hashes. + +Logarithms use 80 exact terms of the binary-reduced atanh series with the +geometric tail. Exponentials use 64 terms after binary scaling into [0,1/2], +outward rounding at precision 2^−192, twice the next term for the remaining +tail, and outward repeated squaring. Negative arguments use reciprocal +intervals. Every decision uses fractions or integers, with no floating-point +acceptance test. A separate exact small product/pad/split example checks +the inventory and preserved surplus, and a sublinear-tail counterexample +guards the theorem's exponent restriction. + +Canonical base is `12fa8c5c844be21bfefb38a19503fbd867a11244`, priority revision +7. [SOURCES.json](SOURCES.json) pins the orientation metadata. The 15 unchanged +exports in [VENDOR.json](VENDOR.json) include complete source paths, commit +IDs, Git blob names and SHA256 hashes; the verifier authenticates both hashes +without requiring Git. Pending commits are represented by self-contained +exports, not implied publication ancestry. Source exports remain unchanged. + +The PR4426 invoice oracle is compiled from its authenticated source bytes, +with only ROOT and PHASES rebound to the exported file locations. Its literal +controller, supplier-receipt and port-recipe checks remain intact. The two +ledger oracles retain predecessor code and attribution; they are arithmetic +cross-checks, not fresh native supplier admission. + +Local validation used Python 3.12.8 on macOS arm64. The registered replay, +metadata/pin check and committed-byte preflight passed. A separate Git-free +copy passed `python3.12 -I -O -B verify.py` in 0.333 seconds; changed-source +and changed-receipt controls rejected. The optional full source-history +preflight could not run because this checkout is shallow. All pending-source +inputs are self-contained exports; standalone replay does not need those +foreign Git objects. No Lean, Docker, native all-size or historical suite was +run. These checks authenticate the stated result, not independent scientific +acceptance. + +Overlap at 18:19 UTC covered 536 open PR bodies and 3,279 discussion/comment +records with complete reported pagination, plus local notes. The newer +#4420/#4428/#4429 checks cover earlier strictification proof/arithmetic and +slightly smaller sufficient powers; #4426 supplies the invoice replay reused +here. No remote closed-PR-body or arbitrary code-diff search was performed. +The task metadata records the changed scope and remaining direct-compiler +question. Submission was authorized after local review; no Discussion claim was posted. + +## Open next questions + +1. **A direct compiler for overlapping ranks.** A finite acyclic integer + schedule would remove strictification altogether. Start by replacing the + Pascal matching step when a paid rank exceeds a target rank, retaining + arbitrary inputs, complements and chronological suspension. No such + termination/matching proof is supplied by the mixed moment alone. +2. **Full finite-word size and precision.** Derive compressed upper bounds + for the compiler's batch denominators, widths, scalar passes and owned + instances at the specified rank. Ambient rank is only one size parameter; + this remains the main barrier to assessing practical constants. +3. **Independent scientific review.** Check the higher-moment inequality, + the p>1 induction and the native product/adapters at their actual callers. + The unchanged raw supplier's internal paid bill and all-column/physical + premises remain separate inherited obligations. Another search of nearby + c,b,u,v values would not resolve those obligations. + +Prepared by zxv with substantial OpenAI Codex assistance in discovery, +implementation and writing. No subagents or independent human review were +used for this new work. New material is Apache-2.0. Native/controller lineage: +zxv's PR4359 and its retained contributors. Product/padding and p7 controller: +@1337isnot1337's PR4412/PR4414/PR4416. Integer mixed flow: Jacob Alan +Sussman, Theorem 1G. Logarithmic-majorant predecessor: zxv's PR4411. +Invoice replay: Ryanson Jonathan / @pinterbanget, PR4426, with Claude Code +assistance and Apache-2.0. The retained supplier and outer sources preserve +their original contributor credit and notices. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json new file mode 100644 index 0000000000..d7b3f98981 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__PROOF-SOURCES.json @@ -0,0 +1,16 @@ +{ + "predecessor_sha256": { + "research/kappa-round3-warp-lean-20261022/CompilerCapacity.lean": "e5ad04cc3d89588e4f464673170d2bad8316de22fa064e7300ee71eb63b0cb6d", + "research/kappa-round3-warp-lean-20261022/KappaWarpVerification.lean": "986701ba85faa746e449ab9abe87afc0d8c8eb0e09051f3f5feac44ffb69893d", + "research/kappa-round3-warp-lean-20261022/generate_arithmetic.py": "41e757e1be70a289a17ecb93e6f62ad5e4be01053f0264eafd54ef2e7c5c732f", + "research/kappa-round3-warp-lean-20261022/numerical_generate.py": "12af3b6d21a798a60f82fbd130e93179edf2803c50fef4950681c9d3b8c1b377" + }, + "preparation_script_sha256": "681bdc36406ba04001d363c03540121730c4d35ee76b1f1df232240cb7845fc6", + "prepared_sha256": { + "TightenedArithmetic.lean": "bfa7e33d37adf346372b5825ad3b77dffaae5e9983f93cd2bc94c929479d60e8", + "TightenedCapacity.lean": "cb23f5679e7372a117b82aebadf10fdb6817a14013a823113b1e0aaca279759d", + "TightenedNumerical.lean": "404dc8acc3e87df52a44367dd534d6228894d3f38119a905e15e97d9c1470725", + "TightenedVerification.lean": "e399fbad280bba4b0447dc14fa44280f5ebf1557acbc63ca7564dd0a8925abb1" + }, + "status": "GENERATED_WITNESSES_PENDING_LEAN" +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md new file mode 100644 index 0000000000..6f822f33cc --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__ROUND6-README.md @@ -0,0 +1,137 @@ +# Conditional kappa 0.0030217758: a smaller finite compiler reserve + +TL;DR: the same admitted native word and complete p16 profile support +**kappa = 15108879/5000000000 = 0.0030217758**, an increase of +**0.0000000158** over PR4610's frozen 0.00302176 checkpoint. This is a +numerical/compiler tightening. The native construction and its raw moment +crossing have not improved. The complete conditional claim still depends on +the predecessor native, compiler, tape, precision and recovery hypotheses. + +Cao Yifan, with substantial OpenAI Codex assistance. Apache-2.0; predecessor +notices and attribution are retained. + +## What changes + +The tested saving is **0.00302177581**, strictly greater than the claimed +kappa. The contraction reserve decreases from `1e-9` to `1e-11`. The existing +power 1024, cutoff 20, completion floor 21, tail offset 1/5, tail coefficient +97/100, complement factor 63/64 and logarithm power 1000 are retained. + +Two exact interval implementations place the unchanged raw crossing in +`(0.00302177587077, 0.00302177587078)`. This crossing is not the claimed +compiler saving. At the new tested saving the paid/target ratio is below +`0.999999999936687383304469699480`, leaving more than the new reserve. +The real contraction proof separately includes that reserve. + +The complete controller still has **64,404 paid calls** and **10,928 productive +fields**. Its local paid profile is `{1:2201,2:412,3:510,4:127,5:40,8:8}`; +the complete helper census is `{4:28,7:7,8:47,9:326}`. The numerical proof's +literal complete profiles are checked against this controller. The aggregate +Lean theorem binds them to the actual finite native census and helper endpoints. + +The strict outer gap is `1/700000000000`. Recomputing the whole finite compiler +gives `j=55099`, `H=38569300000000000` and `N=2^38569300000000000`. +Lean checks `(H+1)^1000 < 2^55099`; the preceding integer fails the corresponding +test. The expanded algorithmic word is not materialized. Its uniform saving is +`1057621533/350000000000`, still strictly greater than the claimed kappa. + +`arithmetic.py` is a readable four-replacement derivative of the frozen exact +engine, recorded in `ARITHMETIC-SOURCE-PATCH.json`. Its inherited status/scope +strings use the predecessor's "changed profile" wording; in this package the +profile is unchanged. `ARITHMETIC.json` records full recomputation, both charged +tails, capacity, all 54 strict outer predicates and four functional predicates. +No paid call, completion or routing charge is removed. + +## Proof and audit boundaries + +The four fresh modules are `TightenedNumerical`, `TightenedArithmetic`, +`TightenedCapacity` and `TightenedVerification`. They expose 31 axiom reports. +The authority for their completed replay is status +`PASS_TIGHTENED_SCOPED_LEAN_CERTIFICATES` in `LEAN-VERIFICATION.json`, genuine +logs and their source/object hashes. The replay uses Lean 4.21.0 and mathlib +`308445d7985027f538e281e18df29ca16ede2ba3`, checks source syntax and admits +only `propext`, `Classical.choice` and `Quot.sound` in printed axiom reports. +The larger integer test uses a 256 MiB Lean thread stack; kernel checking is +retained. + +Native and strict-concavity modules are **explicitly reused** from the frozen +round3 proof package. Their actual source, log, object and dependency hashes, +compile commands, axiom reports, 49 external input pins and runtime are checked. +The new receipt lists this reuse separately from the four fresh compilations. +It does not claim another fresh replay of the native word. The payload remains +`cfcd36b40326d7a5815e1db5313444379b3fb756b27d5201c561574c085cc0dd`. + +`audit/` supplies a separately implemented AI arithmetic audit. It reconstructs +the controller from the admitted native counts, checks exact interval signs, +tails, compiler capacity, the finite integer threshold and source outer +formulas. It is not independent human attestation. + +These are scoped Lean certificates, not an end-to-end Lean theorem about +integer multiplication. JSON transcription, native amplitudes, absolute phases +and free-group endpoint semantics remain explicit Python/proof boundaries. +Whole-job normalization, permitted owned erasure, physical fixed-tape execution, +precision, stock, analytic decomposition, prime avoidance and exact recovery +retain the predecessor hypotheses. The new arithmetic does not establish a +new physical admission lemma or a practical speedup. + +## Reproduce + +Use global Python 3.14 and the pinned Lean/mathlib setup documented in +`../kappa-round3-warp-lean-20261022/README.md`. From the repository root: + +```powershell +py -3.14 -B research/kappa-round6-compiler-tightening-20261022/arithmetic.py --native research/kappa-round3-warp-20261022/NATIVE-VALIDATION.json --kappa .0030217758 --out research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json +py -3.14 -B research/kappa-round6-compiler-tightening-20261022/prepare.py +py -3.14 -B research/kappa-round6-compiler-tightening-20261022/verify_lean.py +``` + +On this Windows host, invoke +`C:\Users\caoyi\AppData\Local\Python\pythoncore-3.14-64\python.exe` in place of +`py -3.14`; the installed launcher does not find that interpreter. On other +systems use the actual global Python 3.14 executable. + +The replay pins the Windows Lean executable used for these receipts. Checking +the sources with a compiler for another platform requires an explicit runtime +pin adaptation and a separate receipt. + +Compiled objects and toolchains are not committed. In a clean checkout first +compile the native dependency closure, without overwriting its published receipt: + +```powershell +py -3.14 -B research/kappa-round3-warp-lean-20261022/replay.py --only Native AnalyticGain --receipt LOCAL-NATIVE-REPLAY.json +py -3.14 -B research/kappa-round6-compiler-tightening-20261022/verify_lean.py --native-receipt research/kappa-round3-warp-lean-20261022/LOCAL-NATIVE-REPLAY.json +``` + +The first command rechecks the frozen native/phase inputs and generates a +partial native receipt; the second validates exactly that dependency closure +before compiling all four new modules. Runtime pins must match. Do not +regenerate source receipts concurrently with replay. Regeneration of unchanged +native receipts changes timing metadata and their hashes; preserve the frozen +receipts when reproducing this package. + +## Attribution + +This tightening uses Cao Yifan's already published PR4610 native word and +compiler certificates. It adds no new native supplier. Cinna Davis's PR4470, +Dugongue's transported frames, zxv's native/compiler work, Jacob Alan Sussman's +mixed-target recursion, Pierre-Loic Doulcet's concurrent helper-interface work +and their credited predecessors retain their original attribution. The earlier +0.00302152 and 0.00302176 packages remain frozen. + +Signed-off-by: Cao Yifan. Substantial OpenAI Codex assistance. + +## Open next questions + +- Can a changed scalar word or recursive interface increase the raw crossing? + Start with a concrete emitted word and its full arbitrary-helper contract. + The current paid profile and retained paired path are the limiting inputs; + numerical tightening alone cannot move their crossing. +- Can the complete compiler implication be formalized in Lean? First add the + native amplitude/absolute-phase semantics and a precise physical execution + contract, then connect them to the existing finite frame certificates. + The universal tape, precision and recovery premises remain external here. +- How close can this finite compiler approach the same raw crossing? First + balance contraction reserve against the charged completion term and improve + numerical enclosure precision if necessary. Every new choice needs fresh + tails, capacity, finite threshold and outer-formula checks; it would still + be a compiler refinement of the same native construction. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md new file mode 100644 index 0000000000..8ecfd3e4d0 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TENSOR.md @@ -0,0 +1,237 @@ +# Native tensor products with paid completion of small targets + +This construction applies to the all-fresh p7/keep232127 native word in +`NATIVE.md`. It retains the source all-column arbitrary-input semantics, +complete spectators, whole-job matchers, finite-program closure and integer +uniform compiler. The local word and controller come from zxv's PR4359; +the integer compiler is Jacob Alan Sussman's Theorem 1G. The tensor product +construction follows PR4414. Apache-2.0; substantial OpenAI/Codex assistance. + +The new step is to complete small productive endpoints before choosing the +paid-rank cutoff. The enormous finite program is specified algorithmically; +it has not been materialized. Finite moment checks do not prove the inherited +analytic, precision, storage, fixed-tape or recovery premises. The selected +frontier is unchanged. + +## 1. Chronological native product + +Let U have productive ranks k_i and chronological paid ranks r_l, and V +have productive ranks h_j and paid ranks s_a. Their ambient ranks equal +their maximum productive ranks and contain every paid job. Work in the +product ambient space, retaining every unused coordinate as an arbitrary +spectator. + +For each role j of V, instantiate a separate U copy at column count h_j. +Its independent arbitrary productive fields have labels (i,j). Give each +copy its own initialized, erased and uncredited center banks. Run these +copies in lockstep through their common scalar and paid-call list. + +At paid position l, pause all copies. Copy j requests a rank r_l*h_j job +on its current physical owner. The owners are distinct across the copies; +they may include centers and may contain correlated values. Invoke V at +column count r_l on these j-indexed fields, using permitted role-specific +whole-job matchers. Its endpoints provide the requested ranks h_j*r_l. +Its owned centers have separate identities. Complete V and restore every +matcher before resuming the suspended U copies. Never combine different +paid positions of the same U copy. + +This is a finite acyclic chronological substitution. Arbitrary-input +correctness allows correlated data in distinct slots; no input is copied +to create productive credit. Its final targets have ranks k_i*h_j and its +remaining paid jobs have ranks r_l*s_a. Thus both moments multiply. +The same argument lifts at every further positive column multiplicity by +substitution of the fixed coordinate, phase and scalar generators. It does +not tensor a sum of matrix operators. + +For v copies of the p7 unit, write T_tau and P_tau for the raw target and +paid moments and B for the number of raw productive fields. The product +has B^v distinct productive fields, target moment T_tau^v, paid moment +P_tau^v, and ambient m^v where m=121. + +## 2. Paid completion on the actual productive owners + +Choose integers 1=L receive no completion. + +For precision about coordinates, conjugate the complete existing product +word by its permitted per-role whole-job normalizers: the inverse map is +applied to each input and the corresponding map to its final output. This +gives the canonical rank-K endpoint on that field. After the whole product +has finished, apply the positive transform on axes K,...,L-1. The disjoint +factors commute and give exactly the canonical rank-L endpoint. Restore +the external matchers where the surrounding interface requires them. +A map only on the output would not be a whole-job conjugation. + +Every field remains an arbitrary original productive input. There is no +new productive credit and no new owned bank. Since LJ by consecutive +jobs on disjoint axes of ranks J,...,J,r where R=qJ+r and 0<=rJ, its new charge satisfies + +``` +q*J^tau+r^tau <= R*J^(-C)+J^tau <= 2*R*J^(-C). +``` + +Retaining the original moment as an overcount for the lower paid jobs +therefore bounds the original paid part by + +``` +P_tau^v + 2*P_1^v/J^C. +``` + +For each added completion D=m_new the inherited exit estimate gives + +``` +m_new*E(x)/x <= r_max*m_new^h*x^(-h) + < 2^((111/26)*v)*x^(-h), +``` + +using 10<16=2^4 and 121<128=2^7. For a desired uniform exponent +z>t=1-C, put z0=(t+z)/2 and d=z0-t. The exact complement coefficient +eta=z0*m_new^(z0-1), with z0>1/2, satisfies + +``` +-log2(eta) < 1+7*v*(1-z0). +``` + +Thus rational sufficient choices are + +``` +H0 = ceil((((111/26)*v)*d+1+7*v*(1-z0))/(h*d)), +H1 = floor(H0*(1-z0)/(z-z0))+1, +N = 2^H1. +``` + +Check H0>=7v to cover all base ranks. Below the threshold, positive +rank-one surplus gives L(x)<=x. Above it, the source strong induction gives +L(x)<=A*x^z0 with A=(2^H0)^(1-z0). The strict H1 inequality then gives +L(N) decide (0 < p.2)) = true := by + apply List.all_eq_true.mpr + norm_num [outerSlacks, kappa, tested, complexUniformSaving, b, a, q, epsilon, beta, r0, stop, layout, bitSaving, oldBaseline, sigma, tau, internal, leaf, lam, capConstant, xi, key, margin_main_transform, margin_global_coordinate_router, margin_fused_gaussian, margin_group_bit_router, margin_group_scans, margin_boundary_algebraic_matrix, margin_sparse_union_movement, margin_polynomial_products, margin_microbox_face_corrections] +theorem outerSlacks_count : outerSlacks.length = 54 := by decide + +def functionalSlacks : List (String × ℚ) := [ + ("new_semantic_group_guard", (1 - beta)), + ("new_BIT_row_stock_sublinear_in_active_group", (beta * (1 - (3 / 1000)))), + ("fixed_halo_explicit_metadata_branch", ((((128 - 48) - epsilon) - beta) - 1)), + ("actual_new_BIT_stock_sublinear", beta*(1-(4/1000)))] +def functionalSlacksRecorded : List (String × ℚ) := [ + ("new_semantic_group_guard", (3 / 700000000000 : ℚ)), + ("new_BIT_row_stock_sublinear_in_active_group", (697899999997009 / 700000000000000 : ℚ)), + ("fixed_halo_explicit_metadata_branch", (13475000000001 / 175000000000 : ℚ)), + ("actual_new_BIT_stock_sublinear", (174299999999253 / 175000000000000 : ℚ))] +theorem functionalSlacks_source_equality : functionalSlacks = functionalSlacksRecorded := by + norm_num [functionalSlacks, functionalSlacksRecorded, kappa, tested, complexUniformSaving, b, a, q, epsilon, beta, r0, stop, layout, bitSaving, oldBaseline, sigma, tau, internal, leaf, lam, capConstant, xi, key, margin_main_transform, margin_global_coordinate_router, margin_fused_gaussian, margin_group_bit_router, margin_group_scans, margin_boundary_algebraic_matrix, margin_sparse_union_movement, margin_polynomial_products, margin_microbox_face_corrections] +theorem functionalSlacks_all_positive : functionalSlacks.all (fun p => decide (0 < p.2)) = true := by + apply List.all_eq_true.mpr + norm_num [functionalSlacks, kappa, tested, complexUniformSaving, b, a, q, epsilon, beta, r0, stop, layout, bitSaving, oldBaseline, sigma, tau, internal, leaf, lam, capConstant, xi, key, margin_main_transform, margin_global_coordinate_router, margin_fused_gaussian, margin_group_bit_router, margin_group_scans, margin_boundary_algebraic_matrix, margin_sparse_union_movement, margin_polynomial_products, margin_microbox_face_corrections] +theorem functionalSlacks_count : functionalSlacks.length = 4 := by decide + +theorem claimed_saving : kappa = 15108879/5000000000 := by + norm_num [kappa] +theorem strict_improvement : (9443/3125000 : ℚ) < kappa := by + norm_num [kappa] +theorem tested_above_kappa : kappa < tested := by + norm_num [kappa, tested] +theorem explicit_gap : (tested-kappa)/7 = (1/700000000000 : ℚ) := by + norm_num [kappa, tested] +theorem splitting_base_gap : (20:ℕ)^64 < 21^63 := by decide +theorem tail_decay : (97/100 : ℚ)^128 < 1/16 := by norm_num +theorem normalized_completion : (1/(1+1024*(1/100000000000))+4/(2:ℚ)^32) < 1 := by norm_num +theorem shifted_exit_capacity : 2*((20:ℕ)^1024)^64 ≤ ((145:ℕ)^1024)^63 := by decide +theorem finite_threshold : 700000000000*55099 = (38569300000000000:ℕ) := by decide +theorem finite_compiler_wins : ((700000000000:ℕ)*55099+1)^1000 < 2^55099 := by decide +theorem previous_integer_fails : ¬ (((700000000000:ℕ)*55098+1)^1000 < 2^55098) := by decide +theorem local_route_count : (3298+2*408+688)*1000 = (4802000:ℕ) := by decide +theorem local_budget : (158168+4802000:ℕ) < 10000000 := by decide +theorem controller_budget : (181098496:ℕ) < 1000000000 := by decide + +end KappaChangedG.Arithmetic + +#print axioms KappaChangedG.Arithmetic.outerSlacks_source_equality +#print axioms KappaChangedG.Arithmetic.outerSlacks_all_positive +#print axioms KappaChangedG.Arithmetic.functionalSlacks_source_equality +#print axioms KappaChangedG.Arithmetic.functionalSlacks_all_positive +#print axioms KappaChangedG.Arithmetic.claimed_saving +#print axioms KappaChangedG.Arithmetic.strict_improvement +#print axioms KappaChangedG.Arithmetic.tested_above_kappa +#print axioms KappaChangedG.Arithmetic.explicit_gap +#print axioms KappaChangedG.Arithmetic.tail_decay +#print axioms KappaChangedG.Arithmetic.normalized_completion +#print axioms KappaChangedG.Arithmetic.finite_compiler_wins diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean new file mode 100644 index 0000000000..8208fc7779 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedCapacity.lean @@ -0,0 +1,65 @@ +/- +Copyright (c) 2026. Released under the Apache 2.0 license. +Substantial OpenAI Codex assistance. + +Two real-power capacity inequalities at the explicit tested saving. These are +scoped scalar inequalities, not a formalization of the multiplication compiler. +-/ +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.Linarith + +namespace KappaChangedG + +noncomputable def capacitySaving : ℝ := 302177581 / 100000000000 +noncomputable def capacityT : ℝ := 1 - capacitySaving +noncomputable def capacityExponent : ℝ := 1024 * capacitySaving +noncomputable def capacityEta : ℝ := capacityT * (145 : ℝ) ^ (-capacityExponent) + +lemma root145_lt_two : (145 : ℝ) ^ (1 / 8 : ℝ) < 2 := by + rw [show (1 / 8 : ℝ) = (8 : ℝ)⁻¹ by norm_num] + apply (Real.rpow_inv_lt_iff_of_pos (by norm_num : (0 : ℝ) ≤ 145) + (by norm_num : (0 : ℝ) ≤ 2) (by norm_num : (0 : ℝ) < 8)).mpr + norm_num + +lemma capacity_power_upper : (145 : ℝ) ^ capacityExponent < 6097250 := by + calc + (145 : ℝ) ^ capacityExponent < (145 : ℝ) ^ (3 + 1 / 8 : ℝ) := + Real.rpow_lt_rpow_of_exponent_lt (by norm_num : (1 : ℝ) < 145) + (by norm_num [capacityExponent, capacitySaving]) + _ = (145 : ℝ) ^ (3 : ℕ) * (145 : ℝ) ^ (1 / 8 : ℝ) := by + rw [Real.rpow_add (by norm_num : (0 : ℝ) < 145)] + simp + _ < (145 : ℝ) ^ (3 : ℕ) * 2 := + mul_lt_mul_of_pos_left root145_lt_two (by norm_num) + _ = 6097250 := by norm_num + +lemma capacity_eta_lower : capacityT / 6097250 < capacityEta := by + have hp : (0 : ℝ) < (145 : ℝ) ^ capacityExponent := + Real.rpow_pos_of_pos (by norm_num) _ + have hinv : (1 : ℝ) / 6097250 < 1 / (145 : ℝ) ^ capacityExponent := + one_div_lt_one_div_of_lt hp capacity_power_upper + have ht : (0 : ℝ) < capacityT := by norm_num [capacityT, capacitySaving] + have h := mul_lt_mul_of_pos_left hinv ht + simpa only [capacityEta, Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 145), + div_eq_mul_inv, one_mul] using h + +theorem compiler_eta_capacity : (63 / 64 : ℝ) ^ (1000 : ℕ) < capacityEta := by + calc + (63 / 64 : ℝ) ^ (1000 : ℕ) < capacityT / 6097250 := by + norm_num [capacityT, capacitySaving] + _ < capacityEta := capacity_eta_lower + +theorem compiler_initial_range : + (145 : ℝ) ^ capacityExponent < (2 : ℝ) ^ (1000 : ℕ) := by + calc + (145 : ℝ) ^ capacityExponent < 6097250 := capacity_power_upper + _ < (2 : ℝ) ^ (1000 : ℕ) := by norm_num + +end KappaChangedG + +#print axioms KappaChangedG.root145_lt_two +#print axioms KappaChangedG.capacity_power_upper +#print axioms KappaChangedG.capacity_eta_lower +#print axioms KappaChangedG.compiler_eta_capacity +#print axioms KappaChangedG.compiler_initial_range diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean new file mode 100644 index 0000000000..5f957dfa9e --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__TightenedVerification.lean @@ -0,0 +1,185 @@ +/- +Apache-2.0. Substantial OpenAI Codex assistance. Signed Cao Yifan. + +Aggregator for scoped finite native-frame, profile and arithmetic evidence. +This is not a formal integer-multiplication theorem. JSON transcription, +native amplitude/phase semantics, controller semantics and the compiler +transfer retain their separately stated external proof boundaries. +-/ +import Native +import AnalyticGain +import TightenedArithmetic +import TightenedCapacity +import TightenedNumerical + +set_option maxRecDepth 100000 +set_option maxHeartbeats 0 + +namespace KappaTightenedVerification + +open NativeCertificate NativeData + +/-- Positive-rank moment of the finite native census (all actual ranks ≤ 9). -/ +noncomputable def censusMoment (c : Array Nat) (t : ℝ) : ℝ := + (c[1]! : ℝ) * (1 : ℝ) ^ t + (c[2]! : ℝ) * (2 : ℝ) ^ t + + (c[3]! : ℝ) * (3 : ℝ) ^ t + (c[4]! : ℝ) * (4 : ℝ) ^ t + + (c[5]! : ℝ) * (5 : ℝ) ^ t + (c[6]! : ℝ) * (6 : ℝ) ^ t + + (c[7]! : ℝ) * (7 : ℝ) ^ t + (c[8]! : ℝ) * (8 : ℝ) ^ t + + (c[9]! : ℝ) * (9 : ℝ) ^ t + +noncomputable def nativePaidMoment (t : ℝ) : ℝ := + censusMoment (totalPaid forwardData) t + +noncomputable def nativeHelperMoment (t : ℝ) : ℝ := + censusMoment NativeVerification.helperCensus t + +/-- Literal retained controller diagonal. Its extraction is externally checked. -/ +noncomputable def controllerDiagonalMoment (t : ℝ) : ℝ := + 448 * (17 : ℝ) ^ t + 448 * (25 : ℝ) ^ t + 448 * (33 : ℝ) ^ t + + 448 * (41 : ℝ) ^ t + 448 * (49 : ℝ) ^ t + 448 * (57 : ℝ) ^ t + + 448 * (65 : ℝ) ^ t + 224 * (73 : ℝ) ^ t + 224 * (145 : ℝ) ^ t + +/-- 15 × 112 rank-one queries, and all retained controller idle charges. -/ +noncomputable def controllerFixedPaidMoment (t : ℝ) : ℝ := + (15 * 112) * (1 : ℝ) ^ t + + 448 * (16 : ℝ) ^ t + 448 * (24 : ℝ) ^ t + 448 * (32 : ℝ) ^ t + + 448 * (40 : ℝ) ^ t + 448 * (48 : ℝ) ^ t + 448 * (56 : ℝ) ^ t + + 448 * (64 : ℝ) ^ t + 224 * (72 : ℝ) ^ t + +theorem local_paid_profile_binding (t : ℝ) : + nativePaidMoment t = KappaChangedG.newPaidMoment t := by + rw [nativePaidMoment, forward_paid] + norm_num [censusMoment, KappaChangedG.newPaidMoment] + +theorem local_helper_profile_binding (t : ℝ) : + nativeHelperMoment t = + 28 * (4 : ℝ) ^ t + 7 * (7 : ℝ) ^ t + 47 * (8 : ℝ) ^ t + 326 * (9 : ℝ) ^ t := by + rw [nativeHelperMoment, NativeVerification.complete_productive_helper_census] + norm_num [censusMoment] + +theorem complete_target_profile_binding (t : ℝ) : + NumericalMoments.targetMoment t = 18 * nativeHelperMoment t + controllerDiagonalMoment t := by + rw [local_helper_profile_binding] + unfold NumericalMoments.targetMoment controllerDiagonalMoment + ring + +theorem complete_paid_profile_binding (t : ℝ) : + NumericalMoments.paidMoment t = 18 * nativePaidMoment t + controllerFixedPaidMoment t := by + rw [local_paid_profile_binding] + unfold NumericalMoments.paidMoment KappaChangedG.newPaidMoment controllerFixedPaidMoment + ring + +theorem tested_real_rational_binding : + (KappaChangedG.Arithmetic.tested : ℝ) = KappaChangedG.capacitySaving := by + norm_num [KappaChangedG.Arithmetic.tested, KappaChangedG.capacitySaving] + +theorem numerical_exponent_binding : + (99697822419 / 100000000000 : ℝ) = 1 - (KappaChangedG.Arithmetic.tested : ℝ) := by + norm_num [KappaChangedG.Arithmetic.tested] + +theorem numerical_tail_exponent_binding : + (119697822419 / 100000000000 : ℝ) = + 1 - (KappaChangedG.Arithmetic.tested : ℝ) + 1 / 5 := by + norm_num [KappaChangedG.Arithmetic.tested] + +theorem compiler_eta_binding : + KappaChangedG.capacityEta = + (1 - (KappaChangedG.Arithmetic.tested : ℝ)) * + (145 : ℝ) ^ (-(1024 * (KappaChangedG.Arithmetic.tested : ℝ))) := by + rw [tested_real_rational_binding] + rfl + +theorem uniform_saving_binding : + KappaChangedG.Arithmetic.complexUniformSaving = + KappaChangedG.Arithmetic.kappa + + 6 * ((KappaChangedG.Arithmetic.tested - KappaChangedG.Arithmetic.kappa) / 7) := by + norm_num [KappaChangedG.Arithmetic.complexUniformSaving, + KappaChangedG.Arithmetic.kappa, KappaChangedG.Arithmetic.tested] + +/-- The precise finite frame/invoice statement imported from Native. -/ +def nativeFrameInvoiceEvidence : Prop := + linked initialFrames finalFrames forwardData = true ∧ + linked initialFrames backwardFinalFrames backwardData = true ∧ + totalPaid forwardData = #[0,2201,412,510,127,40,0,0,8,0] ∧ + totalPaid backwardData = #[0,2201,412,510,127,40,0,0,8,0] ∧ + totalScalarCost forwardData = 158120 ∧ + totalScalarCost backwardData = 158168 ∧ + totalEvents forwardData = 21449 ∧ totalEvents backwardData = 21449 ∧ + backwardFinalFrames.toList.take 632 = finalFrames.toList.take 632 + +/-- All embedded catalogue checks and their exact raw-table bindings. -/ +def nativeCatalogueEvidence : Prop := + (frames.wellFormed && operators.wellFormed && paid.wellFormed && warps.wellFormed) = true ∧ + frameEntries.map (·.data) = frames.toList ∧ + operatorEntries.map (·.data) = operators.toList ∧ + paidEntries.map (·.data) = paid.toList ∧ + warpEntries.map (·.data) = warps.toList ∧ + (∀ i : Fin frameEntries.length, independent (frameEntries.get i).data = true) ∧ + (∀ i : Fin operatorEntries.length, checkOperator (operatorEntries.get i).data = true) ∧ + (∀ i : Fin paidEntries.length, checkPaid frames (paidEntries.get i).data = true) ∧ + (∀ i : Fin warpEntries.length, checkWarp frames operators (warpEntries.get i).data = true) ∧ + (∀ i : Fin helperEntries.length, checkPaid frames (helperEntries.get i).data = true) ∧ + (∀ i : Fin forwardSegments.length, checkSegment frames paid warps (forwardSegments.get i).data = true) ∧ + (∀ i : Fin backwardSegments.length, checkSegment frames paid warps (backwardSegments.get i).data = true) + +theorem native_catalogue_evidence : nativeCatalogueEvidence := + NativeVerification.all_embedded_catalogues_and_segments_checked + +/-- Every productive helper is the corresponding actual persistent endpoint. -/ +def nativeHelperEndpointEvidence : Prop := + (helperEntries.zipIdx).all (fun (h, i) => + h.data.input == initialFrames.get (224+i) && + h.data.output == finalFrames.get (224+i)) = true + +theorem native_helper_endpoint_evidence : nativeHelperEndpointEvidence := + NativeVerification.helpers_are_actual_endpoint_interfaces + +/-- A conjunction of the actual finite/profile/arithmetic results. It makes +no implication from this conjunction to a multiplication algorithm theorem. -/ +theorem complete_scoped_evidence : + KappaChangedG.Arithmetic.kappa = (15108879 / 5000000000 : ℚ) ∧ + (9443 / 3125000 : ℚ) < KappaChangedG.Arithmetic.kappa ∧ + KappaChangedG.Arithmetic.kappa < KappaChangedG.Arithmetic.tested ∧ + KappaChangedG.Arithmetic.outerSlacks.all (fun p => decide (0 < p.2)) = true ∧ + KappaChangedG.Arithmetic.functionalSlacks.all (fun p => decide (0 < p.2)) = true ∧ + NumericalMoments.paidMoment (99697822419 / 100000000000 : ℝ) < + (1 - (1 / 100000000000 : ℝ)) * NumericalMoments.targetMoment (99697822419 / 100000000000 : ℝ) ∧ + NumericalMoments.paidMoment (119697822419 / 100000000000 : ℝ) < + (97 / 100 : ℝ) * (20 : ℝ) ^ (1 / 5 : ℝ) * + NumericalMoments.targetMoment (99697822419 / 100000000000 : ℝ) ∧ + (10928 * 21 : ℝ) < + (97 / 100 : ℝ) * (20 : ℝ) ^ (302177581 / 100000000000 : ℝ) * + NumericalMoments.targetMoment (99697822419 / 100000000000 : ℝ) ∧ + (63 / 64 : ℝ) ^ (1000 : ℕ) < KappaChangedG.capacityEta ∧ + (145 : ℝ) ^ KappaChangedG.capacityExponent < (2 : ℝ) ^ (1000 : ℕ) ∧ + (((700000000000 : ℕ) * 55099 + 1) ^ 1000 < 2 ^ 55099) ∧ + nativeFrameInvoiceEvidence ∧ nativeCatalogueEvidence ∧ nativeHelperEndpointEvidence := + ⟨KappaChangedG.Arithmetic.claimed_saving, + KappaChangedG.Arithmetic.strict_improvement, + KappaChangedG.Arithmetic.tested_above_kappa, + KappaChangedG.Arithmetic.outerSlacks_all_positive, + KappaChangedG.Arithmetic.functionalSlacks_all_positive, + NumericalMoments.contraction, + NumericalMoments.paid_tail, + NumericalMoments.completion_tail, + KappaChangedG.compiler_eta_capacity, + KappaChangedG.compiler_initial_range, + KappaChangedG.Arithmetic.finite_compiler_wins, + NativeVerification.complete_finite_native_certificate, + native_catalogue_evidence, + native_helper_endpoint_evidence⟩ + +end KappaTightenedVerification + +#print axioms KappaTightenedVerification.local_paid_profile_binding +#print axioms KappaTightenedVerification.local_helper_profile_binding +#print axioms KappaTightenedVerification.complete_target_profile_binding +#print axioms KappaTightenedVerification.complete_paid_profile_binding +#print axioms KappaTightenedVerification.tested_real_rational_binding +#print axioms KappaTightenedVerification.numerical_exponent_binding +#print axioms KappaTightenedVerification.numerical_tail_exponent_binding +#print axioms KappaTightenedVerification.compiler_eta_binding +#print axioms KappaTightenedVerification.uniform_saving_binding +#print axioms KappaTightenedVerification.native_catalogue_evidence +#print axioms KappaTightenedVerification.native_helper_endpoint_evidence +#print axioms KappaTightenedVerification.complete_scoped_evidence diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py new file mode 100644 index 0000000000..12af6aa937 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__arithmetic.py @@ -0,0 +1,147 @@ +"""Complete p16 price and finite compiler for a changed native profile. + +Adapted from Cinna Davis's PR4470 arithmetic, retaining zxv's paid tensor +completion/logarithmic majorant and Jacob Alan Sussman's mixed-job flow. +Apache-2.0. Substantial OpenAI Codex assistance. Native admission is separate. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import importlib.util +import json +import math +import sys +sys.dont_write_bytecode=True +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] + +def need(ok,why): + if not ok:raise ValueError(why) + +def load(path,name): + spec=importlib.util.spec_from_file_location(name,path) + m=importlib.util.module_from_spec(spec);sys.modules[name]=m;spec.loader.exec_module(m) + return m + +def encode(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + +def read(path): + import gzip + b=path.read_bytes();return json.loads(gzip.decompress(b) if path.suffix=='.gz' else b) + +def assemble(local): + H={int(k):v for k,v in local['helpers'].items()};N={int(k):v for k,v in local['paid'].items()} + sys.path.insert(0,str(ROOT/'research/joint-helper-lattice')) + J=load(ROOT/'research/joint-helper-lattice/verify.py','round2_pinned_controller') + sys.path.insert(0,str(ROOT/'research/query-thinned-controllers')) + C=load(ROOT/'research/query-thinned-controllers/controller.py','round2_controller_engine') + word=J.controller16(C) + T,P=Counter(),Counter();full=thin=0 + for e in word['physical_events']: + if e[0]=='LOCAL':full+=1;T.update(H);P.update(N) + elif e[0]=='QUERY_SHEAR':thin+=1;P[1]+=112 + elif e[0]=='IDLE':P[8*len(e[2])]+=224 + for term in word['diagonal']:T[1+8*sum(term[1:])]+=112 + need(full==18 and thin==15 and sum(H.values())==408,'Complete retained p16 call and input inventory') + return H,N,T,P,word + +def run(local,kappa=None): + H,N,T,P,word=assemble(local) + E=load(ROOT/'research/higher-moment-strictification/verify.py','round2_exact_intervals') + other=load(ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','round2_second_intervals') + def margin(c): + t,p=E.moment(T,1-c),E.moment(P,1-c) + return t[0]-p[1],t[1]-p[0] + old_upper=Q('.0030201659771') + need(margin(old_upper)[0]>0,'Changed complete invoice strictly beats old raw root upper endpoint') + # Binary search on a fixed rational grid; all final signs use exact intervals. + lo,hi=0,1000000000000 + grid=10**14 + while hi-lo>1: + mid=(lo+hi)//2 + if margin(Q(mid,grid))[0]>0:lo=mid + else:hi=mid + root_low,root_high=Q(lo,grid),Q(hi,grid) + need(margin(root_low)[0]>0 and margin(root_high)[1]<0,'Strict changed-profile rational root enclosure') + if kappa is None:kappa=Q((root_low*10**8).__floor__()-3,10**8) + tested=kappa+Q(1,10**11) + need(Q('.003020165')ph and max(tl,target[0])<=min(th,target[1]) and max(pl,paid[0])<=min(ph,paid[1]),'Two independently implemented rational moment engines agree') + alpha=E.divide(paid,target) + gamma=E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target)) + delta=E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,tested),target)) + alpha_gap=Q(1,10**11);g=d=Q(97,100) + need(alpha[1]<1-alpha_gap and gamma[1]theta**power,'Shifted exits and complement capacity') + need(E.power(145,v*tested)[1]<2**power,'Compiler initial range') + gap=(tested-kappa)/7;need(gap.numerator==1,'Explicit finite integer grid') + step=gap.denominator + def wins(j):return (step*j+1)**power<2**j + left,right=1,2 + while not wins(right):left,right=right,2*right + while right-left>1: + mid=(left+right)//2 + if wins(mid):right=mid + else:left=mid + height=step*right + need(height>8*v and wins(right) and not wins(right-1),'Strict finite uniform-rank integer bound') + local_scalar=max(x['real_scalar_allowance'] for x in local['native'].values()) + routes=(sum(N.values())+2*408+688)*1000 + need(local_scalar+routes<10**7,'Complete scalar and fixed monomial routing bound') + scalar_upper=18*10**7+15*1792+32*112*(len(word['physical_events'])+sum(len(word['boundaries'][k+'_program']) for k in ('left','right'))) + need(scalar_upper<10**9,'Raw controller scalar bound') + bit=read(ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT'] + atom=Q(bit['atom']);ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599');admitted=Q(bit['admitted']) + need(atom==Q('.004') and atom>ordinary>admitted>tested and atom<1-ordinary,'Source ordinary BIT admission and stock') + L=load(ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','round2_outer_ledger') + params={'kappa':kappa,'tested_saving':tested,'complex_uniform_saving':kappa+6*gap, + 'b':kappa+5*gap,'a':kappa+4*gap,'q':kappa+3*gap,'bit_saving':admitted, + 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap} + outer=L.ledger(params);outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom) + need(len(outer['strict_checks'])==54 and len(outer['functional_checks'])==4,'Whole outer predicate inventory') + need(all(x>0 for key in ('strict_checks','functional_checks') for x in outer[key].values()),'All outer inequalities strictly positive') + controls={} + for name,patch in [('old_BIT',{'bit_saving':Q('.0027')}),('closed_uniform',{'complex_uniform_saving':params['b']}),('unfunded_endpoint',{'kappa':tested}),('closed_epsilon',{'epsilon':Q(1)})]: + bad=L.ledger(dict(params,**patch));failed=[k for k,x in bad['strict_checks'].items() if x<=0] + need(failed,'Reject unsupported outer patch '+name);controls[name]=failed + return encode({'status':'PASS_CHANGED_PROFILE_ARITHMETIC_NATIVE_ADMISSION_SEPARATE','kappa':kappa, + 'gain_over_PR4535':kappa-Q('.003020165'),'raw_root_interval':[root_low,root_high], + 'margin_at_old_root_upper':margin(old_upper),'local_helpers':H,'local_paid':N,'targets':T,'paid':P, + 'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),'rank_mass_surplus':sum(r*n for r,n in T.items())-sum(r*n for r,n in P.items()), + 'strictification':{'tested':tested,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized}, + 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'uniform_saving':params['complex_uniform_saving'],'H':height,'N':'2^'+str(height),'integer_test_exponent':right,'word_materialized':False}, + 'nonrecursive':{'local_scalar':local_scalar,'local_routes':routes,'raw_scalar_upper':scalar_upper}, + 'ordinary_BIT':bit,'outer':outer,'negative_controls':controls, + 'scope':'Exact changed-profile arithmetic only. Requires separately admitted changed native programs, paid transports and absolute phases. Retained compiler/native/precision/tape/analytic/recovery assumptions.'}) + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--native',type=Path,required=True);ap.add_argument('--kappa');ap.add_argument('--out',type=Path,default=HERE/'ARITHMETIC.json');args=ap.parse_args() + result=run(read(args.native),Q(args.kappa) if args.kappa else None) + result['native_receipt_sha256']=sha256(args.native.read_bytes()).hexdigest() + # Pin all loaded project source modules and the non-module controller/stock + # records read by the inherited engines. Standard-library files are outside + # the repository and are recorded instead by the replay's Python version. + paths={Path(__file__).resolve(),ROOT/'research/joint-helper-lattice/CONTROLLER.json', + ROOT/'research/query-thinned-controllers/RESULT.json'} + for module in tuple(sys.modules.values()): + name=getattr(module,'__file__',None) + if name: + path=Path(name).resolve() + if path.is_relative_to(ROOT) and path.is_file():paths.add(path) + result['source_sha256']={p.relative_to(ROOT).as_posix():sha256(p.read_bytes()).hexdigest() for p in sorted(paths)} + args.out.write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:result[k] for k in ('status','kappa','gain_over_PR4535','raw_root_interval','paid_calls','compiler')},indent=2)) diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py new file mode 100644 index 0000000000..340e1f0ffb --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/4610__endpoint.py @@ -0,0 +1,240 @@ +#!/usr/bin/env python3 +"""Exact endpoint refill conditional on the source PR4359 construction. + +Apache-2.0. Substantial OpenAI assistance. The mixed inventory and elementary +function enclosure are zxv's PR4359; mixed-target flow is Jacob Alan Sussman's +Theorem 1G. Outer formulas retain the attribution in PR4359 outer_parameters.py. +This file checks arithmetic, not the native or all-size proof hypotheses. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import importlib.util +import json +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +PREFIX = Path('research/kappa-rebuild') +OLD_BASELINE = Q('0.001730970419199163702738') +KAPPA = Q('0.00230509') +TESTED = Q('0.00230509019') +ROOT_UPPER = Q('0.002306') + + +def need(value, message): + if not value: + raise AssertionError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def ceil(value): + value = Q(value) + return -((-value.numerator) // value.denominator) + + +def encode(value): + if isinstance(value, Q): + return str(value) + if isinstance(value, dict): + return {str(k): encode(v) for k, v in value.items()} + if isinstance(value, (tuple, list)): + return [encode(v) for v in value] + return value + + +def family(kappa, tested): + """One explicit slack family approaching the same source mixed root.""" + need(Q(0) < kappa < tested < ROOT_UPPER, 'Positive strictly ordered savings') + d = (tested-kappa)/7 + return {'kappa': kappa, 'tested_saving': tested, + 'complex_uniform_saving': kappa+6*d, + 'b': kappa+5*d, 'a': kappa+4*d, 'q': kappa+3*d, + 'bit_saving': Q('0.0027'), 'epsilon': 1-d, 'beta': 1-3*d, + 'r0': d/10, 'stop': d, 'layout': d, 'd': d} + + +def ledger(p): + """Recompute all 54 named PR4359 checks with freely supplied parameters.""" + kappa, b, a, q = (p[key] for key in ('kappa', 'b', 'a', 'q')) + epsilon, beta, r0, stop, layout = (p[key] for key in + ('epsilon', 'beta', 'r0', 'stop', 'layout')) + sigma, tau = 1-b, 1-a + internal = tau+(1-stop)*max(sigma-tau, Q(0)) + leaf = sigma+stop*(1-sigma) + lam, c = 1-(q+a)/2, Q(3, 32) + xi, key = epsilon*(1+q)-c+layout, beta+1-epsilon + margins = { + 'main_transform': epsilon*q, + 'global_coordinate_router': a, + 'fused_gaussian': 1-epsilon+q*beta, + 'group_bit_router': 1-epsilon+a*beta, + 'group_scans': 1-epsilon+beta, + 'boundary_algebraic_matrix': c+xi-epsilon, + 'sparse_union_movement': xi+Q(1, 2)-epsilon, + 'polynomial_products': epsilon, + 'microbox_face_corrections': 1-(epsilon+beta+48-128+2), + } + checks = { + 'actual_bit_above_effective': p['bit_saving']-a, + 'complex_above_effective': b-a, + 'q_positive': q, 'complex_endpoint': b-q, 'q_below_effective': a-q, + 'stop_positive': stop, 'stop_below_one': 1-stop, + 'leaf_saving_above_effective': (1-stop)*b-a, + 'q_below_internal': 1-internal-q, 'q_below_leaf': 1-leaf-q, + 'lambda_above_tau': lam-tau, 'lambda_above_sigma': lam-sigma, + 'lambda_above_internal': lam-internal, + 'lambda_prime_above_lambda': 1-q-lam, + 'lambda_prime_above_leaf': 1-q-leaf, + 'epsilon_positive': epsilon, 'epsilon_below_one': 1-epsilon, + 'cap_above_band': xi-Q(1, 2), 'cap_below_cell': epsilon-xi, + 'group_positive': beta, 'group_below_dimension': epsilon-beta, + 'support_router_span': 1-beta, + 'group_gauge_power_slack': 1-(2*xi-2)-r0-beta, + 'actual_logarithmic_group_guard': 1-(2*xi-2)-beta, + 'global_gamma_power_slack': 1-epsilon-r0, + 'actual_logarithmic_gamma_guard': 1-epsilon, + 'alpha_logarithm_absorption': r0, + 'group_key_fits_record': 1-key, + 'membership_arithmetic_fits_record': 1-beta-2*(1-epsilon), + 'microbox_halo_volume': 128-48-beta, + 'positive_layout_slack': layout, + 'short_record_fallback': epsilon-a, + 'complex_below_one_over_32': Q(1, 32)-b, + 'strassen_integer_power_gap': Q(2**45-7**16), + 'theta_positive_polynomial_power': Q(2), + 'cap_below_phase_cell_power': 2-xi, + 'halo_covers_generic_inverse_radius': Q(48-43), + 'union_tag_work_per_visit_fits_record': 1-beta, + 'union_header_fits_record': 1-beta, + 'source_axis_superpolynomial': 1-epsilon, + 'gaussian_above_main': margins['fused_gaussian']-margins['main_transform'], + 'new_complex_uniform_saving_above_b': p['complex_uniform_saving']-b, + 'improvement_over_user_baseline': kappa-OLD_BASELINE, + 'new_semantic_guard_with_C1_one': 1-epsilon, + 'fine_prime_halo_umbrella': 10-(2*2+2+Q(1, 2)), + } + checks.update({name+'_above_kappa': value-kappa for name, value in margins.items()}) + # These are the additional functional conditions in the independent + # PR4359 outer_transfer_audit.py, beyond the 54-row parameter ledger. + functional = { + 'new_semantic_group_guard': 1-beta, + 'new_BIT_row_stock_sublinear_in_active_group': beta*(1-Q(3, 1000)), + 'fixed_halo_explicit_metadata_branch': 128-48-epsilon-beta-1, + } + return {'parameters': dict(p, cap_xi=xi, lambda_=lam, lambda_prime=1-q), + 'margins': margins, 'strict_checks': checks, 'functional_checks': functional} + + +def compiler_rank(E, targets, paid, tested, uniform): + """The original sufficient bound, re-instantiated for the new exponent.""" + m, kmin, rmax = max(targets), min(targets), max(paid) + need((m, kmin, rmax) == (57, 6, 5), 'Pinned complex separation') + t, z = 1-tested, 1-uniform + z0, h = (t+z)/2, Q(1, 10) + delta = z0-t + need(0 < t < z0 < z < 1, 'Compiler exponent order') + need(5**10 < 6**9 and 57 < 2**10, 'Exact source rank bounds') + need(z0 > Q(1, 2) and (1-z0)*E.log_interval(m)[1] < E.log_interval(2)[0], + 'Original eta strictly exceeds 1/4') + H0 = ceil((3+4*delta)/(h*delta)) + ratio = H0*(1-z0)/(z-z0) + H1 = ratio.numerator//ratio.denominator+1 + need(H0 >= m.bit_length() and H0*h*delta >= 3+4*delta, 'Induction starts') + need(H1*(z-z0) > H0*(1-z0), 'Strict winning uniform rank') + need((H0-1)*h*delta < 3+4*delta, 'Reject one lower threshold exponent') + need((H1-1)*(z-z0) <= H0*(1-z0), 'Reject one lower final exponent') + return {'t': t, 'z0': z0, 'z': z, 'theta_upper': Q(9, 10), + 'H0': H0, 'H1': H1, 'N_encoding': '2^H1', + 'strict_final_gap': H1*(z-z0)-H0*(1-z0), + 'winning_word_materialized': False, + 'bound': 'Original sufficient inequality; a sharper bound is separate.'} + + +def run(source_root): + base = source_root/PREFIX + interval_path = base/'architecture/mixed_target_probe.py' + spec = importlib.util.spec_from_file_location('pr4359_moment', interval_path) + E = importlib.util.module_from_spec(spec) + spec.loader.exec_module(E) + cover = read(base/'controller/P3-NATIVE-COVER.json.gz')['cover'] + targets = {int(k): int(v) for k, v in cover['targets'].items()} + paid = {int(k): int(v) for k, v in cover['paid'].items()} + need(targets == {6: 192, 7: 56, 8: 93, 9: 1229, 25: 448, 57: 224}, + 'Exact source productive inventory') + need(paid == {1: 17623, 2: 5065, 3: 1738, 4: 714, 5: 254}, + 'Exact source paid inventory') + signed = Counter(targets) + signed.subtract(paid) + need(sum(k*v for k, v in signed.items()) == 224, 'Rank-one surplus') + bracket = {'lower': E.moment(signed, TESTED), 'upper': E.moment(signed, ROOT_UPPER)} + need(bracket['lower'][0] > 0 and bracket['upper'][1] < 0, + 'Strict mixed test and upper root bound') + + original = read(base/'controller/OUTER-PARAMETERS.json')['outer'] + old = ledger({'kappa': Q('0.0023'), 'complex_uniform_saving': Q('0.002304'), + 'b': Q('0.002303'), 'a': Q('0.0023025'), 'q': Q('0.002302'), + 'bit_saving': Q('0.0027'), 'epsilon': Q('0.99999'), + 'beta': Q('0.99997'), 'r0': Q(1, 10**6), + 'stop': Q(1, 10**8), 'layout': Q(1, 10**6)}) + for group in ('margins', 'strict_checks'): + frozen = {key: Q(value['rational']) for key, value in original[group].items()} + need(old[group] == frozen, 'Exact reproduction of every old '+group) + p = family(KAPPA, TESTED) + result = ledger(p) + need(all(v > 0 for v in result['strict_checks'].values()), 'All 54 new outer predicates') + need(all(v > 0 for v in result['functional_checks'].values()), 'Additional functional predicates') + need(min(result['margins'].values()) == result['margins']['main_transform'], + 'Main transform remains limiting') + need(result['parameters']['cap_xi'] == Q(29, 32)+(1-p['d'])*p['q'], + 'Cofinal cap simplification') + controls = {} + for label, updates in [('closed_epsilon_gap', {'epsilon': Q(1)}), + ('missing_layout', {'layout': Q(0)}), + ('unfunded_kappa', {'kappa': Q('0.002306')}), + ('BIT_below_effective', {'bit_saving': OLD_BASELINE}), + ('no_complex_slack', {'complex_uniform_saving': p['b']})]: + tested = ledger(dict(p, **updates)) + failures = {k: v for k, v in tested['strict_checks'].items() if v <= 0} + need(failures, 'Mutation rejected: '+label) + controls[label] = failures + need(E.moment(signed, Q('0.004'))[1] < 0, 'Unsupported mixed target is rejected') + inputs = [interval_path, base/'controller/P3-NATIVE-COVER.json.gz', + base/'controller/OUTER-PARAMETERS.json'] + return encode({'schema': 'pr4359-cofinal-outer-refill/1', + 'status': 'PASS_EXACT_CONDITIONAL_ENDPOINT_REFILL', + 'kappa': KAPPA, 'gain_over_PR4359': KAPPA-Q('0.0023'), + 'unchanged_paid': paid, 'unchanged_targets': targets, + 'mixed_test_saving': TESTED, 'mixed_test_margin': E.show(bracket['lower']), + 'root_upper_test': ROOT_UPPER, 'root_upper_margin': E.show(bracket['upper']), + 'old_ledger_crosscheck': {'matched_savings': len(old['margins']), + 'matched_checks': len(old['strict_checks'])}, + 'outer': result, 'limiting_margin': min(result['margins'].values())-KAPPA, + 'compiler': compiler_rank(E, targets, paid, TESTED, p['complex_uniform_saving']), + 'negative_controls': controls, + 'source_sha256': {str(p.relative_to(source_root)): sha256(p.read_bytes()).hexdigest() + for p in inputs}, + 'scope': 'Conditional arithmetic and specified finite rank. The PR4359 native, compiler, cover, precision, fixed-tape and outer hypotheses remain premises; no full theorem or practical word is certified.'}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--source-root', type=Path, default=HERE/'source') + parser.add_argument('--out', type=Path) + args = parser.parse_args() + result = run(args.source_root) + if args.out: + args.out.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print(json.dumps({key: result[key] for key in + ('status', 'kappa', 'gain_over_PR4359', 'limiting_margin', 'compiler')}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex new file mode 100644 index 0000000000..cbaa8cb42c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/notes__batched-bit-rows.tex @@ -0,0 +1,123 @@ +\subsection{Integer widths, bounded row padding, and mixed contractions} +\label{sec:mixed-width-rows} + +The batched residual construction uses a fixed finite list of child sizes, +not only powers of one radix. The following implementation supplies the +corresponding integer-width recursion. All constants in this subsection +are fixed finite circuit constants, independent of the input length. + +\paragraph{A general moment condition.} +Let $m,W\ge2$ be fixed. At one circuit invocation, let the list +$t_1,\ldots,t_J$ contain integers in $[1,m-1]$. A child of type $i$ has +width $t_i f$, where $f=\lfloor e/m\rfloor$, and operates on exactly +$1/W$ of the parent's logical volume. Repetitions in the list represent +separate calls. An ordinary rank-one call has $t_i=1$; a batched block +has the corresponding larger value of $t_i$. Full-rank edges may retain +their original $m$ rank-one calls, so no same-width recursive call is +needed. Put +\[ + \Psi(x)=\frac1W\sum_{i=1}^J(t_i/m)^x, + \qquad t_* = \max_i t_i 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(n=t` +of arbitrary-input roles. This includes noncommuting scalar projectors and +any number of restored dirty spectator roles. + +Consequently the thirteen-call five-SWAP candidate in +[Aaron Wang's PR2317](https://github.com/CrocSwap/integer-mult-bounds/pull/2317) +is excluded without a commuting-projector restriction: its minimum is 15. +Four SWAPs cost 12 even with extra dirty roles. These implications resolve the +same-model open questions 1 and 2 in the frozen +[four-SWAP note](../four-swap-full-occupancy/README.md). +Those historical files remain unchanged. + +The contribution is the explicit model identification, an independent audit, +and a retrievable answer to the live handoff. The all-parameter cut theorem +and method are credited to +[PR1989](https://github.com/CrocSwap/integer-mult-bounds/pull/1989), whose +[proof](../symmetric-adjacent-cut-bound/PROOF.md) is retained byte-identically. +This is not a new supplier, a physical cost improvement, or a kappa claim. + +## Exact model and isomorphism + +Let + +``` +a = [1 1] b = [1 0] s = aba = bab = [0 1] + [0 1] [1 1] [1 0] +``` + +in `G=GL_2(F2)`. Products act on columns, so `gh` means `g` after `h`. +A paid factor is `D_N(g)=I_R+([g]+1)N`, where `g` is exactly `a` or `b`, +`N=uv^T` is binary, and `v^Tu=1`. Each paid factor costs one, including +all preparation and restoration. Scalar `GL_R(F2)` operations are free +and may be interleaved. There are no other free address operations, clean +allocations, resets, copies or erasures. The required complete formal map is + +``` +T = diag([s], ..., [s], 1, ..., 1), with t copies of [s]. +``` + +Every role begins arbitrarily; all spectators are individually restored and +all off-diagonal couplings vanish. Equality is coefficientwise in the full +formal group algebra, not equality of the natural two-dimensional matrices. + +Order the three nonzero column vectors as +`v1=(0,1)^T`, `v2=(1,1)^T`, `v3=(1,0)^T`. Define `phi(g)` by +`g v_i = v_(phi(g)(i))`. This action is a homomorphism with the same product +convention. It is injective because fixing these vectors fixes a basis; +`|GL_2(F2)|=6=|S3|`, so it is a group isomorphism. + +| GL2 element | Image in S3 | One-line image | Inversions | +|---|---|---|---:| +| e | e | 123 | 0 | +| a | (12) | 213 | 1 | +| b | (23) | 132 | 1 | +| ab | (123) | 231 | 2 | +| ba | (132) | 312 | 2 | +| s=aba | (13) | 321 | 3 | + +Extending linearly maps the six formal basis elements bijectively and +preserves every product. It therefore gives an algebra isomorphism +`F2[G] -> F2[S3]`, and an entrywise isomorphism of register matrices. +It preserves the scalar projector `N`, every free scalar map, all role +counts and all dirty endpoint requirements. The paid labels become exactly +the two adjacent transpositions. Thus every hypothesis of PR1989 is met; +its inversion-sum theorem gives minimum `t*3`. + +## Direct proof of the specialized lower bound + +For clarity, this restates the relevant PR1989 argument with its notation +specialized, rather than relying on an unexplained invocation. +Use the six ordered pairs `(i,j)` of distinct labels in `{1,2,3}`. +Each permutation acts simultaneously on the two entries. Partition the +address basis into `H={ij}`, on **every** one of the R roles. +For the resulting operator M write `q(M)=rank_F2 M[K,H]`. + +For arbitrary operators U,V, block multiplication gives + +``` +(UV)[K,H] = U[K,H] V[H,H] + U[K,K] V[K,H], +q(UV) <= q(U) + q(V). +``` + +No commutativity or invertibility is used in this inequality. A free +scalar map is `S tensor I_6`, so its crossing block is zero, even when +it mixes active roles with spectators. For a paid factor, the crossing +block is `N tensor P_g[K,H]`. Either adjacent label reverses exactly +one increasing ordered pair, so this block has rank `rank N=1`. +SWAP maps to reversal, which reverses all three increasing pairs with +independent images. The target crossing block is therefore the direct +sum of t rank-three blocks and R-t zero blocks, of rank `3t`. +Subadditivity proves that any legal word has at least `3t` paid factors. +All intermediate roles and their dirty values were included; no bound +on R except finiteness was used. + +For attainment, on each target role j execute `a,b,a` with coordinate +projector `E_jj`. The formal product has `[aba]=[s]` in that diagonal +entry and identity elsewhere. Concatenating the t words gives T in +exactly `3t` calls. It uses no extra roles or free operations, and leaves +no restoration debt. This also handles t=0, with the empty word. + +The universal conclusion rests on this written argument and the explicit +isomorphism. It is not an extrapolation from finite fixtures or a +formal-kernel proof. + +## What this closes and what it does not + +The mapping answers the exact formal-model questions in the four-SWAP +note and PR2317. PR2317's commuting-family computation remains credited +as predecessor evidence; the additional noncommuting search it proposes is +unnecessary in this same alphabet. This note does not rerun or supersede +its finite enumeration as independent evidence. + +The natural two-dimensional GL2 representation alone is not faithful +on the group algebra: the nonzero formal sum of all six group elements +has zero natural-matrix image over F2. The checker rejects an endpoint +corrupted by this sum. The six-dimensional ordered-pair action for S3 +is regular and faithful; full formal coefficients are nevertheless used +for the primary endpoint checks. + +Charging a direct SWAP label as one call changes the alphabet: that +one factor crosses three directions. Charging a rank-two projector as +one call changes the tariff: it can cross two. Clean workspace with only +a restricted-input endpoint, partial/unrestored spectators, other address +maps or nonlinear operations also change the theorem's premises. +The argument supplies no native rational-address compiler, source access, +hosting, precision/tape, recursive child moment or outer multiplication +assembly. It does not settle the different abelian rational-frame model +or the GL3 CNOT alphabet. No selected cold replay is asserted. + +## Reproduction and finite evidence + +From the repository root: + +``` +python3.12 -B scripts/research_package.py --package research/gl2-swap-cut-corollary +``` + +`verify.py` uses packed full group-algebra coefficients and binary row +elimination, importing no predecessor implementation. It checks all 36 +group products and 4,096 algebra products, all 1,302 paid factors for +R=1..5, and all 3,136 ordered pairs of three-role factors (including +noncommuting cases). It verifies both orientations of the direct word +for t=0..8 and R=t,t+1,t+2: 27 complete formal endpoints, plus all 324 +single-call omissions. It checks wrong labels, dirty spectator coupling, +the natural-representation alias, free scalar mixing, and changed-price +boundary controls. These are complete finite domains, not searches over +all legal words. + +`independent.py` and [REVIEW.md](REVIEW.md) give the separately implemented +regular-action audit, its exact domain and the mathematical model review. +`test_verify.py` exercises actual guard removal and semantic corruptions; +it also checks equivalent group-basis order and read-only Git-free replay. +Each detector must reject for the intended reason. The registered commands +run with `-O` to ensure their checks do not rely on Python assertions. + +## Sources, attribution and freshness + +Pinned base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4; +selected-record SHA256 +`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +[SOURCES.json](SOURCES.json) authenticates both retained proof/model inputs. +PR1989 head: `8b9f3ec8b1e5745c42fec68d75da5fbc82ea91ec`; its proof is identical +to the pinned main copy (SHA256 +`008be68867a8e85f4e18455d206e03f20aebfc28e9f08efba576180e7e1edc50`). +PR2317 head: `139779c86ba8215910117ddb383e4df007b23dcf`; its README SHA256 is +`edba3d71ad274311f3a8c2293d390a7adba38deca344662c0364cbdd192521d3`. +The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18944151) +answers its linked handoff in the existing investigation thread. + +The entry overlap helper covered 614 open PRs including drafts and 1,139 +Discussion records, with complete pagination and no warnings, at +2026-10-15 07:57–08:00 UTC. Focused follow-up at 08:01:57 UTC included local +READMEs, TASK records and the PR ledger. Closed PRs are represented through +local notes/ledger only; arbitrary diffs and nested sources are not searched. +No-match output is not a novelty claim: this is explicitly a corollary of +known work. TASK.json records the changed scope from the bit-mechanisms draw. + +Credit: Ross Richardson/PR1989 for the general theorem; Adam Gall/PR1941 and +Ross Richardson/PR1966 for its cut-method predecessors; Cinna Davis for the +finite symmetric-group work credited there. Aaron Wang/PR2317 supplied the +commuting five-SWAP screen and the concrete live handoff. The coordinate-SWAP +model and earlier bounds retain Gareth Davidson/PR1333, +commdata2338/PR1414/1491, Cinna Davis/PR1541, Ross Richardson/PR1722 and the +four-SWAP note, and Aaron Wang/PR1705/1755 lineage. See the pinned source +notes for their own earlier attribution. Prepared by Ross Richardson with +substantial OpenAI Codex assistance, including a separate mathematical +verification specialist. No independent human review is claimed. Apache-2.0. + +## Open next questions + +No further uniform-price formal SWAP search in this exact alphabet is +justified by these handoffs. A useful follow-up must identify a changed +operation, price or endpoint contract, derive its crossing charge, and +fully price any physical implementation before claiming supplier relevance. +The first decisive check is whether the proposed call can cross more than +one direction for its declared charge. Native realization and complete +recursive accounting remain the blockers to transferring such an escape +into the multiplication construction. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md new file mode 100644 index 0000000000..431363d53d --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-ceilings-20261023/frozen/research__rank2-swap-batching__README.md @@ -0,0 +1,215 @@ +# Three GL2 swaps need five capped-rank invocations + +This contribution was produced by Nick Petalas. Apache-2.0. + +**Scoped proof; no new kappa.** Three independent coordinate-SWAP targets +have exact minimum **five invocations** when each paid coordinate-CNOT call +may have scalar rank one or two and costs one invocation. The complete +five-call word has rank profile `(2,2,1,2,2)` and total scalar rank nine. +It improves the six-invocation implementation that separately batches two +roles and processes the third role. Every additional dirty role returns +unchanged, with no off-diagonal residue. + +More generally, if a rank-one call costs `c1` and a rank-two call costs `c2`, +where `0 <= c1 <= c2 <= 2*c1`, the exact minimum is + +```text +c1 + 4*c2. +``` + +The disjoint batching bill is `3*c1 + 3*c2`. The new saving is therefore +`2*c1-c2`, positive for every strictly subadditive price `c2<2*c1`. +In particular, a power price `c_r=r^theta`, with `0<=theta<=1`, gives +`1+4*2^theta`. Scalar projector rank is not recursive child rank, so this +local result supplies no changed supplier histogram or multiplication bound. + +## Model + +Let `G=GL_2(F2)`, with + +```text +a = [[1,1],[0,1]], b = [[1,0],[1,1]], s=aba=bab=[[0,1],[1,0]]. +``` + +For any finite `R>=3`, work coefficientwise in `M_R(F2[G])`. All registers +start arbitrary. The required complete endpoint is +`T=diag([s],[s],[s],1,...,1)`. +A paid invocation is + +```text +D_N(g)=I_R+([g]+1)N, g in {a,b}, 1<=rank_F2(N)<=2. +``` + +The theorem allows arbitrary binary `N`, including nonidempotent matrices. +Restricting the alphabet to idempotents gives the same optimum, since the +attaining word uses only diagonal idempotents. Every factor is invertible: +its square is identity because `([g]+1)^2=0` in characteristic two. +Free scalar `GL_R(F2)` mixing may occur anywhere. There are no other free +address maps, resets, clean allocations or omitted restoration calls. + +The changed premise from the rank-one GL2 results is the cap-two invocation +price. David Arias's [PR2738](https://github.com/CrocSwap/integer-mult-bounds/pull/2738) +proves the scalar-rank tariff but explicitly leaves sublinear higher-rank +invocation prices outside its conclusion. Ross Richardson's +[PR2415 handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18944151) +names rank-two unit prices as a changed question. Their results are used as +cited mathematical premises; their scientific replays are not run here. + +## Attaining construction + +For a set `S` of role indices, write `E_S=sum_(j in S) E_jj`. +Execute these calls in the listed chronological order, with zero entries +on every role above two: + +| Call | Label | Role support | Scalar rank | +| --- | --- | --- | ---: | +| 1 | a | 0,1 | 2 | +| 2 | b | 0,2 | 2 | +| 3 | a | 2 | 1 | +| 4 | b | 1,2 | 2 | +| 5 | a | 0,1 | 2 | + +Role zero receives `a,b,a`, role one receives `a,b,a`, and role two receives +`b,a,b`. Both palindromic words equal `s`; the rightmost-first matrix-product +convention therefore gives the same stated endpoint. All factors are +diagonal in role space. Their formal product has no off-diagonal entries, +and every spectator diagonal remains exactly `[e]`. This is an identity in +the full group algebra, with no restriction on register values or addresses. + +The two target roles that share a call change between calls. Requiring a +fixed partition into a two-role block and a singleton would miss this word. +No scalar bridge, auxiliary role or uncharged cleanup is needed to attain it. + +## Optimality and the exact price + +We cite the rank-priced extension in +[PR2738, proof section 7](../coxeter-root-tariff/PROOF.md#7-rank-priced-extension-and-scope-boundaries), +using the product-preserving `GL_2(F2)=S3` bridge retained in +[PR2415](../gl2-swap-cut-corollary/README.md). +Its root-cut lower bound is valid for arbitrary binary scalar couplings, +free scalar mixing and arbitrary finite restored dirty workspace. Since +`s` is the length-three longest element of `S3`, **every legal circuit here +satisfies `sum_i rank(N_i)>=9`**. This nine-unit inequality is inherited, +not a new lower-bound theorem claimed by this package. + +Each invocation has rank at most two, so four invocations supply at most +eight rank units. At least five invocations are necessary. The table attains +five and nine rank units, proving the exact invocation minimum in both the +arbitrary-coupling and idempotent-only alphabets. + +For the price theorem, let `q1,q2` count rank-one and rank-two calls. Then +`q1+2*q2>=9`. If `q2<=4`, the nonnegative price assumptions imply + +```text +c1*q1+c2*q2 >= 9*c1-(2*c1-c2)*q2 >= c1+4*c2. +``` + +If `q2>=5`, the bill is at least `5*c2>=c1+4*c2`. These two cases cover +every finite circuit, including zero prices. The table attains the lower +bound exactly. No rounding of a numerical moment or finite word exclusion +is used in this proof. + +The interval `c1<=c2<=2*c1` is part of the statement. For example, with +`c1=1,c2=3`, nine rank-one calls cost nine, below the displayed formula +thirteen. The verifier rejects prices outside the stated interval. + +## Evidence and reproduction + +Use CPython 3.12 with the standard library, from the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/rank2-swap-batching +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/rank2-swap-batching/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/rank2-swap-batching/verify.py +``` + +Expected markers are `PASS_RANK2_SWAP_BATCHING minimum=5` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. A different installation can substitute +its own CPython 3.12 path. Default replay writes no files and needs neither +Git nor network. `--emit-receipt` prints a newly computed, source-hash-bound +receipt to standard output. The committed [RESULT.json](RESULT.json) is +generated by that command, never written by hand. + +The primary checker multiplies all formal coefficients using binary GL2 +matrices. A separate checker builds `S3` from permutations of three points +and applies the gates to every column of its faithful left regular module. +Both check the new complete endpoint. The finite fixtures cover all 168 +invertible scalar gauges at three roles, and elementary plus dense gauges +at four through six roles. Gauged calls include actual dirty-role coupling, +with separately applied entrance and exit maps. Each call omission and label +flip must change the formal endpoint; unmatched dirty coupling and an illegal +rank-three invocation must also fail. Exact rational price cases check the +new two-case integer-profile argument. Exact enumerated totals are in the +receipt, not extrapolated to larger spaces. + +The universal conclusion is the written construction and price proof using +the cited rank bound. The finite fixtures are corroboration. This is not an +exhaustive search over all legal words and does not replay predecessor +censuses or certify the inherited proof in a formal kernel. + +## Open next questions + +1. What native interface can implement this exact cap-two scalar-coupling + invocation at a strictly subadditive complete price? First specify its + data layout and arbitrary-input entry/exit contract, then charge its + compilation, scalar work, routing, ownership, precision and cleanup. + Those physical costs are unknown here; another construction round is + not justified by the formal five-call count alone. +2. What is the exact three-target tariff when scalar ranks above two are + allowed at a declared price? First specify one price schedule and compare + complete attaining words with the inherited nine-unit rank floor. + The cap-two price argument does not classify that changed alphabet. + +## Credit, overlap and limits + +David Arias's PR2738 supplies the rank-priced Coxeter theorem. Ross Richardson's +PR1989 supplies the symmetric-group cut theorem, and PR2415 supplies the GL2 +bridge and changed-price handoff. Adam Gall's PR1941 and Ross Richardson's +PR1966 retain the cut-method credit. Arham Tahir's +[PR1919](../ut3-rank-bounded-block-calls/README.md) supplies a related cyclic +rank-capped batching precedent for the distinct UT3 central target. +Ali Romman's [PR5031](../mixed-gl2-block-tariff/README.md) prices mixed GL2 +blocks at rank one and does not admit unit-priced rank-two invocations. +The underlying register-model lineage includes eumemic, Ali Romman, +Gareth Davidson and David Govea. All retained source notices remain unchanged. + +The new contribution is the displayed five-call GL2 support schedule and +its sharp cap-two invocation/concave-price consequence. The rank bound, +GL2 bridge, general cut method and the idea of higher-rank batching are +credited predecessors. No literature-priority claim is made. + +The [CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19141448) +records the concrete scope. Base is canonical main +`4c0a359d88f22f05189d51f48387750b801a45d4`, priority revision seven. +A submission checkpoint fetched main at +`9269eea18a6a10dddeac6a4f696904c55ef1d365`; guidance, selected record and +the four relevant predecessor paths were unchanged. The scientific base +and immutable pins are retained. +The overlap snapshot covered 330 open PRs and 4193 Discussion records with +complete remote pagination. Sparse local coverage was 128 of 6760 note +paths, supplemented by distinctive main-tree and merged-PR searches and +direct predecessor reads. Arbitrary diffs and unpublished work are outside +that coverage. Open PR2444 concerns rank-one five-SWAP search tooling; +its changed-price boundary is a lead, not a claim to this cap-two result. + +Native/compiler admission, physical payload/tape/precision/stock costs, +a complete recursive invoice, selected cold replay, Lean, independent human +review and a complete multiplication theorem are unrun or outside scope. +The selected frontier is unchanged. See [SOURCES.json](SOURCES.json) for +immutable provenance pins and [TASK.json](TASK.json) for the scope change. + +### Verifier bounds and diagnostics + +The verifier has no recursive calls, solver, subprocess or background service. +Its matrix dimensions are at most six, group tables have six elements, +scalar-gauge enumeration has at most 512 candidates, and price-count checks +use a 13-by-13 grid. Each routine is shorter than sixty physical lines. +Explicit exceptions retain all invariants under optimized Python. + +Python dynamically allocates tuples, lists and arbitrary-size integers. This +is a managed-runtime deviation from fixed allocation, confined to the bounded +finite verifier, not a real-time or native-memory guarantee. The dimension +and enumeration caps bound live collections; no unbounded input is accepted. +The compensating checks are the normal and optimized warning-strict registered +commands. Revisit allocation and capacity if these corroboration bounds grow. +No shared repository diagnostic configuration is changed. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md new file mode 100644 index 0000000000..4af01d7516 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/DIRECT-COMPARATOR-REVIEW.md @@ -0,0 +1,42 @@ +# Independent narrow review of the #5083 physical comparator screen + +2026-10-23. **PASS within the declared source interpretation and tariff hypotheses.** This reviews the economic/source-orientation result in `outputs/new-approach-ceilings-20261023/DIRECT-COMPARATOR-PROOF.md`, SHA256 `7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0`. It does not replay Nick Petalas's formal theorem or a physical cap-two supplier. Substantial OpenAI Codex assistance; no independent human review is claimed. + +The exact retained source distinguishes scalar role rank from address width. The #2415 group bridge maps a,b,s to (12),(23),(13), preserving formal multiplication. The frozen BIT note defines the unweighted primitive `F(H,D)=(C D,C H)`, with C reversing atom positions, and it preserves complete spectators. Acting chronologically on three chunks gives + +``` +(x,y,z) -> (Cy,Cx,z) -> (Cy,Cz,x) -> (z,y,x). +``` + +Thus aba and bab yield ordinary J13. This is an unweighted interpretation; ancestor-dependent diagonal weights need their own matched identity and bill. For an ordinary-swap primitive, the required J13 is directly available, so three target roles already have the three-J competitor. That larger physical alphabet does not refute #5083's scoped five-call optimum in its restricted formal alphabet. + +The source `notes/three-stage-cover-bit.tex:172–187` gives `J_A=R_tail F_A R_tail`, with each tail reversal supplied by an unweighted reversed call of width floor(f/2). The available direct recipe therefore has recursive upper tariff `3F+6Q`, before its declared outside work. The source's larger-address child retains volume V/W; merging two independent role owners doubles payload volume and does not justify substituting an address-width price. These types were checked in the frozen source excerpts. + +For matched complete tariffs, the proposed price is `F+4B+wNew` and this direct recipe costs at most `3F+6Q+wDirect`. With `Delta=wNew-wDirect`, any strict improvement must satisfy + +``` +B < (2F+6Q-Delta)/4. +``` + +The upper-recipe logic is sound: if the new price is at least the constructive upper recipe, an available direct implementation is no more expensive. Passing the inequality is only a necessary economic screen; the direct recipe need not be optimal. A constructive `B<=2F` is an upper bound, and cannot be used as a lower bound on novel physical suppliers. Unknown outside work, unequal label prices, precision/orientation or payload mismatches prevent a complete physical conclusion. Delta must exclude costs already counted in F,Q,B. + +Under the expressly hypothetical power tariff `F=K f^tau`, `Q=K floor(f/2)^tau`, `B=2^tau F`, Delta=0 and `0<=C<=17/5000`, tau=1−C, put x=2^tau. The proof correctly obtains + +``` +Q/F <= 1/x, +(new-direct-upper)/F >= 4x-2-6/x, +4x-2-6/x = 2(2x-3)(x+1)/x. +``` + +The exact integer inequality `399^5000 < 2^4983 200^5000` proves x>399/200 over the complete domain. Because the deficit increases in x and the break-even cap decreases, + +``` +necessary B/F < 333/266, +nominal deficit/F > 19767/6650 > 0. +``` + +The transition x=3/2 and the opposite sign below it are correctly scoped. At odd widths the floor strengthens this exclusion; f=1 has Q=0. This is a tariff/comparator transition, not a κ ceiling or proof that no cheaper physical B can exist. A sufficiently negative, independently proved outside-work difference could also change the result. + +The independent checker `check_economic_reviews.py --direct-only` authenticates the frozen packet and all its source manifests, checks exact payload permutations at widths 1,2,3,4,7,8 including an untouched dirty spectator, derives the threshold and exact integer/rational domain constants, and retains equality and opposite-sign controls. It imports no author engine and executes no author formal-word or native verifier. Normal and `-O` JSON are byte-identical. The output is `ECONOMIC-REVIEWS-DIRECT-RESULT.json`. + +Credit Nick Petalas for #5083's formal schedule and price theorem; Ross Richardson for the #2415 bridge; David Arias and the root-cut predecessors; the BIT and physical-source contributors; the sibling physical worker for the frozen interface extraction; and the ceilings worker for the comparator proof under review. The next useful physical gate remains one actually eligible caller with complete identically typed F,Q,B and outside-work prices. No supplier, compiler reserve, complete output inventory or new κ is admitted by this review. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json new file mode 100644 index 0000000000..6796516026 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json @@ -0,0 +1,64 @@ +{ + "status": "PASS_SCOPED_INDEPENDENT_ECONOMIC_REVIEW_DIRECT", + "author_packet_hashes_before": { + "DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + "author_packet_hashes_after": { + "DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + "direct_comparator": { + "status": "PASS_SCOPED_SOURCE_ORIENTATION_AND_CONDITIONAL_TARIFF_REVIEW", + "orientation_width_controls": [ + 1, + 2, + 3, + 4, + 7, + 8 + ], + "complete_tariff_cases": [ + { + "B": "6/5", + "Delta": "0", + "new_minus_direct_upper": "-1/5", + "strict_B_threshold": "5/4" + }, + { + "B": "5/4", + "Delta": "0", + "new_minus_direct_upper": "0", + "strict_B_threshold": "5/4" + }, + { + "B": "3/2", + "Delta": "0", + "new_minus_direct_upper": "1", + "strict_B_threshold": "5/4" + }, + { + "B": "3/2", + "Delta": "-2", + "new_minus_direct_upper": "-1", + "strict_B_threshold": "7/4" + } + ], + "domain_C": [ + "0", + "17/5000" + ], + "strict_x_lower": "399/200", + "strict_necessary_B_over_F_upper": "333/266", + "strict_nominal_deficit_lower": "19767/6650", + "upper_recipe_logic": "Failure to beat a constructive upper recipe excludes improvement against an available competitor; passing is not a physical admission or optimality proof", + "power_B_price": "hypothetical only; scalar owner rank is not recursive address rank", + "author_formal_theorem_replay": false, + "new_kappa": null + }, + "source_author_packets_edited": false, + "native_or_compiler_execution": false, + "new_kappa": null +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json new file mode 100644 index 0000000000..6796516026 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/ECONOMIC-REVIEWS-DIRECT-RESULT.json @@ -0,0 +1,64 @@ +{ + "status": "PASS_SCOPED_INDEPENDENT_ECONOMIC_REVIEW_DIRECT", + "author_packet_hashes_before": { + "DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + "author_packet_hashes_after": { + "DIRECT-COMPARATOR-PROOF.md": "7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0", + "SOURCES.json": "5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb", + "CHECK-RESULT.json": "c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b" + }, + "direct_comparator": { + "status": "PASS_SCOPED_SOURCE_ORIENTATION_AND_CONDITIONAL_TARIFF_REVIEW", + "orientation_width_controls": [ + 1, + 2, + 3, + 4, + 7, + 8 + ], + "complete_tariff_cases": [ + { + "B": "6/5", + "Delta": "0", + "new_minus_direct_upper": "-1/5", + "strict_B_threshold": "5/4" + }, + { + "B": "5/4", + "Delta": "0", + "new_minus_direct_upper": "0", + "strict_B_threshold": "5/4" + }, + { + "B": "3/2", + "Delta": "0", + "new_minus_direct_upper": "1", + "strict_B_threshold": "5/4" + }, + { + "B": "3/2", + "Delta": "-2", + "new_minus_direct_upper": "-1", + "strict_B_threshold": "7/4" + } + ], + "domain_C": [ + "0", + "17/5000" + ], + "strict_x_lower": "399/200", + "strict_necessary_B_over_F_upper": "333/266", + "strict_nominal_deficit_lower": "19767/6650", + "upper_recipe_logic": "Failure to beat a constructive upper recipe excludes improvement against an available competitor; passing is not a physical admission or optimality proof", + "power_B_price": "hypothetical only; scalar owner rank is not recursive address rank", + "author_formal_theorem_replay": false, + "new_kappa": null + }, + "source_author_packets_edited": false, + "native_or_compiler_execution": false, + "new_kappa": null +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json new file mode 100644 index 0000000000..4cdefc0418 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/FREEZE.json @@ -0,0 +1,100 @@ +{ + "status": "LOCAL_INDEPENDENT_VERIFICATION_FREEZE_NO_PUBLIC_WRITE", + "source_candidate_result": "CORRECTED_SOURCE_SPECIFICATION_PASS_DECLARED_PRODUCT_PLACEMENT_REJECTED", + "files": [ + { + "path": "CONDITIONAL-P2-REVIEW.md", + "sha256": "657e8639d3d5fa51a1118684bde461a5b8b2d23188946b6d2a752241cfe6c842", + "bytes": 5056 + }, + { + "path": "DECLARED-PRODUCT-RESULT-OPTIMIZED.json", + "sha256": "8886de3259fadf04e8b014b9bc56222fa26a550b6c800e38d5c16c23c8183ea2", + "bytes": 13899 + }, + { + "path": "DECLARED-PRODUCT-RESULT.json", + "sha256": "8886de3259fadf04e8b014b9bc56222fa26a550b6c800e38d5c16c23c8183ea2", + "bytes": 13899 + }, + { + "path": "DIRECT-COMPARATOR-REVIEW.md", + "sha256": "d512aaffbf0fbe53918de2850ae725b9375e1f060018bc9759def4be55572999", + "bytes": 4480 + }, + { + "path": "ECONOMIC-REVIEWS-DIRECT-RESULT-OPTIMIZED.json", + "sha256": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319", + "bytes": 2117 + }, + { + "path": "ECONOMIC-REVIEWS-DIRECT-RESULT.json", + "sha256": "3bf4554d2266fe1c42673cbfad3693c25f99a32a9d366df90aae5c7f3efff319", + "bytes": 2117 + }, + { + "path": "ECONOMIC-REVIEWS-P2-RESULT-OPTIMIZED.json", + "sha256": "815aef1d6b271b065b90e731d359d8cc6432c0303ce40dfad0fac6e20f60ebb2", + "bytes": 3202 + }, + { + "path": "ECONOMIC-REVIEWS-P2-RESULT.json", + "sha256": "815aef1d6b271b065b90e731d359d8cc6432c0303ce40dfad0fac6e20f60ebb2", + "bytes": 3202 + }, + { + "path": "ECONOMIC-REVIEWS-RESULT-OPTIMIZED.json", + "sha256": "22ce0902c437500ccec324eee3e4ea36df305101593ecc0abc8577cc07827a38", + "bytes": 5076 + }, + { + "path": "ECONOMIC-REVIEWS-RESULT.json", + "sha256": "22ce0902c437500ccec324eee3e4ea36df305101593ecc0abc8577cc07827a38", + "bytes": 5076 + }, + { + "path": "PRODUCER-AND-PRODUCT-REVIEW.md", + "sha256": "89a1689cc6b3ccf1432a4bb3c7557570837a309aafd357d2d579f1f710ee1165", + "bytes": 9541 + }, + { + "path": "PRODUCER-PACKET-RESULT-OPTIMIZED.json", + "sha256": "472c530ff90be020426a5345e1c2b7ff3d8e4dcb5bef12903b160b5b2f0ed6d2", + "bytes": 4294 + }, + { + "path": "PRODUCER-PACKET-RESULT.json", + "sha256": "472c530ff90be020426a5345e1c2b7ff3d8e4dcb5bef12903b160b5b2f0ed6d2", + "bytes": 4294 + }, + { + "path": "STATE.md", + "sha256": "61166f2c68a14090f1caae57e182ae1791a45c9af2084965a1ae1b9d44767821", + "bytes": 1470 + }, + { + "path": "check_declared_product.py", + "sha256": "33ece9b807bcb9768c572c8dcdd017634c2c416efdf1f3b8f52542039b84f6c9", + "bytes": 8830 + }, + { + "path": "check_economic_reviews.py", + "sha256": "4f372d4dba50e8fa96820f8287241d6accaa44149229a5544387dacd96b3ec8e", + "bytes": 12146 + }, + { + "path": "check_producer_packet.py", + "sha256": "31650ed29698a6f835c98ddbb9ac1a6c55113aad9c0255d668f6a5a9e9d2e418", + "bytes": 16536 + } + ], + "replays": [ + "check_producer_packet.py", + "check_declared_product.py", + "check_economic_reviews.py --p2-only", + "check_economic_reviews.py --direct-only" + ], + "optimized_equivalence": "ALL_NORMAL_OPTIMIZED_PAIRS_BYTE_IDENTICAL", + "no_native_or_compiler_execution": true, + "new_kappa": null +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py new file mode 100644 index 0000000000..e977984c43 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/outputs/new-approach-verification-20261023/check_economic_reviews.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +"""Independent bounded accounting review. No author or native engine imported. + +P2 powers use fresh positive exp series and reciprocal bounds, distinct from +the reviewed worker's alternating negative exp engine. All decisions rational. +""" +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from hashlib import sha256 +from pathlib import Path +import ast +import json +import re +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +AUTHOR = ROOT/'outputs/new-approach-ceilings-20261023' +PINS = { + 'DIRECT-COMPARATOR-PROOF.md':'7462ddb298e137dd397d9dd59253d1287ca85288e3e97b151f1939f208b8b1e0', + 'SOURCES.json':'5a559fec47ea22c25a94c92ed5e4208d2788151a810912ea5701426063edb1bb', + 'CHECK-RESULT.json':'c756dbb2f47356706fc46611599ba56cbf4520360b6383fa6c02dd728ec95d5b', + 'centre0-p2/SOURCES.json':'30f720c1debd63c091280752d340ca514987f1bfa789432be177291da65592b9', + 'centre0-p2/CHECK-RESULT.json':'ce7b255e9645c66a99e5e4a849a6896b1024d9986c1b32c76943305428e08449', + 'centre0-p2/REPORT.md':'c5cea3ffb6f8fe129bb9207d619bb8d290e430fd6403532f8f2db52c32981c70', +} + + +def require(ok, label): + if not ok: + raise RuntimeError(label) + + +def authenticate(mode): + pins = {p:q for p,q in PINS.items() if mode == 'both' or + (p.startswith('centre0-p2/') == (mode == 'p2'))} + got = {p:sha256((AUTHOR/p).read_bytes()).hexdigest() for p in pins} + require(got == pins, 'reviewed author packet changed') + subdirs = ('','centre0-p2') if mode == 'both' else (('centre0-p2',) if mode == 'p2' else ('',)) + for subdir in subdirs: + base = AUTHOR/subdir + manifest = json.loads((base/'SOURCES.json').read_text()) + for item in manifest['files']: + path = base/item['snapshot'] if item.get('snapshot') else ROOT/item['provenance'] + require(sha256(path.read_bytes()).hexdigest() == item['sha256'], 'source manifest hash '+str(path)) + return got + + +@lru_cache(maxsize=None) +def log_series(z): + require(0 <= z <= Q(1,3), 'atanh series domain') + # log((1+z)/(1-z)) has positive terms. Bound every omitted denominator + # below by 2N+1 and sum the remaining geometric powers. + N = 48 + lo = sum((2*z**(2*j+1)/Q(2*j+1) for j in range(N)),Q()) + tail = 2*z**(2*N+1)/((2*N+1)*(1-z*z)) + return lo,lo+tail + + +@lru_cache(maxsize=None) +def logint(r): + require(isinstance(r,int) and 1 <= r <= 17, 'bounded positive rank') + k = r.bit_length()-1 + t = Q(r,2**k) + a,b = log_series((t-1)/(t+1)) + c,d = log_series(Q(1,3)) + return a+k*c,b+k*d + + +def exp_positive(t): + require(0 <= t < Q(1,50), 'positive exp range') + N = 24 + term,total = Q(1),Q(1) + for j in range(1,N+1): + term *= t/j + total += term + first_omitted = term*t/(N+1) + upper_tail = first_omitted/(1-t/(N+2)) + return total,total+upper_tail + + +@lru_cache(maxsize=None) +def rankpower(r,c): + require(0 <= c <= Q(17,5000), 'bounded saving domain') + l,u = logint(r) + require(u < 3, 'rank logarithm below3') + exp_lower = exp_positive(c*l)[0] + exp_upper = exp_positive(c*u)[1] + return r/exp_upper,r/exp_lower + + +def moment(hist,c): + pairs = [(n,rankpower(r,c)) for r,n in hist.items()] + return tuple(sum((n*x[k] for n,x in pairs),Q()) for k in (0,1)) + + +def outward(a,b,places=24): + scale = 10**places + low = (a*scale).__floor__() + high = (b*scale).__ceil__() + return {'lower':str(Q(low,scale)),'upper':str(Q(high,scale)), + 'scale':scale,'floor_units':low,'ceil_units':high} + + +def direct_review(): + # Symbolic payload entries are (original_chunk,index). C reverses index. + # Exact permutation composition checks orientation, not the source theorem. + def swap_reverse(state,a,b): + out = [list(x) for x in state] + out[a],out[b] = list(reversed(state[b])),list(reversed(state[a])) + return out + def J(state,a,b): + out = [list(x) for x in state] + out[a],out[b] = list(state[b]),list(state[a]) + return out + tested = [] + for width in (1,2,3,4,7,8): + start = [[(owner,j) for j in range(width)] for owner in range(4)] + out = swap_reverse(swap_reverse(swap_reverse(start,0,1),1,2),0,1) + require(out == J(start,0,2), 'F12 F23 F12 ordinary J13 including spectator') + out2 = swap_reverse(swap_reverse(swap_reverse(start,1,2),0,1),1,2) + require(out2 == out, 'bab orientation') + # R_tail reverses only the later field of this two-bank operation. + wrapped = [list(x) for x in start] + wrapped[1].reverse() + wrapped = swap_reverse(wrapped,0,1) + wrapped[1].reverse() + require(wrapped == J(start,0,1), 'Rtail F Rtail ordinary target') + tested.append(width) + # Delta is NEW outside overhead minus DIRECT outside overhead. These + # algebraic differences compare complete matched tariffs to one upper recipe. + tariff_cases = [] + for b,delta in ((Q(6,5),Q()),(Q(5,4),Q()),(Q(3,2),Q()),(Q(3,2),Q(-2))): + f,q = Q(1),Q(1,2) + difference = f+4*b+delta-(3*f+6*q) + threshold = (2*f+6*q-delta)/4 + require((difference < 0) == (b < threshold), 'complete tariff threshold') + tariff_cases.append({'B':str(b),'Delta':str(delta),'new_minus_direct_upper':str(difference), + 'strict_B_threshold':str(threshold)}) + require(399**5000 < 2**4983*200**5000, 'uniform domain integer power bound') + x = Q(399,200) + cap,deficit = Q(1,2)+Q(3,2)/x,4*x-2-6/x + require(cap == Q(333,266) and deficit == Q(19767,6650), 'exact sharp rational constants') + require((4*Q(3,2)-2-6/Q(3,2)) == 0, 'transition equality') + require(4*Q(7,5)-2-6/Q(7,5) < 0, 'sign reversal below transition') + # d/dx(4x-2-6/x)=4+6/x²>0, and cap decreases in x. + require(4+6/(x*x) > 0, 'monotone nominal deficit') + return {'status':'PASS_SCOPED_SOURCE_ORIENTATION_AND_CONDITIONAL_TARIFF_REVIEW', + 'orientation_width_controls':tested,'complete_tariff_cases':tariff_cases, + 'domain_C':['0','17/5000'],'strict_x_lower':'399/200', + 'strict_necessary_B_over_F_upper':str(cap),'strict_nominal_deficit_lower':str(deficit), + 'upper_recipe_logic':'Failure to beat a constructive upper recipe excludes improvement against an available competitor; passing is not a physical admission or optimality proof', + 'power_B_price':'hypothetical only; scalar owner rank is not recursive address rank', + 'author_formal_theorem_replay':False,'new_kappa':None} + + +def p2_review(): + base = AUTHOR/'centre0-p2' + checked = json.loads((base/'CHECK-RESULT.json').read_text()) + design = json.loads((base/'frozen/AUTHOR-OPTIMISTIC-SCREEN.json').read_text()) + producer = json.loads((base/'frozen/SOURCE-DERIVED-PRODUCER.json').read_text()) + native_audit = json.loads((HERE/'PRODUCER-PACKET-RESULT.json').read_text()) + require(native_audit['status'] == 'PASS_SOURCE_PACKET_AUDIT_ONLY', 'independent source packet audit') + require(sha256((base/'frozen/SOURCE-DERIVED-PRODUCER.json').read_bytes()).hexdigest() + == native_audit['packet_hashes_after']['CORRECTED-DERIVATION.json'], 'exact same corrected producer') + local = Counter({int(k):v for k,v in producer['paid_profile'].items()}) + paid = Counter({r:2*n for r,n in local.items()}) + paid[1] += 336 + paid[8] += 224 + targets = Counter({int(k):2*v for k,v in producer['full_independent_inputs']['helper_native_target_rank_profile'].items()}) + require(sum(targets.values()) == 816, 'each original helper credited once') + targets[9] += 224 + targets[17] += 224 + require(dict(paid) == {1:4754,2:824,3:1020,4:254,5:80,8:226}, 'full conditional payment incidence') + require(dict(targets) == {4:56,7:14,8:94,9:876,17:224}, 'full unproved target grant') + require(dict(paid) == {int(k):v for k,v in design['conditional_paid_minimum'].items()}, 'author paid profile') + require(dict(targets) == {int(k):v for k,v in design['target_grant'].items()}, 'author target grant') + require(design['status'] == 'AUTHOR_DESIGN_OPTIMISM_ONLY_UNREALIZED_TARGET_GRANT', 'unrealized status') + proposal = (base/'frozen/FAILED-PREDECESSOR-PROPOSAL.md').read_text() + require('required h endpoint fails' in proposal, 'predecessor failure stays explicit') + original_paid = ast.literal_eval(re.search(r'`P=(\{[^\n]+\})`',proposal).group(1)) + require(original_paid[8]+2 == paid[8] and original_paid[1] == paid[1], '+2H8 and no H1 removal') + a,b = Q('.0030217758'),Q('.00339999') + points = {} + for c in (a,b): + tl,tu = moment(targets,c) + pl,pu = moment(paid,c) + lo,hi = tl-pu,tu-pl + recorded = checked['point_enclosures'][str(c)] + require(Q(recorded['outward_lower']) <= lo <= hi <= Q(recorded['outward_upper']), + 'independent positive-exp interval inside reported outward enclosure') + points[str(c)] = outward(lo,hi) + if c == b: + minimum_lo,minimum_hi = lo,hi + # H_r decreases, log r is nonnegative, so this is an upper derivative on [a,b]. + paid_upper = sum((n*rankpower(r,a)[1]*logint(r)[1] for r,n in paid.items()),Q()) + targets_lower = sum((n*rankpower(r,b)[0]*logint(r)[0] for r,n in targets.items()),Q()) + derivative_upper = paid_upper-targets_lower + require(derivative_upper < -19660, 'uniform strict derivative upper bound') + require(12 < minimum_lo <= minimum_hi < 13, 'minimum endpoint sharp H1 integer budget') + require(rankpower(12,a)[1] < minimum_lo, 'single rank12 fits entire interval') + require(rankpower(13,b)[0] > minimum_hi, 'single rank13 fails included endpoint') + placement = json.loads((HERE/'DECLARED-PRODUCT-RESULT.json').read_text()) + require(placement['status'] == 'REJECT_DECLARED_PRODUCT_PLACEMENT_BY_EXACT_NECESSARY_UNIT_IDENTITY', + 'failed candidate placement cannot be omitted from interpretation') + return {'status':'PASS_CONDITIONAL_RELAXATION_ARITHMETIC_ONLY_FAILED_PLACEMENT_RETAINED', + 'independent_method':'48-term rational atanh log plus positive 24-term exp with geometric tail and reciprocal; no author/worker engine imported', + 'target_grant':dict(sorted(targets.items())),'conditional_paid':dict(sorted(paid.items())), + 'original_helpers_once':816,'unproved_main_jobs':448,'new_H8':2,'removed_H1':0, + 'point_enclosures':points,'derivative_upper':outward(derivative_upper,derivative_upper), + 'minimum_at':'included right endpoint by uniform strict decrease', + 'maximum_additional_integer_H1_calls':12,'thirteen_positive_rank_calls_fail_at_b':True, + 'largest_single_additional_integer_rank_uniformly':12, + 'remaining_after12H1_at_b':outward(minimum_lo-12,minimum_hi-12), + 'candidate_declared_product_placement':'FAILED_e1_coefficient0_residual42', + 'compiler_reserve':None,'finite_work_funded':False,'actual_caller':False,'new_kappa':None} + + +def main(): + require(not ('--p2-only' in sys.argv and '--direct-only' in sys.argv), 'choose one separate review mode') + mode = 'p2' if '--p2-only' in sys.argv else ('direct' if '--direct-only' in sys.argv else 'both') + before = authenticate(mode) + after_values = {} + if mode in ('both','direct'): + after_values['direct_comparator'] = direct_review() + if mode in ('both','p2'): + after_values['corrected_centre_p2_relaxation'] = p2_review() + after = authenticate(mode) + result = {'status':'PASS_SCOPED_INDEPENDENT_ECONOMIC_REVIEW_'+mode.upper(), + 'author_packet_hashes_before':before,'author_packet_hashes_after':after, + **after_values, + 'source_author_packets_edited':False,'native_or_compiler_execution':False, + 'new_kappa':None} + stem = 'ECONOMIC-REVIEWS' + ('' if mode == 'both' else '-'+mode.upper()) + '-RESULT' + out = HERE/(stem+('-OPTIMIZED' if sys.flags.optimize else '')+'.json') + out.write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({'status':result['status'],'result':str(out)})) + + +if __name__ == '__main__': + main() diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json new file mode 100644 index 0000000000..4e0a3cdca2 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/FILES.json @@ -0,0 +1,20 @@ +{ + "REPORT.md": "71bb4f5ab05bf4da2887ccdcb32ff1ee00994347591f9954d22fca515cb86bd2", + "SOURCES.json": "446fff2e65151972205503e7e713da6e47b89d62be59a4b51937fea9fa2cafdd", + "source/certificates__frontier4470__CLAIM.json": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232", + "source/certificates__selected-result.json": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375", + "source/notes__batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "source/notes__batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "source/notes__general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "source/notes__three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "source/research__coxeter-root-tariff__PROOF.md": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8", + "source/research__gl2-swap-cut-corollary__README.md": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9", + "source/research__kappa-rebuild__bit__README.md": "351a9111292f3d406f94fd3c0f78867c8f421887f5073c0fb8fcef8a1377b02e", + "source/research__kappa-rebuild__bit__bit_native_binding.py": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7", + "source/research__kappa-round6-compiler-tightening-20261022__README.md": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba", + "source/research__mixed-gl2-block-tariff__README.md": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0", + "source/research__rank2-swap-batching__README.md": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054", + "source/research__rank2-swap-batching__SOURCES.json": "0026e1286fb9377ed5862fe91c109f34be038d2058fb50cba951f6cd362108d6", + "source/research__rank2-swap-batching__TASK.json": "fefb528b755540d19b5f65ac13bed14689461d0d2741441e84d88cc068c0c3e7", + "source/research__ut3-rank-bounded-block-calls__README.md": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md new file mode 100644 index 0000000000..91fc60feb8 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/REPORT.md @@ -0,0 +1,218 @@ +# Three-SWAP cap-two mechanism: physical-interface feasibility + +**Read/derive outcome: the formal changed mechanism is soundly separated from +its missing physical supplier. No strictly subadditive cap-two physical call +was identified in the declared source lineage. No eligible paid occurrence, +changed recursive histogram, emitter or new kappa is established.** + +This review concerns Nick Petalas's #5083, exact head +`d2b3f35275cab6fbf18bee40e3fb411496732e54`, and only the physical first question +in `research/rank2-swap-batching/README.md`. The author owns the formal +five-call construction; its checker was not rerun or duplicated. The monitor's +08:28 UTC ownership check found the formal claim complete, physical/native +compilation explicitly open, and no matching physical claim in its refreshed +coverage. This is a local root-authorized feasibility review, not a public +construction reservation. All inspected bytes are listed in `SOURCES.json`. + +## 1. Exact missing ABI + +The formal payload space is a direct sum of independent owner fields. For a +physical representation rho_f(g) on one complete address range Omega_f, the +attaining word needs only coordinate-projector calls of the form + + Cap2(g,{i,j}): (u0,u1,u2,dirty...) + -> (rho_f(g)u_i, rho_f(g)u_j, all other original fields unchanged), + +with g=a or b. Every u_r is an arbitrary independent payload function on the +complete same-shaped range; arbitrary row and other spectators are retained. +There are two output jobs on the two original inputs, not one job on their +sum, one zero source, or a discarded owner. The third active owner and every +dirty spectator must be individually restored. A candidate must specify the +actual representation, axis order, orientation, weights, width lifting and +complete physical entry/exit maps. The word does not need a physical +implementation for every nonidempotent rank-two N allowed in the lower-bound +model: the attaining calls use only diagonal idempotents. + +Let c1 be the complete physical charge for the matching one-owner call and +c2 that for this two-owner transaction, including preparation, routing, +storage and return to the same ABI. The formal comparison is + + new = c1+4c2, formal disjoint = 3c1+3c2, + formal saving = 2c1-c2. + +Any outside-call overhead difference must be charged separately, without +counting in-call work twice. This comparison is useful only if the actual +caller has that comparator, or a more expensive proven one. It is not a +statement that scalar rank two is a recursive rank-two child. +Both labels and all selected pair positions need the same asserted tariff; +otherwise the new bill is c1_a+2c2_a+2c2_b rather than the uniform expression. + +The diagonal attaining schedule could act on an actual representation over +other payload coefficient fields too: it merely applies group elements to +selected owners and uses no scalar XOR bridges. That observation does not +transfer the formal model's arbitrary-coupling lower bound or its tariff to +the complex construction. + +## 2. Existing BIT supplier has a different batching dimension + +The selected record retained at the reviewed head names the conditional +#4470 supplier. Its `notes/batched-bit-rows.tex`, lines 9–25, explicitly gives +each rank-r child address width r*f and exactly one role's logical volume +V/W. Repetitions are separate calls. The integer-width and spectator rules +retain the full unused address ranges. This is batching of **address +directions inside one arbitrary field**, not batching of two independent +owner fields. + +Placing two owners into two ROW values produces one same-address-width job +on volume 2V/W. Under the retained volume normalization this is charge 2c1, +before any additional packing/routing. It supplies a legal linear-price +implementation, not c2<2c1. With c2=2c1 the formal saving is zero. Treating +that pair instead as a width-2f child at volume V/W has no supplied layout or +hosting proof. In particular, a direct sum of two arbitrary functions on +Omega_f is not one arbitrary function on the product address range used by +two active address directions. Padding, cross terms and all restored values +would have to be accounted for. The ability to preserve arbitrary ROW fields +does not remove their logical volume. + +The same distinction is visible in the source-bound BIT native binding at +`20bb93cd990d2ff683e4d0fc56b87a42cd5d3296`, +`research/kappa-rebuild/bit/bit_native_binding.py`: physical projector rank is +rank in a rational head-coordinate space, and whole-rank requests act on one +current arbitrary-input role. Independent helper ownership is recorded +separately. That source supplies no two-owner cap-two price rule. + +No fixed-alphabet or fixed-tape SIMD discount is assumed. A packed payload +alphabet, growing type, shared decoder or bulk backend would be a new supplied +interface requiring its own recursive closure and complete cost argument. + +## 3. A concrete address representation, with orientation-sensitive comparator + +#2415, retained in #5083's declared sources, identifies GL2(F2) with S3: +a=(12), b=(23), s=(13). One can therefore realize those labels as permutations +of three complete address chunks, with any other fields as spectators. This +avoids silently applying the natural binary-CNOT matrix to the odd-radix atom +ring used by the actual BIT supplier. The latter is not the same address +operation: binary XOR and addition on Z/q^w have different orders. + +If all three S3 transpositions are represented as **ordinary** chunk swaps J, +the existing arbitrary-spectator BIT service also implements target s directly. +They have the same complete shape and ordinary-swap tariff. Three target +owners then have a direct recipe of price 3c_J, whereas the proposed five-call +word costs at least 5c_J when c2>=c1=c_J. The formal six-call comparator is not +the physical comparator for that representation. + +There is another relevant, cheaper-generator orientation. The retained raw +atom contract is + + F_f(H,D)=(C_f D,C_f H), + +where C_f reverses atom positions but not digits within an atom. Let a=F12 +and b=F23 on three chunks, with C=C_f and C^2=I. Direct substitution gives + + (x,y,z) --a--> (Cy,Cx,z) + --b--> (Cy,Cz,x) + --a--> (z,y,x). + +Thus aba is ordinary J13, not raw F13. These are exact address maps at every +width, with the middle chunk restored. No five-call formal-word computation +is needed for this orientation check. + +The source supplies a concrete ordinary-swap upper recipe in +`notes/three-stage-cover-bit.tex`, lines 172–187: + + J_A = R_tail F_A R_tail, + cost(J_f) <= cost(F_f)+2 cost(F_floor(f/2)). + +Each call retains the entire current logical volume, with unused digits as +spectators. This is an upper recipe, not an exact minimum. In the unweighted +case the five-call candidate for three ordinary targets must be compared +against the available bound 3F_f+6F_floor(f/2), not just its formal disjoint +word. A necessary condition to beat that explicit direct recipe is + + F_f+4c2+Delta < 3F_f+6F_floor(f/2), + +where Delta is any additional outside-call cost difference. No numerical +power price is asserted for c2. If a separate induction price F_t proportional +to t^tau were applicable at the same logical volume, this threshold would +be about c2<1.25F_f near tau=1, substantially stronger than formal strict +subadditivity alone. This is only an economic condition, not a new supplier. + +For actual raw-F targets, the displayed raw-generator word still produces J. +Conjugating each of the three targets by its tail reversal adds six half-width +calls. With c2>=c1=F_f, that particular wrapped recipe cannot beat three +direct F_f calls. Absorbing the reversals into existing layouts could change +the comparison, but requires a literal matched caller proof and bill. +Weighted F_A jobs also require the same actual weights and reversed pairing; +the unweighted S3 identity does not identify different ancestor-dependent +weight arrays across changing owner pairs. + +## 4. Complex and funded-caller relevance + +In the complex native ABI, recursive rank is the Fourier rank of an actual +Clifford transition. The selected `notes/general-clifford-frames.tex` defines +the physical transition ST^-1 and its preimage-frame intersection distance. +A nested rank-r transition becomes one C^(tensor r*f) child on one field, +between actual rank-zero adapters. Its group and exact phases differ from +the scalar-owner rank used in #5083. + +Bare coordinate-CNOT or coordinate-SWAP address permutations are monomial +Clifford maps of Fourier rank zero. They are not the paid Gaussian rank-one +and rank-two jobs in the #4610 invoice. Actual native K_G lifts also include +quadratic phases; their binary permutation labels alone are not their exact +operators. Monomial movement and any BIT service they require remain charged; +rank zero does not mean a free fixed-tape implementation. Interpreting the +natural 2x2 GL2 matrices as scalar-owner ADDs instead would change the paid +alphabet again and would not create Gaussian rank. + +No literal group of three eligible completed jobs with a bound subadditive +cap-two transaction was found in the declared #4610 complex source or the +selected BIT contracts. The closest BIT shapes are ordinary-swap adapters +and reversed/weighted whole-job targets just distinguished above. Turning +them into an occurrence requires actual chronology, identical weights, +adapters, changing pair layouts, all outputs and strict child contraction; +the present source reads do not provide that binding. +No chronological occurrence census was run; this is absence of a bound +occurrence in the inspected contracts, not a universal absence theorem. + +The selected claim's admitted BIT saving is 17/5000=0.0034, whereas its complex +template and limiting main-transform saving are near 0.00302015. The frozen +#4610 round-six comparison remains near 0.0030217758 and explicitly retains +the same physical/whole-job/compiler hypotheses. A BIT-only local saving +therefore is not automatically an improvement of the binding complex moment +or the integer-multiplication kappa. No new P/T histogram is reported here. + +## 5. Smallest useful next fixture, held for root authorization + +Before any emitter or search, a prospective supplier should name one exact +Cap2(a,{0,1}) transaction at the same completed ABI, followed by the b version. +Use three active owner fields plus one arbitrary dirty spectator owner, with +the same three address chunks and a nontrivial untouched ROW field. Require +two independent transformed outputs, zero cross-owner leakage, and identity +on both other owners and every spectator. Record all entry/exit layouts, +copies, resets, buffers and charged recursive calls. + +Width f=1 alone cannot distinguish internal atom reversal from an ordinary +swap. The smallest orientation-discriminating fixture uses f=2, unequal atoms +inside each chunk, and independent payload impulses in both selected owners +and the unselected dirty owners. An exact symbolic address-permutation or +operator identity at a permitted atom radix must accompany any finite fixture; +a small-radix test is only a type/orientation control, not admission of the +large-prime cover or all widths. Wrong pairing, reversed C_f convention, +discarded dirty input and accidental owner-sum delivery should each fail. + +The decisive cost test is whether the supplier's complete transaction has a +justified price below the **actual** direct comparator, with the same logical +volumes, widths, weights and all outputs. Known two-stream packing does not. +If no source-bound subadditive supplier is provided, stop at this missing ABI +rather than relabel scalar rank as H2 or emit a hypothetical positive invoice. + +No proposed physical fixture was executed. There was no author formal replay, +source change, compiler/Lean campaign, native emitter, public post or kappa +claim. This is a source-pinned feasibility handoff. + +Credit Nick Petalas for #5083; David Arias, Ross Richardson, Adam Gall and the +retained group-cut/model lineage for its formal premises; the selected BIT, +native, row-cover, Clifford and compiler authors for their separate physical +contracts, including Cao Yifan, Cinna Davis, Dugongue, Jacob Sussman, eumemic +and predecessors. Prepared with substantial OpenAI Codex assistance; +Apache-2.0. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json new file mode 100644 index 0000000000..5080a04466 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/SOURCES.json @@ -0,0 +1,101 @@ +{ + "scope": "Read/derive only; exact-head source bytes, no source implementation or author formal-word replay", + "files": [ + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/rank2-swap-batching/README.md", + "local": "source/research__rank2-swap-batching__README.md", + "sha256": "2eded51bc7d80e360ff3937f3cc9feddb79e35b3f3d5ee3d69ac5b232b0d8054" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/rank2-swap-batching/TASK.json", + "local": "source/research__rank2-swap-batching__TASK.json", + "sha256": "fefb528b755540d19b5f65ac13bed14689461d0d2741441e84d88cc068c0c3e7" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/rank2-swap-batching/SOURCES.json", + "local": "source/research__rank2-swap-batching__SOURCES.json", + "sha256": "0026e1286fb9377ed5862fe91c109f34be038d2058fb50cba951f6cd362108d6" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/coxeter-root-tariff/PROOF.md", + "local": "source/research__coxeter-root-tariff__PROOF.md", + "sha256": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/gl2-swap-cut-corollary/README.md", + "local": "source/research__gl2-swap-cut-corollary__README.md", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/mixed-gl2-block-tariff/README.md", + "local": "source/research__mixed-gl2-block-tariff__README.md", + "sha256": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "research/ut3-rank-bounded-block-calls/README.md", + "local": "source/research__ut3-rank-bounded-block-calls__README.md", + "sha256": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "certificates/selected-result.json", + "local": "source/certificates__selected-result.json", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "certificates/frontier4470/CLAIM.json", + "local": "source/certificates__frontier4470__CLAIM.json", + "sha256": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/batched-bit-rows.tex", + "local": "source/notes__batched-bit-rows.tex", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/three-stage-cover-bit.tex", + "local": "source/notes__three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/general-clifford-frames.tex", + "local": "source/notes__general-clifford-frames.tex", + "sha256": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54" + }, + { + "head": "d2b3f35275cab6fbf18bee40e3fb411496732e54", + "path": "notes/batched-complex-rows.tex", + "local": "source/notes__batched-complex-rows.tex", + "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c" + }, + { + "head": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-rebuild/bit/bit_native_binding.py", + "local": "source/research__kappa-rebuild__bit__bit_native_binding.py", + "sha256": "bf6374225f388e7531fa6475cc255bd430100ff62c38d582c41601f0739de7b7" + }, + { + "head": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-rebuild/bit/README.md", + "local": "source/research__kappa-rebuild__bit__README.md", + "sha256": "351a9111292f3d406f94fd3c0f78867c8f421887f5073c0fb8fcef8a1377b02e" + }, + { + "head": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "path": "research/kappa-round6-compiler-tightening-20261022/README.md", + "local": "source/research__kappa-round6-compiler-tightening-20261022__README.md", + "sha256": "1bcab4559e34bdac32787a23b3232aacf5afcba35c9d30091e1ecc1a645845ba" + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json new file mode 100644 index 0000000000..bbf9f0bd34 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__frontier4470__CLAIM.json @@ -0,0 +1,33 @@ +{ + "schema": "proposed-conditional-integer-multiplication-claim/1", + "kappa": "60403/20000000", + "source_result": "research/joint-helper-lattice/RESULT.json", + "uniform_templates": [ + { + "family": "complex", + "rank_encoding": "2^64215200000000", + "saving": "528527/175000000" + }, + { + "family": "BIT before cover", + "rank_encoding": "2^25986965159937", + "saving": "3459/1000000" + } + ], + "ordinary_BIT_saving": "8590884599/2500000000000", + "admitted_BIT_saving": "17/5000", + "nine_outer_savings": { + "boundary_algebraic_matrix": "5919499595771787/1960000000000000000", + "fused_gaussian": "5919499587315361/1960000000000000000", + "global_coordinate_router": "2114107/700000000", + "group_bit_router": "2959750493657679/980000000000000000", + "group_scans": "699999999/700000000", + "main_transform": "5919498195771787/1960000000000000000", + "microbox_face_corrections": "26950000001/350000000", + "polynomial_products": "1399999999/1400000000", + "sparse_union_movement": "802169499595771787/1960000000000000000" + }, + "limiting_outer_saving": "5919498195771787/1960000000000000000", + "strict_limiting_slack": "4195771787/1960000000000000000", + "scope": "Maintainer-reviewed conditional PR4470 construction. Inherited native/all-column, owned-erasure, whole-job, compiler, precision/tape, analytic, prime and recovery hypotheses remain. Uniform words are not materialized." +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json new file mode 100644 index 0000000000..c35482cd90 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/certificates__selected-result.json @@ -0,0 +1,85 @@ +{ + "status": "Selected maintainer-reviewed conditional joint-helper construction; source-bound foundation reuse is explicit", + "kappa": "60403/20000000", + "decimal": "0.00302015", + "source_prs": [ + 4470, + 4447, + 4441, + 4440, + 4416, + 4433, + 4359, + 4268, + 3945, + 4085, + 2979, + 4076, + 4088, + 1673, + 1758, + 1786, + 23, + 555, + 589 + ], + "source_manifest": "certificates/frontier4470-source.json", + "certificate": "certificates/frontier4470/CLAIM.json", + "certificate_sha256": "d962932a6971b8f0054462c59f4ad699dcf3d1fbf886e1f856a6fa9e97491232", + "proof": "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md", + "proof_supplements": { + "notes/batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/semantic-bulk/pr23/semantic-bulk-17-note.tex": "652242b05174bb776ffc6165af170df9c8cf220dbd0fc26c24d778f320dbabc8", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1", + "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "docs/research/pr-intake-evidence/pr4359/PROOF-REVIEW.md": "7d67bb814285f7634029fbd378c6457156545f0b38858cc1c6ec34b68cd9d162", + "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b", + "docs/research/pr-intake-evidence/pr4416/PROOF-REVIEW.md": "2c2bbe6fe1bab44778192118f27e59a0d23dbe02c47aa8a42845093f1ce46f49" + }, + "review": "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md", + "validation": "docs/research/pr-intake-evidence/pr4470/VALIDATION.json", + "integration": "docs/research/pr-intake-evidence/pr4470/INTEGRATION.json", + "reproduce": "make frontier4470-verify", + "scope": "Maintainer-reviewed conditional PR4470 construction. Inherited native/all-column, owned-erasure, whole-job, compiler, precision/tape, analytic, prime and recovery hypotheses remain. Uniform words are not materialized.", + "previous_kappa": "23/10000", + "previous_record": "certificates/checkpoints/frontier4359.json", + "audited_source_head": "b9a13c1673e0e9697de410de16e8bbf3207a7363", + "source_certificate": "research/joint-helper-lattice/RESULT.json", + "source_certificate_sha256": "c7b2388f6511c19976b337d8c8ac374610af616866a249d75dace704eb5d9e21", + "replay_mode": "fresh changed-construction replay with exact-source prior foundation review reuse", + "contributors": "docs/research/community-joint4470-contributors.md", + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex new file mode 100644 index 0000000000..cbaa8cb42c --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__batched-bit-rows.tex @@ -0,0 +1,123 @@ +\subsection{Integer widths, bounded row padding, and mixed contractions} +\label{sec:mixed-width-rows} + +The batched residual construction uses a fixed finite list of child sizes, +not only powers of one radix. The following implementation supplies the +corresponding integer-width recursion. All constants in this subsection +are fixed finite circuit constants, independent of the input length. + +\paragraph{A general moment condition.} +Let $m,W\ge2$ be fixed. At one circuit invocation, let the list +$t_1,\ldots,t_J$ contain integers in $[1,m-1]$. A child of type $i$ has +width $t_i f$, where $f=\lfloor e/m\rfloor$, and operates on exactly +$1/W$ of the parent's logical volume. Repetitions in the list represent +separate calls. An ordinary rank-one call has $t_i=1$; a batched block +has the corresponding larger value of $t_i$. Full-rank edges may retain +their original $m$ rank-one calls, so no same-width recursive call is +needed. Put +\[ + \Psi(x)=\frac1W\sum_{i=1}^J(t_i/m)^x, + \qquad t_* = \max_i t_i \tau$, every internal width is at least $d^\beta$, so +$e^\tau\le d^{\beta(\tau-\sigma)}e^\sigma$; summing the strict +$\sigma$-moment gives +$O(G^\tau d^{\sigma+\beta(\tau-\sigma)})$. +Thus in both cases, with +\[ + \chi=\tau+(1-\beta)\max\{\sigma-\tau,0\}, +\] +the complete normalized layer cost is +\[ + O\!\left((\log p)^3\left[ + d^\chi+d^{\sigma+\beta(1-\sigma)} + +d^{\max\{1-c,0\}}+1\right]\right). +\] +The displayed logarithmic factor conservatively retains the existing +layout and descriptor allowances. Hence the original strict conditions +\[ + \max\{\tau,\sigma,\chi\}<\lambda<\lambda'<1, + \qquad + \max\{\sigma+\beta(1-\sigma),1-c,0\}<\lambda' +\] +continue to imply the complete $O(Vd^{\lambda'})$ layer bound. + +\paragraph{Compatibility with the new dependency guard.} +The separate dependency-path estimate uses $q=m+6h=22120$, observes that +one path crosses at most one selected bulk residual, and bounds its +$\rho$-moment by +\[ + \max\left\{ + \frac q{m^\rho},\quad + \frac{q-a_1}{m^\rho}+\left(\frac{a_1}{m}\right)^\rho,\quad + \frac{q-a_2}{m^\rho}+\left(\frac{a_2}{m}\right)^\rho + \right\}<\frac{999}{1000} + \quad\left(\rho=\frac65\right). +\] +Integer floors only shrink these children. For sufficiently large $d$, +an internal parent has $e\ge d^\beta\ge2m$, hence every recursive child +has width at least $\lfloor e/m\rfloor\ge d^\beta/(2m)$ whenever it +becomes a stopping leaf. The at most $m-1$ individually processed +remainder axes at each internal node belong to its fixed local overhead; +add their bounded coefficient contribution to the guard's fixed constant +$E$. They are not extra arbitrarily small stopping leaves. Thus the +separately established guard exponent +\[ + C_1=\rho-(\rho-1)\beta+\zeta + =\frac65-\frac\beta5+\zeta +\] +applies to this integer-width implementation. All stopping tests can be +performed by the existing rational-power integer comparison. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__general-clifford-frames.tex b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__general-clifford-frames.tex new file mode 100644 index 0000000000..0367eeb005 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/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/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex new file mode 100644 index 0000000000..f05225d21f --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/notes__three-stage-cover-bit.tex @@ -0,0 +1,264 @@ +\subsection{Atom contract and common endpoint} +Fix an odd prime $q$, chosen below, and put $R_w=\mathbb Z/q^w\mathbb Z$. +An atom is a complete consecutive $w$-digit address field. Write $C_n$ for +reversal of the $n$ atom positions, without reversing digits inside an atom. +The recursive contract is the involution +\[ + F_A(H,D)=(AC_nD,C_nA^{-1}H), +\] +where $A$ is a diagonal array of units on the head atoms. Its entries may +depend on exposed ancestor row fields and the atom index, but not on the +fresh role fields of this invocation or on the head/data values. Only the +polynomial-time descriptors generated by the construction are required; +no constant-cost oracle for arbitrary functions of a prefix is assumed. +Every call preserves all complete spectator fields and restores its row +coordinate. The original unweighted call has $A=I$. + +For a split idempotent $P$ on the head coordinates set +\[ + D_P=\begin{pmatrix}I-P&PC_n\\C_nP&I-C_nPC_n\end{pmatrix}, + \qquad F=D_I. +\] +These are involutions, and $D_P-I$ has split rank $\operatorname{rank}P$. +Nested commuting-projector identities are polynomial identities and require +no symmetry of $P$. For $n=mf$ and $G=g\otimes I_f$ define +\[ + Q_g=\operatorname{diag}(G,C_nGC_n). +\] +Then $Q_gF=FQ_g$ and $Q_gD_PQ_g^{-1}=D_{GPG^{-1}}$. +Consequently conjugating every base frame by any $g\in\operatorname{GL}_m(R_w)$ +leaves the same full physical endpoint $F$. + +Put $Q_A=\operatorname{diag}(A,I)$. Conjugate the entire completed scalar +word by $Q_A$. Scalar gates mix roles having the same address map, so they +commute with $Q_A$. A current role routing also commutes with $Q_A$, since +it changes only fresh fields. Thus only address residuals change, and the +completed endpoint is $Q_AFQ_A^{-1}=F_A$. More explicitly, when a port +changes charts from $g$ to $gR_s$, its local label changes from $M$ to +$R_s^{-1}MR_s$, and +\[ + (gR_s)(R_s^{-1}MR_s)(gR_s)^{-1}=gMg^{-1}. +\] +This routing is a change of row/chart, not an uncharged dense address map. +The adapted chart $Q_AQ_gQ_A^{-1}$ commutes with $F_A$. None of these +conjugations is executed as an extra normalization pass. + +\subsection{Explicit rational three-stage geometry} +Use the retained PR97 local producer with +\[ + h=23,\qquad v=1771,\qquad R_{\rm loc}=28866,\qquad \ell=506. +\] +Its physical projector ranks and scalar word are unchanged. On +$\mathcal A=\mathbb Q^{23}$ take the form $H_0=(I-J/9)/2$. +For a triple $S$ let $q_S=\chi_S$; then $q_S^tH_0q_S=1$. +Fix $q_0=\chi_{\{1,2,3\}}$ and $K=q_0^\perp$. A rational basis is +\[ + k_i=e_i-(e_i^tH_0q_0)q_0,\qquad 2\le i\le23. +\] +Projection along $q_0$ is injective on the span of $e_2,\ldots,e_{23}$, +since $q_0$ has nonzero first coordinate. Thus this is indeed a basis. +Let $\mathcal B,\mathcal C$ be orthogonal copies of $K$ and put +$\mathcal E=\mathcal A\perp\mathcal B\perp\mathcal C$, of dimension $m=67$. + +Choose a coordinate permutation $\pi_S$ taking $\{1,2,3\}$ to $S$. +It preserves $H_0$. The rational isometry $R_{12,S}$ fixes $q_S$ and +$\mathcal C$, and exchanges $\pi_Sk_i\in q_S^\perp\subset\mathcal A$ +with $k_i\in\mathcal B$. Define $R_{23,S}$ by exchanging the same vectors +with their copies in $\mathcal C$, fixing $q_S$ and $\mathcal B$. +Both maps are involutions. A hyperedge $(g,S)$ uses the invocations +$gR_{12,S},g,gR_{23,S}$, with active spaces +\[ + g(\mathcal B+\mathbb Qq_S),\qquad g\mathcal A, + \qquad g(\mathcal C+\mathbb Qq_S). +\] +Their projectors commute; their pairwise and common intersection is the +projector $P_{gq_S}$, and their sum is $I+2P_{gq_S}$. +This follows from the orthogonal decomposition +$\mathbb Qq_S\perp q_S^\perp\perp\mathcal B\perp\mathcal C$ before +conjugation. These are the cumulative-projector three-stage transfer +identities: the three scalar shears complete the interchange, with zero +interstage connectors and no rank-one endpoint correction. Each port +family visits the full cover bijectively, by right multiplication with +its displayed involution. The physical ledger is therefore three copies +of the local auxiliary, data and center histograms, and three copies of +the exterior histogram $m-\text{nullity}$. + +\subsection{One weighted child on a generic residue class} +Work first on one atom column. Let $g$ be its weighted residual involution, +of split rank $r$ relative to $I$. If the cross block has generic northeast +rank profile, unit lower row and column elimination, without normalizing +pivots, gives +\[ + Lg_{XY}R=ED_pF_0^t, + \quad E=(e_1,\ldots,e_r),\quad + F_0=(e_m,\ldots,e_{m-r+1}), +\] +with invertible diagonal $D_p$. Conjugate by $\operatorname{diag}(L,R^{-1})$. +Split rank and the unit pivot minor give a factorization +\[ + g-I=\binom EB(A_0,D_pF_0^t),\qquad + A_0E+D_pF_0^tB=-2I_r. +\] +For clarity, if $g-I=UV$, then $g^2=I$ gives +$U(VU+2I)V=0$. The unit minor supplies a left inverse of $U$ and a right +inverse of $V$, proving the identity over the local ring itself. +Set +\[ + K=-(B+F_0D_p^{-1})E^t+F_0D_p^{-1}A_0(I-EE^t), + \qquad S=\begin{pmatrix}I&0\\K&I\end{pmatrix}. +\] +The identities $KE=-B-F_0D_p^{-1}$ and +$D_pF_0^tK=A_0+E^t$ give +\[ + SgS^{-1}=\begin{pmatrix} + I-EE^t&ED_pF_0^t\\F_0D_p^{-1}E^t&I-F_0F_0^t + \end{pmatrix}. +\] +This is one weighted reversed interchange on the first $r$ head and last +$r$ tail coordinates. All other factors are unit lower intrabank maps or +lower cross-bank additive maps. Thus variable diagonal units remain in +the child's weight array rather than becoming unsupported routing passes. + +For $n=mf$, group atoms by coarse coordinate $i$ and column $j$. +If $L_P,R_P,D_P$ are unweighted normalizers for the current projector and +$A_j=\operatorname{diag}(A[if+j])$, then +$L_j=A_jL_PA_j^{-1}$ and $R_j=R_P$ are unit lower normalizers for +$A_jPC_m$. The child's exact contiguous index rule is +\[ + A_{\rm child}[kf+j]=A[i_kf+j]D_P[k]. +\] +The cross-bank atom pairing is reversed, and $C_r\otimes C_f=C_{rf}$. +Hence the middle operation is exactly one $rf$-atom call of the same +contract, with no interleaving or gathering. Its coefficients depend only +on parent prefix fields, which become ancestor spectators at the child; +the child's fresh roles come from disjoint unused row stock. + +All unit lower adapters require $O(n)$ atom passes. The retained ordered +affine lemma implements each later-target shear in $O(V)$, including +prefix-controlled offsets. The generated descriptors have polynomial cost +in $w$: good-class evaluation follows one ancestral index per level; +fallback evaluation branches by a constant per level. Since depth is +$O(\log e)$ and $w=\lceil e^{1/1000}\rceil$, this costs $e^{O(1)}=w^{O(1)}$. +Stored ancestor data use $O(w\log e)$ bits. The proof of the ordered affine +lemma still applies with these controls: polynomial preparation per prefix +is absorbed by the complete $q^w$ target fiber. Unrelated spectator counters +are incremented by ripple counting rather than read in their entirety. + +\subsection{Weighted leaves and a genuine local-ring fallback} +At one atom write $J_a=\left(\begin{smallmatrix}0&a\\a^{-1}&0\end{smallmatrix}\right)$, +$U(a)=\left(\begin{smallmatrix}1&a\\0&1\end{smallmatrix}\right)$ and +$L(b)=\left(\begin{smallmatrix}1&0\\b&1\end{smallmatrix}\right)$. +Then +\[ + J_a=\operatorname{diag}(1,-1)U(a)L(-a^{-1})U(a), + \qquad U(a)=J_1L(a)J_1. +\] +Thus a weighted leaf uses four old ordinary atom interchanges, three +prefix-controlled shifts and one fixed sign. With +$a_{\rm old}=384599/10^{10}$ it costs $O(Vw^{1-a_{\rm old}})$. +This constant occurs only at stopped leaves. + +A bad residue class cannot be treated by field Bruhat elimination: +an entry zero modulo $q$ need not vanish modulo $q^w$. Instead Gaussian +eliminate the full invertible residual of size $N_0=2m$ with unit pivots. +Each invertible Schur complement has a unit in its next pivot column; +row swaps and unnormalized additions clear that column. There are at most +$N_0(N_0-1)$ additions and $N_0$ swaps. Pivot choices are determined by +the unweighted low residue class: diagonal conjugation scales every +Schur-complement row and column by units and preserves its zero pattern. +The final diagonal has product a fixed sign, since the residual has +determinant $(-1)^r$ and row swaps change only the sign. + +A lower addition is a paid additive adapter. An upper addition is +conjugated into a lower addition by two ordinary coarse-field swaps. +For a field of $f$ atoms, let $R_{\rm tail}$ reverse the later field. +Then the ordinary weighted swap is +\[ + J_A=R_{\rm tail}F_AR_{\rm tail},\qquad + J_A(H,D)=(AD,A^{-1}H). +\] +Each $R_{\rm tail}$ is one unweighted reversed call on the first and last +$\lfloor f/2\rfloor$ atoms, fixing a possible middle atom. Thus $J_A$ +costs at most three children of widths $f,\lfloor f/2\rfloor, +\lfloor f/2\rfloor$. A paired diagonal scaling is $J_aJ_1$, at most six +children. The full diagonal is a product of $N_0-1$ such pairs and a fixed +sign. Across the two banks the reversed pairing already makes the swaps +and diagonal pairs directly reversed calls; the preceding ordinary bounds +remain conservative. Reindexing a tail weight by $j\mapsto f-1-j$ changes +only its descriptor. Charging every addition as upper therefore gives +\[ + 6N_0(N_0-1)+3N_0+6(N_0-1)<32m^2. +\] +Every child has width at most $f$, hence ratio at most $1/m$. Coefficients +are computed from constant-sized local-ring matrices and parent weight +descriptors; only units are inverted. This proves the fallback cost, +including its actual reversals, rather than assuming nonunit pivots away. + +\subsection{Finite covers, batching, and the strict moment} +Take $q>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(n=d>=0` scalar registers, each with an arbitrary entrance value. The +required complete endpoint is + +``` +T = diag([w_1],...,[w_d],1,...,1) in M_r(A). (1) +``` + +Every spectator is restored to its own entrance value, and all off-diagonal +role couplings vanish. A paid call is + +``` +D_N(s) = I_r + ([s]+1)N, +s in S, N in M_r(F2), rank(N)=1, N^2=N. (2) +``` + +Arbitrary scalar `GL_r(F2)` operations are free and may be interleaved. +Scalar entries commute with A. There are no other free address operations, +clean allocations, resets, discards, or uncharged preparation/restoration +calls. Matrix products act on columns, rightmost first. Since +`([s]+1)^2=0`, every call (2) is its own inverse. + +Let Phi be the real root set of the standard geometric representation of +`(W,S)`, let `Phi+` be its positive roots, and put `Phi-=-Phi+`. These are real +geometric roots used as distinct labels. **They are not reduced modulo two.** +Write O for a W-orbit in Phi and `O(s)` for the orbit of the simple root +`alpha_s`. Assign each root orbit a positive real price `c_O`, and charge (2) +the price `c_O(s)`. There are at most `|S|` such orbits. Define + +``` +i_O(w) = |{alpha in O intersect Phi+ : w alpha in Phi-}|, +L_c(w) = sum_O c_O i_O(w). (3) +``` + +These counts are finite, including when W is infinite. + +**Theorem.** In this model, for every finite r and every tuple in (1), the +exact minimum paid cost is + +``` +sum_(j=1)^d L_c(w_j). (4) +``` + +More strongly, the number of calls whose simple generator belongs to orbit O +is at least `sum_j i_O(w_j)`, separately for every O. One coordinate-role +circuit attains all these inequalities simultaneously. In particular, with +all prices one, the exact call count is `sum_j ell_S(w_j)`. + +The pricing hypothesis is equivalently that conjugate simple generators +have the same price. This permits different prices on different reflection +classes, for example the two classes in type B. It does **not** permit +arbitrary separate prices for the adjacent swaps of a symmetric group. + +The vacuous `r=d=0` endpoint has cost zero. Below assume r is positive; the +case `d=0` follows by the same argument and the empty circuit. + +## 2. Standard root facts used, and the weighted recurrence + +We use three standard facts from the geometric representation of a Coxeter +system: + +1. `Phi = Phi+ disjoint union Phi-`. +2. A simple s sends `alpha_s` to `-alpha_s` and permutes + `Phi+ minus {alpha_s}`. +3. `Inv(w)={alpha in Phi+ : w alpha in Phi-}` has cardinality + `ell_S(w)`. Also `w alpha_s` is negative exactly when + `ell_S(ws)=ell_S(w)-1`. + +These facts, including infinite Coxeter groups, are proved in Gert Heckman's +[Coxeter Groups, Section 4.2](https://www.math.ru.nl/~heckman/CoxeterGroups.pdf#page=71), +Theorem 4.11, Corollaries 4.12--4.13, and Theorem 4.14 (printed pages 71--73). +We use those root-theory results as cited mathematical input. The circuit +inequality and attaining formal construction are proved below. + +Here is the needed refinement by root orbit. Choose a right descent s of +w, so `ell_S(ws)=ell_S(w)-1`. By facts 2--3, + +``` +Inv(w) = {alpha_s} disjoint union s Inv(ws). (5) +``` + +Indeed `alpha_s` is inverted by w and is not inverted by ws. On every other +positive root, applying s is a bijection of the positive roots other than +`alpha_s`, and `w(s beta)=(ws)beta`. As s preserves each W-orbit, (5) gives + +``` +i_O(w) = i_O(ws) + 1[O=O(s)]. (6) +``` + +Apply (6) repeatedly to the last letters of any reduced expression for w. +The number of letters in orbit O in that expression is exactly `i_O(w)`. +Its price is therefore `L_c(w)`. This proves the weighted reduced-word fact +needed here directly from the inversion recurrence; no additional theorem +about unequal-parameter Hecke algebras is assumed. + +For completeness, the root-orbit pricing formulation agrees with reflection +conjugacy. The reflection associated to `alpha=w alpha_s` is `w s w^-1`. +Roots in one orbit therefore give conjugate reflections. Conversely, +suppose `h s h^-1=t` for simple s,t. In the geometric representation, the +image of `I-t` is the line through `alpha_t`, and also the line through +`h alpha_s`. The roots in the standard normalized representation have the +same nonzero norm, so `h alpha_s=+alpha_t` or `-alpha_t`. In the second case +composition with t changes the sign. Thus the simple roots are in one orbit. +Each orbit contains the negative of each of its roots, because the +associated reflection changes that root's sign. + +## 3. Algebraic cut rank also works for infinitely many roots + +For an orbit O, form the algebraic direct-sum vector space + +``` +V_O = direct_sum_(alpha in O) F2 e_alpha + = V_O^+ direct_sum V_O^-, +``` + +where the two summands use positive and negative root labels respectively. +Every vector has finite support. Define the permutation representation +`P_w e_alpha=e_(w alpha)`. Since `P_g P_h=P_(gh)`, it extends linearly to +an algebra homomorphism `rho_O:A -> End_F2(V_O)` and entrywise to `M_r(A)`. +The represented register space is `F2^r tensor V_O`. + +This is a permutation module on the set of real roots, not the geometric +reflection representation over a field of characteristic two. In +particular, `e_alpha` and `e_(-alpha)` are different basis vectors. + +Let H contain all role copies of `V_O^+`, and K all role copies of `V_O^-`. +For a represented operator M, define + +``` +q_O(M) = rank_F2(M[K,H]). (7) +``` + +Here the block is an actual linear map between algebraic direct sums. For +any group element w its crossing block is a partial permutation with one +nonzero column for each root of `Inv(w) intersect O`. Those columns are +different standard basis vectors. Consequently + +``` +rank(P_w[K,H]) = i_O(w). (8) +``` + +It is finite by fact 3. Every entry of a formal matrix uses finitely many +group elements, and r is finite. A finite sum of finite-rank crossing maps +has finite rank. Thus (7) is finite for every formal matrix used here, even +if Phi is infinite. All maps and their compositions are defined on the +direct sum because images of basis vectors have finite support. No infinite +series, limits, bounded-operator topology, or finite truncation of Phi is +being used. + +For two operators U,V, their two-by-two block multiplication gives + +``` +(UV)[K,H] = U[K,H] V[H,H] + U[K,K] V[K,H]. (9) +``` + +The image of a sum lies in the sum of the images. Composition cannot +increase finite rank: for `AB`, its image is contained in `image(A)` and +is a linear image of `image(B)`. Therefore (9) implies + +``` +q_O(UV) <= q_O(U)+q_O(V). (10) +``` + +The argument is the same finite-rank image inequality in finite and +infinite-dimensional spaces. It does not require invertibility or +commutativity. We apply it in the actual order of the circuit. + +## 4. Every orbit has its own complete paid-call lower bound + +A free scalar S acts as `S tensor I_(V_O)`. It preserves H and K, so its +crossing rank is zero. A paid factor (2) acts as + +``` +I + N tensor (P_s+I). +``` + +The identity part has zero crossing block. Fact 2 says that the crossing +block of `P_s` is zero if `alpha_s` is outside O, and otherwise has exactly +one nonzero entry, from `alpha_s` to `-alpha_s`. Hence the paid crossing +block is either zero or a single copy of N. In particular, + +``` +q_O(rho_O(D_N(s))) = 1[O=O(s)]. (11) +``` + +The complete target (1) is diagonal in role space. Its crossing block is +the direct sum of those of the target permutations, followed by zero +spectator blocks. By (8), + +``` +q_O(rho_O(T)) = sum_j i_O(w_j). (12) +``` + +A formal endpoint equality remains an equality under each `rho_O`. +Iterating (10), inserting the zero free-map costs and (11), and applying +(12) proves the separate call-count lower bound for every O. Multiply +these inequalities by the positive `c_O` and sum to obtain (4) as a lower +bound. All arbitrary dirty roles are included in the ranks throughout; +there is no dependence on how many spectators were used. + +This argument handles interleaved free scalar maps directly. Normalizing +them is also legitimate: `S D_N(s) S^-1 = D_(SNS^-1)(s)`, and conjugation +preserves the allowed projector class. After sliding scalar maps to one +end, augmentation `[g]->1` maps every paid gate and target to `I_r`, so +the final scalar residue must be the identity. No scalar residue or dirty +output coupling is waived by the model. + +## 5. Attainment is in the full formal algebra + +For role j write E_j for its coordinate projector, and put + +``` +T_j(g)=I_r+([g]+1)E_j. +``` + +This is a diagonal formal matrix, and direct multiplication shows +`T_j(g)T_j(h)=T_j(gh)`. For a reduced expression +`w_j=s_1...s_k`, the product + +``` +D_(E_j)(s_1)...D_(E_j)(s_k)=T_j(w_j) (13) +``` + +therefore holds coefficientwise in `M_r(A)`. To execute that product on +columns, apply the gates chronologically in the order `s_k,...,s_1`. +By (6), its number of orbit-O calls is `i_O(w_j)`. + +Concatenating these circuits for distinct target roles gives (1), since +diagonal operations on different roles commute. It uses no spectator, +no scalar mixing, and no uncharged cleanup. Each spectator present is +untouched. Thus every orbitwise lower bound is attained, establishing the +exact cost claim and a true minimum for any positive real orbit prices. + +The permutation representation is used only as a necessary lower-bound +test. Its possible kernel as an algebra representation is immaterial: +(13), not equality in a root representation, certifies the upper endpoint. +Even a faithful action of W on roots need not make the induced group +algebra representation faithful. + +## 6. Explicit two-price corollary for signed permutations + +Let `W=B_n` be the group of signed permutations, with `n>=1`. A group +element has one-line form `(w_1,...,w_n)`, where the absolute values are +`1,...,n`, and acts by `e_i -> sign(w_i)e_|w_i|`. The simple generators are + +``` +s_0: e_1 -> -e_1, fixing the other coordinates; +s_i: swap e_i and e_(i+1), 1<=i0 and every adjacent swap at b>0. Use the following +positive roots: + +``` +short: e_i (1<=i<=n), +long: e_j-e_i and e_j+e_i (1<=i=2` they are exactly the two root orbits. +Using roots with lengths one and square-root-two instead of normalized +roots merely rescales these two orbits. It preserves their permutations +and signs. The root of `s_0` is `e_1`, and that of `s_i` is +`e_(i+1)-e_i`. + +For a signed list w define + +``` +neg(w) = #{i : w_i<0}, +inv(w) = #{iw_j}, +nsp(w) = #{iw_j`. +The image of `e_j+e_i` is negative exactly when `w_i+w_j<0`. These +equivalences follow by looking at the sign at the larger of +`|w_i|,|w_j|`, which are distinct. Thus the long crossing count is +`inv(w)+nsp(w)`. + +The exact cost for an arbitrary tuple of signed-permutation targets, with +any finite number of dirty spectators, is consequently + +``` +sum_j [ a neg(w_j) + b (inv(w_j)+nsp(w_j)) ]. (14) +``` + +There is also a direct sorting proof of attainment, without the abstract +root facts. If the first entry is negative, negate it by right multiplying +by `s_0`. Otherwise, if there is an adjacent descent, swap its entries by +right multiplying by the corresponding `s_i`. If neither move is possible, +the list is positive and increasing, hence the identity. + +Negating a negative first entry decreases neg by one and leaves +`inv+nsp` unchanged. To check the latter assertion, for x<0 and another +entry y, the combined pair contribution before the sign change is +`1[x>y]+1[x+y<0]`; afterwards it is +`1[-x>y]+1[-x+y<0]`. Writing x=-u with u>0, the two terms are merely +`1[y<-u]` and `1[y=t` +of arbitrary-input roles. This includes noncommuting scalar projectors and +any number of restored dirty spectator roles. + +Consequently the thirteen-call five-SWAP candidate in +[Aaron Wang's PR2317](https://github.com/CrocSwap/integer-mult-bounds/pull/2317) +is excluded without a commuting-projector restriction: its minimum is 15. +Four SWAPs cost 12 even with extra dirty roles. These implications resolve the +same-model open questions 1 and 2 in the frozen +[four-SWAP note](../four-swap-full-occupancy/README.md). +Those historical files remain unchanged. + +The contribution is the explicit model identification, an independent audit, +and a retrievable answer to the live handoff. The all-parameter cut theorem +and method are credited to +[PR1989](https://github.com/CrocSwap/integer-mult-bounds/pull/1989), whose +[proof](../symmetric-adjacent-cut-bound/PROOF.md) is retained byte-identically. +This is not a new supplier, a physical cost improvement, or a kappa claim. + +## Exact model and isomorphism + +Let + +``` +a = [1 1] b = [1 0] s = aba = bab = [0 1] + [0 1] [1 1] [1 0] +``` + +in `G=GL_2(F2)`. Products act on columns, so `gh` means `g` after `h`. +A paid factor is `D_N(g)=I_R+([g]+1)N`, where `g` is exactly `a` or `b`, +`N=uv^T` is binary, and `v^Tu=1`. Each paid factor costs one, including +all preparation and restoration. Scalar `GL_R(F2)` operations are free +and may be interleaved. There are no other free address operations, clean +allocations, resets, copies or erasures. The required complete formal map is + +``` +T = diag([s], ..., [s], 1, ..., 1), with t copies of [s]. +``` + +Every role begins arbitrarily; all spectators are individually restored and +all off-diagonal couplings vanish. Equality is coefficientwise in the full +formal group algebra, not equality of the natural two-dimensional matrices. + +Order the three nonzero column vectors as +`v1=(0,1)^T`, `v2=(1,1)^T`, `v3=(1,0)^T`. Define `phi(g)` by +`g v_i = v_(phi(g)(i))`. This action is a homomorphism with the same product +convention. It is injective because fixing these vectors fixes a basis; +`|GL_2(F2)|=6=|S3|`, so it is a group isomorphism. + +| GL2 element | Image in S3 | One-line image | Inversions | +|---|---|---|---:| +| e | e | 123 | 0 | +| a | (12) | 213 | 1 | +| b | (23) | 132 | 1 | +| ab | (123) | 231 | 2 | +| ba | (132) | 312 | 2 | +| s=aba | (13) | 321 | 3 | + +Extending linearly maps the six formal basis elements bijectively and +preserves every product. It therefore gives an algebra isomorphism +`F2[G] -> F2[S3]`, and an entrywise isomorphism of register matrices. +It preserves the scalar projector `N`, every free scalar map, all role +counts and all dirty endpoint requirements. The paid labels become exactly +the two adjacent transpositions. Thus every hypothesis of PR1989 is met; +its inversion-sum theorem gives minimum `t*3`. + +## Direct proof of the specialized lower bound + +For clarity, this restates the relevant PR1989 argument with its notation +specialized, rather than relying on an unexplained invocation. +Use the six ordered pairs `(i,j)` of distinct labels in `{1,2,3}`. +Each permutation acts simultaneously on the two entries. Partition the +address basis into `H={ij}`, on **every** one of the R roles. +For the resulting operator M write `q(M)=rank_F2 M[K,H]`. + +For arbitrary operators U,V, block multiplication gives + +``` +(UV)[K,H] = U[K,H] V[H,H] + U[K,K] V[K,H], +q(UV) <= q(U) + q(V). +``` + +No commutativity or invertibility is used in this inequality. A free +scalar map is `S tensor I_6`, so its crossing block is zero, even when +it mixes active roles with spectators. For a paid factor, the crossing +block is `N tensor P_g[K,H]`. Either adjacent label reverses exactly +one increasing ordered pair, so this block has rank `rank N=1`. +SWAP maps to reversal, which reverses all three increasing pairs with +independent images. The target crossing block is therefore the direct +sum of t rank-three blocks and R-t zero blocks, of rank `3t`. +Subadditivity proves that any legal word has at least `3t` paid factors. +All intermediate roles and their dirty values were included; no bound +on R except finiteness was used. + +For attainment, on each target role j execute `a,b,a` with coordinate +projector `E_jj`. The formal product has `[aba]=[s]` in that diagonal +entry and identity elsewhere. Concatenating the t words gives T in +exactly `3t` calls. It uses no extra roles or free operations, and leaves +no restoration debt. This also handles t=0, with the empty word. + +The universal conclusion rests on this written argument and the explicit +isomorphism. It is not an extrapolation from finite fixtures or a +formal-kernel proof. + +## What this closes and what it does not + +The mapping answers the exact formal-model questions in the four-SWAP +note and PR2317. PR2317's commuting-family computation remains credited +as predecessor evidence; the additional noncommuting search it proposes is +unnecessary in this same alphabet. This note does not rerun or supersede +its finite enumeration as independent evidence. + +The natural two-dimensional GL2 representation alone is not faithful +on the group algebra: the nonzero formal sum of all six group elements +has zero natural-matrix image over F2. The checker rejects an endpoint +corrupted by this sum. The six-dimensional ordered-pair action for S3 +is regular and faithful; full formal coefficients are nevertheless used +for the primary endpoint checks. + +Charging a direct SWAP label as one call changes the alphabet: that +one factor crosses three directions. Charging a rank-two projector as +one call changes the tariff: it can cross two. Clean workspace with only +a restricted-input endpoint, partial/unrestored spectators, other address +maps or nonlinear operations also change the theorem's premises. +The argument supplies no native rational-address compiler, source access, +hosting, precision/tape, recursive child moment or outer multiplication +assembly. It does not settle the different abelian rational-frame model +or the GL3 CNOT alphabet. No selected cold replay is asserted. + +## Reproduction and finite evidence + +From the repository root: + +``` +python3.12 -B scripts/research_package.py --package research/gl2-swap-cut-corollary +``` + +`verify.py` uses packed full group-algebra coefficients and binary row +elimination, importing no predecessor implementation. It checks all 36 +group products and 4,096 algebra products, all 1,302 paid factors for +R=1..5, and all 3,136 ordered pairs of three-role factors (including +noncommuting cases). It verifies both orientations of the direct word +for t=0..8 and R=t,t+1,t+2: 27 complete formal endpoints, plus all 324 +single-call omissions. It checks wrong labels, dirty spectator coupling, +the natural-representation alias, free scalar mixing, and changed-price +boundary controls. These are complete finite domains, not searches over +all legal words. + +`independent.py` and [REVIEW.md](REVIEW.md) give the separately implemented +regular-action audit, its exact domain and the mathematical model review. +`test_verify.py` exercises actual guard removal and semantic corruptions; +it also checks equivalent group-basis order and read-only Git-free replay. +Each detector must reject for the intended reason. The registered commands +run with `-O` to ensure their checks do not rely on Python assertions. + +## Sources, attribution and freshness + +Pinned base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, priority revision 4; +selected-record SHA256 +`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +[SOURCES.json](SOURCES.json) authenticates both retained proof/model inputs. +PR1989 head: `8b9f3ec8b1e5745c42fec68d75da5fbc82ea91ec`; its proof is identical +to the pinned main copy (SHA256 +`008be68867a8e85f4e18455d206e03f20aebfc28e9f08efba576180e7e1edc50`). +PR2317 head: `139779c86ba8215910117ddb383e4df007b23dcf`; its README SHA256 is +`edba3d71ad274311f3a8c2293d390a7adba38deca344662c0364cbdd192521d3`. +The [canonical claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18944151) +answers its linked handoff in the existing investigation thread. + +The entry overlap helper covered 614 open PRs including drafts and 1,139 +Discussion records, with complete pagination and no warnings, at +2026-10-15 07:57–08:00 UTC. Focused follow-up at 08:01:57 UTC included local +READMEs, TASK records and the PR ledger. Closed PRs are represented through +local notes/ledger only; arbitrary diffs and nested sources are not searched. +No-match output is not a novelty claim: this is explicitly a corollary of +known work. TASK.json records the changed scope from the bit-mechanisms draw. + +Credit: Ross Richardson/PR1989 for the general theorem; Adam Gall/PR1941 and +Ross Richardson/PR1966 for its cut-method predecessors; Cinna Davis for the +finite symmetric-group work credited there. Aaron Wang/PR2317 supplied the +commuting five-SWAP screen and the concrete live handoff. The coordinate-SWAP +model and earlier bounds retain Gareth Davidson/PR1333, +commdata2338/PR1414/1491, Cinna Davis/PR1541, Ross Richardson/PR1722 and the +four-SWAP note, and Aaron Wang/PR1705/1755 lineage. See the pinned source +notes for their own earlier attribution. Prepared by Ross Richardson with +substantial OpenAI Codex assistance, including a separate mathematical +verification specialist. No independent human review is claimed. Apache-2.0. + +## Open next questions + +No further uniform-price formal SWAP search in this exact alphabet is +justified by these handoffs. A useful follow-up must identify a changed +operation, price or endpoint contract, derive its crossing charge, and +fully price any physical implementation before claiming supplier relevance. +The first decisive check is whether the proposed call can cross more than +one direction for its declared charge. Native realization and complete +recursive accounting remain the blockers to transferring such an escape +into the multiplication construction. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md new file mode 100644 index 0000000000..10132fe535 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__README.md @@ -0,0 +1,215 @@ +# Rebuilt BIT supplier, delayed-cover bridge, and larger-gain probes + +Prepared with substantial OpenAI assistance. Apache-2.0. This directory contains +new source files after the workspace loss. The retained predecessors are read +only. Fresh finite fixtures are not represented as recovered historical bytes. + +## Main result and scope + +The strongest closed BIT path in this directory changes the **global controller +and the accounting of independent helper outputs**, while retaining the actual +PR589 local word. Its exact mixed moment root lies in + +\[ +[0.002769830250,\;0.002769830251]. +\] + +The target inventory is `3073 H8 + 444 H22 + 222 H50`; the complete paid +inventory is + +\[ +9261H_1+9394H_2+553H_3+308H_4+714H_5+77H_6+1465H_7. +\] + +All 3,739 productive fields have independent arbitrary input arrays. In +particular, all 3,073 helper inputs are arbitrary, and their physical completed +rank-eight transforms are proved before receiving output credit. The 63 owned +COPY episodes remain charged. No owned zero stream receives independent-output +credit. Every paid rank is at most seven; every target rank is at least eight. + +The finite mixed-to-uniform compiler is documented in the sibling +[architecture proof](../architecture/FINITE-PRECOMPILATION.md). The BIT-specific +[delayed-cover bridge](DELAYED-COVER-BRIDGE.md) keeps one common external weight +until that entire finite program has been compiled. Only the final leaves are +lowered into ordinary weighted calls. This resolves the earlier mismatch +between weights inherited from different parent jobs; it is not a claim that +those mismatched weights can be normalized for free at each internal boundary. + +The parameter certificate uses + +\[ +C_0=0.00276,\quad C_1=0.00275,\quad \delta=0.003, +\] + +with an allowed odd prime `q > 25,600,000 N^5` for the fixed compiled dimension +`N`, also excluding the finite list of rational denominators and rank +witnesses. The ordinary BIT saving before relaxation is exactly + +\[ +(1-\delta)C_1+\delta a_{\rm old} +=0.0027418653797. +\] + +The admitted simple BIT saving is `0.0027`. The complete multiplication +parameter selection and its complex supplier belong to the parent package; +this directory does not independently declare a multiplication kappa. The +enormous finite uniform program is specified constructively, not materialized. +The exact finite audits and the all-size proof are separate evidence layers. + +## Evidence map + +| Question | Generator / proof | Receipt | +|---|---|---| +| What survived from the lost deferred mechanism? | `reconstruct_deferred.py` | `DEFERRED-RECONSTRUCTION.json` | +| Does the actual PR589 word replay on arbitrary helper inputs? | `mixed_productive_bit.py`, frozen independent `xcheck_p.py` | `MIXED-PRODUCTIVE-BIT.json`, `sources/pr589-regenerated/XCHECK.json` | +| Is the new p3 controller an exact operator identity? | `mixed_productive_bit.py`, independent `check_mixed_controller.py` | `MIXED-CONTROLLER-INDEPENDENT.json` | +| Are the endpoint ranks native, with actual owners? | `bit_native_binding.py` | `BIT-P3-NATIVE-BINDING.json` | +| Can internal mixed jobs keep a common weight? | `DELAYED-COVER-BRIDGE.md`, `delayed_cover_bridge.py` | `DELAYED-COVER-BRIDGE.json` | +| Are the prime, atom, row-stock and adapter powers funded? | `bit_allsize_parameters.py` | `BIT-ALLSIZE-PARAMETERS.json` | +| Does the controller lift to exact complex Laurent algebra? | `complex_controller_factor.py` | `COMPLEX-CONTROLLER-FACTOR.json`, `COMPLEX-CONTROLLER-FACTOR-P6.json` | +| Do wider controller searches improve the bill? | `single_field_controller_probe.py`, `stage_projector_probe.py` | `SINGLE-FIELD-CONTROLLER-P3.json`, `STAGE-PROJECTOR-P3.json` | +| Can actual PR589 helpers simply share state? | `pr589_state_sharing_probe.py` | `PR589-STATE-SHARING-PROBE.json` | +| Can the nine expensive centers be replaced locally? | `pr589_h_completion.py`, `pr589_minimum_completion.py` | `PR589-H-COMPLETION.json`, `PR589-MINIMUM-COMPLETION.json` | +| Does the cheaper local completion close globally? | `pr589_h_global_probe.py` | `PR589-H-GLOBAL-PROBE.json` | + +## Reconstruction and actual-source provenance + +The lost 15-output and 16-output fixtures were not recoverable byte for byte. +The fresh reconstruction keeps aggregate functions in original registers until +their consumers and pooled helpers have finished. Minimum path covers in a +reverse-inclusion DAG share nested functions on dirty helpers. The originals +are restored last. The fresh 15-output fixture changes 263 helpers / 34,386 ADDs +to 205 / 17,779; the 16-output fixture changes 527 / 39,362 to 265 / 18,903. +All arbitrary inputs, both orientations, intermediate cuts and deliberately +wrong cleanup orders are checked. These finite examples do not supply an +exponent by themselves. + +The actual local word used in the closed supplier is regenerated from the +retained PR589/PR555 sources into `sources/pr589-regenerated/`. Its compressed +SHA256 is +`e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f`; +its canonical decompressed JSON SHA256 is +`5642fd0e35a1acc11acff8d0c08350c1617e95f310d4d35ad63a651f9eeeba0b`. +It has 111 data ports, 439 helpers and 661 independent persistent inputs. +Both the source-side and copied-center obligations are included in its bill. + +The immutable local `NOTICE.md` credits preparation to **eumemic with +substantial Anthropic Claude assistance**. The tuned source records the PR555 +R439 baseline, PR543 R420 skeleton, DreamingOfClouds's PR545 puncture and PR510 +nine-stage chain, and the cited mechanisms by Dugongue and rohanarun. The tuned +transport pass records Claude Opus 5.5 assistance. The E8 construction and +earlier global controller retain their original repository attribution, +including Jacob Sussman's construction. Current work changes the global +factorization, endpoint accounting, bridge proof and the explicitly named new +probes; it does not claim authorship of those predecessors. + +## What the additional controller rounds established + +The first exact search lets the old global controller omit selected idle +windows and then changes its constant boundary bases. It tests formal +coefficient matrices, not sampled numerical operators. For two through six +pairs, the complete paired-window survivor counts are 3, 8, 20, 48 and 112. +All 192 survivors across one through six pairs lift to exact signed Laurent +identities for the complex construction; no reduction modulo an operator order +is used to justify that lift. The best BIT member is the three-pair case with +keep mask 43. Simply extending the path to more pairs does not improve it. + +A broader three-pair probe separates the two fields of each idle window: +4,096 choices give 64 exact factorizations, including 56 asymmetric ones. A +second probe allows independent stage projectors and tests all 123,904 complete +compatible choices in its stated family. It recovers the old best all-fresh +three-pair bill, rather than a new saving. These are scoped exhaustive results; +they are not lower bounds for all possible global controllers. + +The actual PR589 state-sharing probe examines all 96,141 helper pairs. Only +five pairs have compatible full monotone frame timelines. Two cause a +noninvertible self-gate; the other three change the actual source response. +No pair has disjoint forward lifetimes. Separately, both the nine center +producer signals and their consumer matrix have rank nine. A same-cut +eight-signal compression therefore fails before transport and cleanup costs +are considered. + +## A real cheaper local primitive, and its remaining global debt + +Removing the nine old copied centers and rebuilding dirty compensation gives +an actual clean response + +\[ +J=I+UV +\] + +over `F2`, with `V` the nine center producer rows and `U` their actual scatter +map. Select nine source coordinates `A` for which `V_A` is invertible and set + +\[ +M=V_A^{-1}VU,\qquad U'=U+E_A M,\qquad H=I+U'V. +\] + +Then `VU'=0`, hence `H^2=I`. Only nine output rows are corrected. Each query is +gathered from unchanged completed source arrays, moved through its selected +rank-one target hole, read, and erased under the inherited owned-stream +contract. The complete local bill becomes + +\[ +1332H_1+1342H_2+79H_3+44H_4+102H_5+11H_6+10H_7, +\] + +with rank mass 5,075, saving 54 from the old 5,129. The native word has 11,955 +ADDs and one owned stream reused nine times. Both orientations restore all +439 arbitrary helpers. Its common-frame involution has a three-shear +implementation of only `474 + 504 + 474 = 1452` ADDs. A separate independent +audit in `../transfer-audit/h-branch/` reconstructs the matrices, every frame +rank, all 661 input columns and the owned-erasure model. + +The further minimum-completion probe observes that `rank(J)=108`. It changes +only rows `106,109,110`, replacing them by source coordinates `0,1,2`, and +obtains an invertible `G`. Three changed rows are optimal by the elementary +rank bound. This costs only three new rank-one gathers, giving rank mass +5,069 and 11,625 local ADDs. Forward common-frame wrappers use `G`; reverse +wrappers use `G^-1`. Four literal native replays check the plain and wrapped +orientations on all 661 inputs. Removing any one correction leaves rank 110. +The separate `BIT-MINIMUM-COMPLETION-AUDIT.json` in +`../transfer-audit/h-branch/` independently reconstructs the completion, +both scalar inverse programs, all native transitions and the three actual +line-to-hyperplane contacts; all four native variants pass. + +Neither local improvement is advertised as a new global supplier. The exact +noncommuting three-pair controller produces three interval products, for +stages `(0,1,2)`, `(4,5,6)` and `(0,...,6)`. One bank of each pair can erase its +remaining product by costed scalar/cover operations. The other has a +`Q K Q` endpoint. Direct normalization costs **666 rank-one calls**, not 222. +With the involution the raw rank surplus is 603 and the completed direct bill +has surplus -63. With the minimum invertible completion these are 645 and -21. +Both direct constructions fail even at exponent zero. These receipts prevent +a cheap local repair from being mistaken for a funded recursive improvement. + +The next useful larger-gain question is therefore whether the three actual +head-conjugated interval products can share a correction, or whether a changed +local family makes those products cancel at their physical owner charts. +Unconstrained scalar cancellation or repeated same-chart kernels is not +sufficient. The fixed data geometry, independent inputs, borrowed state and +all endpoint repairs must be included in that next probe's objective. + +## Reproduction + +All new generators use Python's standard library and retained repository code. +From the repository root: + +```sh +python3 -B research/kappa-rebuild/bit/reconstruct_deferred.py +python3 -B research/kappa-rebuild/bit/mixed_productive_bit.py --max-p 5 +python3 -B research/kappa-rebuild/bit/check_mixed_controller.py +python3 -B research/kappa-rebuild/bit/bit_native_binding.py +python3 -B research/kappa-rebuild/bit/delayed_cover_bridge.py +python3 -B research/kappa-rebuild/bit/bit_allsize_parameters.py +python3 -B research/kappa-rebuild/bit/pr589_state_sharing_probe.py +python3 -B research/kappa-rebuild/bit/pr589_h_completion.py +python3 -B research/kappa-rebuild/bit/pr589_h_global_probe.py +python3 -B research/kappa-rebuild/bit/pr589_minimum_completion.py +``` + +The literature-to-probe map is in [LITERATURE.md](LITERATURE.md). The source and +artifact closure is recorded in `SOURCE-MANIFEST.json`. Receipt runtimes are +diagnostics and vary between replays; exact matrices, canonical payload hashes, +profiles, proof conditions and negative-control outcomes are the meaningful +scientific comparisons. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py new file mode 100644 index 0000000000..f4c4082d89 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__kappa-rebuild__bit__bit_native_binding.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""Bind the p3 BIT physical controller to exact local rational port charts. + +The cover is a formal GL_N row until a complete finite uniform program is +compiled. This verifier checks every fixed port map and actual local data +endpoint, plus the native helper ownership and complete recursive invoice. +Apache-2.0. Substantial OpenAI assistance; retained source attribution is +in the immutable PR589/PR555 notices and the companion README. +""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json +import struct +import time + +import mixed_productive_bit as B + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[2] + + +def ident(n): + return [[Q(i==j) for j in range(n)] for i in range(n)] + + +def multiply(a,b): + out=[[Q(0)]*len(b[0]) for _ in a] + for i,row in enumerate(a): + for k,value in enumerate(row): + if value: + for j,second in enumerate(b[k]): + if second: + out[i][j]+=value*second + return out + + +def transpose(a): + return list(map(list,zip(*a))) + + +def subtract(a,b): + return [[x-y for x,y in zip(row,second)] for row,second in zip(a,b)] + + +def serialize(a): + return [[str(x) for x in row] for row in a] + + +def partial_swap(p): + n=len(p) + return [[(int(i==j)-p[i][j] if i=8) for j in range(15)]for i in range(15)] + B.need(multiply(multiply(rho,local8),rho)==active,'Local helper rank8 map under the port chart') + B.need(projectors[word['start'][port]]==p and projectors[word['start'][111+port]]==zero, + 'Actual local data entrance frames') + B.need(projectors[word['final'][port]]==eye and projectors[word['final'][111+port]]==k, + 'Actual local data exit frames') + B.need(multiply(full_swap,partial_swap(p))==partial_swap(k),'Exact physical local factorD_I D_P=D_K') + ports.append(dict(port=port,root=[str(x) for x in q], + central_projector=serialize(p),complement_columns=serialize(a), + chart_15=serialize(rho), + lifted_routes=[dict(stage=s,axes=list(range(8))+list(range(8+7*(s-1),8+7*s))) + for s in range(1,7)])) + copy_checks=0 + for op,x,y,c,f,z in records: + if op==2: + a,b=projectors[c],projectors[f] + low,high=(a,b) if sum(a[i][i]for i in range(8))>(s+1)&1] + rank=(term&1)+7*len(stages) + targets[rank]+=111 + endpoint.append(dict(data_role=role,central_q=bool(term&1),stages=stages,rank=rank, + projector='P_q + selected pairwise perpendicular K_q/B_s blocks')) + B.need(dict(sorted(paid.items()))=={int(r):n for r,n in case['paid'].items()},'Literal complete paid ledger') + B.need(dict(sorted(targets.items()))=={int(r):n for r,n in case['targets'].items()},'Actual endpoint rank credit') + B.need(max(paid)=2` and let `B_j=(p_j,q_j)` be fixed pairs with disjoint coordinate +sets in `{0,...,n-1}`. For each target register `r` and block `j`, select +`g_(r,j)` from `GL_2(F2)`. Its embedding acts on the two coordinates of `B_j` +and fixes all other coordinates. The register target `g_r` is the product +of these embeddings. They commute because the pairs are disjoint. +Other register targets and all unused address coordinates are identity. + +Work in the formal group algebra `M_R(F2[GL_n(F2)])`. Every register input +is arbitrary. The endpoint is `diag([g_1],...,[g_t],1,...,1)`, with every +extra register restored and no off-diagonal residue. Paid units are + +```text +I_R + ([c]+1)N, +``` + +where `c` is any coordinate CNOT in the ambient address space, and `N` is +any binary scalar rank-one idempotent. Each unit costs one. Free scalar +`GL_R(F2)` maps may occur anywhere. There are no other free address maps, +clean allocations or uncharged restoration calls. + +**Theorem.** For every finite `R>=t`, the exact paid-call minimum is +`sum_(r,j) ell(g_(r,j))`, with `ell` given by the table above. +The empty target uses the empty word. The statement covers arbitrary +intermediate scalar projectors and cross-pair address calls; only the +required final target has the block form. + +## Proof + +Use the left regular representation of `G=GL_n(F2)`. For each total order +`<` on the nonzero binary vectors and pair `(p,q)`, let + +```text +A_(p,q) = {x in G : row_p(x) < row_q(x)}. +``` + +On all `R` registers, take the crossing rank from this address cut to its +complement. Block multiplication gives `q(MN)<=q(M)+q(N)`. A free scalar +map has crossing rank zero. A paid call has crossing block +`P_c[A^c,A] tensor N`, so its crossing rank is `out_A(c)`, since `rank(N)=1`. +A diagonal target has the sum of its register crossing ranks. These facts +hold in the formal algebra and do not assume commuting projectors. + +Average each cut over all total orders. Write `u=|G|/6`. +A CNOT writing neither coordinate of a pair changes neither selected row, +so its charge in that cut is zero. If it writes the first row, denote the +old rows by `x,y` and the new row by `z`. The three vectors are distinct: +rows of an invertible matrix are independent, and a sum of two rows is +neither zero nor any original row. The event that the cut is left is +`x0`, this proves +the lower bound for arbitrary dirty workspace and ambient dimension. + +For the upper bound, use the direct two-generator word for each block on +its own register with coordinate projector `E_rr`. Its length is `ell(g)`. +The factors remain diagonal formal monomials, so the group identity is +also a coefficientwise identity in the full formal algebra. Concatenate +the words for all blocks and registers. This attains the lower bound and +restores every unused register and coordinate. No unpaid cleanup is needed. + +## Consequences and boundary + +The heterogeneous target `diag([a],[b],[aba])` costs exactly five for all +`n>=2` and any `R>=3`. The fixed-three-register search in +[the retained heterogeneous-target note](../bit-mixed-transposition-triple/README.md) +already found five at `n=2`. Its extra-register question is covered there by +the inherited dimension-two cut theorem; the ambient-address extension here +also rules out using other address coordinates to reduce that cost. + +The coordinate pairs must be disjoint. On one register, the product of the +three swaps on `(01),(12),(02)` equals the swap on `(12)`. Its separate +nine-call implementation can therefore be replaced by three calls. The +verifier checks this literal counterexample and rejects overlapping pairs +as input to the additive tariff. This is a one-register product; it is not +the three-register mixed-swap target of the component-cut theorem. + +The theorem also retains the rank-one tariff, arbitrary-input endpoint and +absence of free address transformations. It does not cover unequal or +projector-dependent prices, a rank-two call charged as one, a restricted +clean-input endpoint, or arbitrary overlapping block products. + +## Evidence and reproduction + +Use CPython 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/mixed-gl2-block-tariff +python3.12 -I -W error -O -B research/mixed-gl2-block-tariff/verify.py +``` + +Expected markers: `PASS_REGISTERED_RESEARCH_PACKAGE` and +`PASS_MIXED_GL2_BLOCK_TARIFF costs=0,1,1,2,2,3 no_new_kappa`. +Normal replay recomputes [RESULT.json](RESULT.json), writes no files and +needs no Git or network. `--emit-receipt` emits JSON for explicit regeneration. +The receipt binds all five source files by SHA-256. + +The checker compares the six crossing counts with independently computed +`GL2` word lengths. It checks 80 actual coordinate-CNOT/basis cases over +31,992 relative orders, including cross-pair reads and spectator writes. +It exhausts all three-register single-block label triples and all two-register +two-block label quadruples in the declared finite dimension/register grids: +7,128 complete diagonal formal endpoints and 39,852 single-call omissions. +Nine controls cover invalid contracts, empty targets, the five-call example +and the overlapping-block counterexample. + +These particular upper words remain diagonal monomials. Their group labels +are therefore sufficient to verify their full formal endpoints. This does +not assert that natural matrices certify arbitrary group-algebra programs. +The lower bound for all programs is the written regular-representation proof. +No predecessor executable is imported. + +## Open next questions + +What is possible for overlapping target blocks? First specify the actual +one-register product or multi-register endpoint; the example above shows +that a list of local block prices need not add. No general cost law for +that changed boundary is supplied here. Native realization, full supplier +accounting and proof-kernel review remain separate obligations. + +## Credit and source pins + +Prepared for Ali Romman with substantial OpenAI Codex assistance. New work +is Apache-2.0. Ross Richardson supplied the general inversion-sum theorem +and the GL2 bridge; James Reed supplied the averaged spectator cut; Cinna +Davis supplied the fixed-register heterogeneous question. Their retained +notes credit Mihir Srivastava, commdata2338, Gareth Davidson and earlier +register-model/cut contributors. All notices remain unchanged. +The four source documents are provenance only, pinned in +[SOURCES.json](SOURCES.json). Base: +`f259dabc7d70e0db8d6d36bfda888f008bbfecc1`, priority revision 7. +No independent human review, native/compiler admission, selected cold replay, +full multiplier theorem or kappa improvement is claimed. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md new file mode 100644 index 0000000000..431363d53d --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__README.md @@ -0,0 +1,215 @@ +# Three GL2 swaps need five capped-rank invocations + +This contribution was produced by Nick Petalas. Apache-2.0. + +**Scoped proof; no new kappa.** Three independent coordinate-SWAP targets +have exact minimum **five invocations** when each paid coordinate-CNOT call +may have scalar rank one or two and costs one invocation. The complete +five-call word has rank profile `(2,2,1,2,2)` and total scalar rank nine. +It improves the six-invocation implementation that separately batches two +roles and processes the third role. Every additional dirty role returns +unchanged, with no off-diagonal residue. + +More generally, if a rank-one call costs `c1` and a rank-two call costs `c2`, +where `0 <= c1 <= c2 <= 2*c1`, the exact minimum is + +```text +c1 + 4*c2. +``` + +The disjoint batching bill is `3*c1 + 3*c2`. The new saving is therefore +`2*c1-c2`, positive for every strictly subadditive price `c2<2*c1`. +In particular, a power price `c_r=r^theta`, with `0<=theta<=1`, gives +`1+4*2^theta`. Scalar projector rank is not recursive child rank, so this +local result supplies no changed supplier histogram or multiplication bound. + +## Model + +Let `G=GL_2(F2)`, with + +```text +a = [[1,1],[0,1]], b = [[1,0],[1,1]], s=aba=bab=[[0,1],[1,0]]. +``` + +For any finite `R>=3`, work coefficientwise in `M_R(F2[G])`. All registers +start arbitrary. The required complete endpoint is +`T=diag([s],[s],[s],1,...,1)`. +A paid invocation is + +```text +D_N(g)=I_R+([g]+1)N, g in {a,b}, 1<=rank_F2(N)<=2. +``` + +The theorem allows arbitrary binary `N`, including nonidempotent matrices. +Restricting the alphabet to idempotents gives the same optimum, since the +attaining word uses only diagonal idempotents. Every factor is invertible: +its square is identity because `([g]+1)^2=0` in characteristic two. +Free scalar `GL_R(F2)` mixing may occur anywhere. There are no other free +address maps, resets, clean allocations or omitted restoration calls. + +The changed premise from the rank-one GL2 results is the cap-two invocation +price. David Arias's [PR2738](https://github.com/CrocSwap/integer-mult-bounds/pull/2738) +proves the scalar-rank tariff but explicitly leaves sublinear higher-rank +invocation prices outside its conclusion. Ross Richardson's +[PR2415 handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1317#discussioncomment-18944151) +names rank-two unit prices as a changed question. Their results are used as +cited mathematical premises; their scientific replays are not run here. + +## Attaining construction + +For a set `S` of role indices, write `E_S=sum_(j in S) E_jj`. +Execute these calls in the listed chronological order, with zero entries +on every role above two: + +| Call | Label | Role support | Scalar rank | +| --- | --- | --- | ---: | +| 1 | a | 0,1 | 2 | +| 2 | b | 0,2 | 2 | +| 3 | a | 2 | 1 | +| 4 | b | 1,2 | 2 | +| 5 | a | 0,1 | 2 | + +Role zero receives `a,b,a`, role one receives `a,b,a`, and role two receives +`b,a,b`. Both palindromic words equal `s`; the rightmost-first matrix-product +convention therefore gives the same stated endpoint. All factors are +diagonal in role space. Their formal product has no off-diagonal entries, +and every spectator diagonal remains exactly `[e]`. This is an identity in +the full group algebra, with no restriction on register values or addresses. + +The two target roles that share a call change between calls. Requiring a +fixed partition into a two-role block and a singleton would miss this word. +No scalar bridge, auxiliary role or uncharged cleanup is needed to attain it. + +## Optimality and the exact price + +We cite the rank-priced extension in +[PR2738, proof section 7](../coxeter-root-tariff/PROOF.md#7-rank-priced-extension-and-scope-boundaries), +using the product-preserving `GL_2(F2)=S3` bridge retained in +[PR2415](../gl2-swap-cut-corollary/README.md). +Its root-cut lower bound is valid for arbitrary binary scalar couplings, +free scalar mixing and arbitrary finite restored dirty workspace. Since +`s` is the length-three longest element of `S3`, **every legal circuit here +satisfies `sum_i rank(N_i)>=9`**. This nine-unit inequality is inherited, +not a new lower-bound theorem claimed by this package. + +Each invocation has rank at most two, so four invocations supply at most +eight rank units. At least five invocations are necessary. The table attains +five and nine rank units, proving the exact invocation minimum in both the +arbitrary-coupling and idempotent-only alphabets. + +For the price theorem, let `q1,q2` count rank-one and rank-two calls. Then +`q1+2*q2>=9`. If `q2<=4`, the nonnegative price assumptions imply + +```text +c1*q1+c2*q2 >= 9*c1-(2*c1-c2)*q2 >= c1+4*c2. +``` + +If `q2>=5`, the bill is at least `5*c2>=c1+4*c2`. These two cases cover +every finite circuit, including zero prices. The table attains the lower +bound exactly. No rounding of a numerical moment or finite word exclusion +is used in this proof. + +The interval `c1<=c2<=2*c1` is part of the statement. For example, with +`c1=1,c2=3`, nine rank-one calls cost nine, below the displayed formula +thirteen. The verifier rejects prices outside the stated interval. + +## Evidence and reproduction + +Use CPython 3.12 with the standard library, from the repository root: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/rank2-swap-batching +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/rank2-swap-batching/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/rank2-swap-batching/verify.py +``` + +Expected markers are `PASS_RANK2_SWAP_BATCHING minimum=5` and +`PASS_REGISTERED_RESEARCH_PACKAGE`. A different installation can substitute +its own CPython 3.12 path. Default replay writes no files and needs neither +Git nor network. `--emit-receipt` prints a newly computed, source-hash-bound +receipt to standard output. The committed [RESULT.json](RESULT.json) is +generated by that command, never written by hand. + +The primary checker multiplies all formal coefficients using binary GL2 +matrices. A separate checker builds `S3` from permutations of three points +and applies the gates to every column of its faithful left regular module. +Both check the new complete endpoint. The finite fixtures cover all 168 +invertible scalar gauges at three roles, and elementary plus dense gauges +at four through six roles. Gauged calls include actual dirty-role coupling, +with separately applied entrance and exit maps. Each call omission and label +flip must change the formal endpoint; unmatched dirty coupling and an illegal +rank-three invocation must also fail. Exact rational price cases check the +new two-case integer-profile argument. Exact enumerated totals are in the +receipt, not extrapolated to larger spaces. + +The universal conclusion is the written construction and price proof using +the cited rank bound. The finite fixtures are corroboration. This is not an +exhaustive search over all legal words and does not replay predecessor +censuses or certify the inherited proof in a formal kernel. + +## Open next questions + +1. What native interface can implement this exact cap-two scalar-coupling + invocation at a strictly subadditive complete price? First specify its + data layout and arbitrary-input entry/exit contract, then charge its + compilation, scalar work, routing, ownership, precision and cleanup. + Those physical costs are unknown here; another construction round is + not justified by the formal five-call count alone. +2. What is the exact three-target tariff when scalar ranks above two are + allowed at a declared price? First specify one price schedule and compare + complete attaining words with the inherited nine-unit rank floor. + The cap-two price argument does not classify that changed alphabet. + +## Credit, overlap and limits + +David Arias's PR2738 supplies the rank-priced Coxeter theorem. Ross Richardson's +PR1989 supplies the symmetric-group cut theorem, and PR2415 supplies the GL2 +bridge and changed-price handoff. Adam Gall's PR1941 and Ross Richardson's +PR1966 retain the cut-method credit. Arham Tahir's +[PR1919](../ut3-rank-bounded-block-calls/README.md) supplies a related cyclic +rank-capped batching precedent for the distinct UT3 central target. +Ali Romman's [PR5031](../mixed-gl2-block-tariff/README.md) prices mixed GL2 +blocks at rank one and does not admit unit-priced rank-two invocations. +The underlying register-model lineage includes eumemic, Ali Romman, +Gareth Davidson and David Govea. All retained source notices remain unchanged. + +The new contribution is the displayed five-call GL2 support schedule and +its sharp cap-two invocation/concave-price consequence. The rank bound, +GL2 bridge, general cut method and the idea of higher-rank batching are +credited predecessors. No literature-priority claim is made. + +The [CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19141448) +records the concrete scope. Base is canonical main +`4c0a359d88f22f05189d51f48387750b801a45d4`, priority revision seven. +A submission checkpoint fetched main at +`9269eea18a6a10dddeac6a4f696904c55ef1d365`; guidance, selected record and +the four relevant predecessor paths were unchanged. The scientific base +and immutable pins are retained. +The overlap snapshot covered 330 open PRs and 4193 Discussion records with +complete remote pagination. Sparse local coverage was 128 of 6760 note +paths, supplemented by distinctive main-tree and merged-PR searches and +direct predecessor reads. Arbitrary diffs and unpublished work are outside +that coverage. Open PR2444 concerns rank-one five-SWAP search tooling; +its changed-price boundary is a lead, not a claim to this cap-two result. + +Native/compiler admission, physical payload/tape/precision/stock costs, +a complete recursive invoice, selected cold replay, Lean, independent human +review and a complete multiplication theorem are unrun or outside scope. +The selected frontier is unchanged. See [SOURCES.json](SOURCES.json) for +immutable provenance pins and [TASK.json](TASK.json) for the scope change. + +### Verifier bounds and diagnostics + +The verifier has no recursive calls, solver, subprocess or background service. +Its matrix dimensions are at most six, group tables have six elements, +scalar-gauge enumeration has at most 512 candidates, and price-count checks +use a 13-by-13 grid. Each routine is shorter than sixty physical lines. +Explicit exceptions retain all invariants under optimized Python. + +Python dynamically allocates tuples, lists and arbitrary-size integers. This +is a managed-runtime deviation from fixed allocation, confined to the bounded +finite verifier, not a real-time or native-memory guarantee. The dimension +and enumeration caps bound live collections; no unbounded input is accepted. +The compensating checks are the normal and optimized warning-strict registered +commands. Revisit allocation and capacity if these corroboration bounds grow. +No shared repository diagnostic configuration is changed. diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json new file mode 100644 index 0000000000..8a315b46f2 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "4c0a359d88f22f05189d51f48387750b801a45d4", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/coxeter-root-tariff/PROOF.md", + "usage": "provenance", + "git_blob": "c67d51701a3dccf1028f8213502979372dbd73b3", + "sha256": "2e20ac459ed1524fca510b58d2792004e44024fd96b9f775501c47786c8325f8" + }, + { + "path": "research/gl2-swap-cut-corollary/README.md", + "usage": "provenance", + "git_blob": "c34c1460063ee4690c934d3c3fb3d81896f8931c", + "sha256": "3650918994be00323ccb61b75cdd81ecae47104a6e0765e319196618737949d9" + }, + { + "path": "research/mixed-gl2-block-tariff/README.md", + "usage": "provenance", + "git_blob": "0e70d9afe37947ca267a93892b791e5ea27c19e8", + "sha256": "c261a4d289c61e31dc495303f22d994b506c87b2f03de308ed94435bd7a1a4e0" + }, + { + "path": "research/ut3-rank-bounded-block-calls/README.md", + "usage": "provenance", + "git_blob": "dc0d1bac91fcebecc9fed4e8c3d26a11acca3ef5", + "sha256": "822574c7040b5571d729960951425a1ad9742ae8541a2af2882733f952975b5d" + } + ] +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json new file mode 100644 index 0000000000..e3bf3f5f04 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__rank2-swap-batching__TASK.json @@ -0,0 +1,99 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 7, + "base_commit": "4c0a359d88f22f05189d51f48387750b801a45d4", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Prove the exact five-invocation minimum and c1+4*c2 tariff for three GL2 SWAP targets with scalar-rank cap two, arbitrary finite restored dirty workspace and free scalar mixing.", + "scope_change_reason": "Take PR2415 changed-price handoff and PR2738 higher-rank invocation boundary. The paid scalar-rank cap and subadditive price change the old rank-one premise; native implementation is not supplied.", + "bottleneck_link": "A complete formal schedule saves one invocation versus disjoint batching when scalar rank two is subadditive. Scalar projector rank is not recursive child rank, and physical supplier costs remain unknown.", + "budget_minutes": 60, + "stop_rule": "Stop at the first verified five-call construction, exact inherited-bound consequence and bounded independent endpoint checks. Do not search larger caps or native suppliers.", + "outcome": "completed", + "evidence": "Written complete endpoint and price proof; independent formal GL2 and regular S3 endpoint checkers; omitted-call, label, dirty-leak, rank-cap and price controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Can a native interface implement this cap-two invocation with a strictly subadditive complete price?", + "why_it_matters": "The formal invocation saving changes no recursive supplier bill without a physical contract.", + "first_step": "Specify one layout and arbitrary-input entry/exit contract, then charge its compilation, scalar work, routing, ownership, precision and cleanup.", + "blocked_by": "No native implementation or complete cost is supplied." + }, + { + "question": "What is the exact three-target tariff if scalar ranks above two are allowed?", + "why_it_matters": "The cap-two proof does not classify other price alphabets.", + "first_step": "Fix one full price schedule and compare complete words with the cited nine-unit rank floor.", + "blocked_by": "A changed rank alphabet and matching lower bound are required." + } + ], + "canonical_discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19141448", + "selection": { + "mode": "handoff-first", + "source_prs": [ + 2415, + 2738 + ], + "changed_hypothesis": "scalar-rank-two invocation prices", + "predecessor_replay": "not run; cited premises only" + }, + "environment": { + "python": "CPython 3.12.15", + "interpreter": "/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12", + "dependencies": "standard library", + "platform": "macOS-27.0.1-arm64-arm-64bit" + }, + "overlap": { + "checked_at": "2026-10-23T08:14:00Z", + "open_prs": 330, + "discussion_records": 4193, + "local_note_paths": 128, + "head_note_paths": 6760, + "limits": "Sparse omitted notes, arbitrary diffs and unpublished work; supplemented with distinctive main-tree/merged-PR searches and direct predecessor reads." + }, + "upstream_refresh": { + "commit": "9269eea18a6a10dddeac6a4f696904c55ef1d365", + "guidance_and_selected_record": "unchanged from scientific base", + "compatibility": "Relevant pinned predecessor paths unchanged; scientific base retained without rebasing." + } +} diff --git a/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md new file mode 100644 index 0000000000..dc0d1bac91 --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/evidence/physical-interface/source/research__ut3-rank-bounded-block-calls__README.md @@ -0,0 +1,234 @@ +# Sharp invocation count for rank-bounded UT3 block calls + +**Scoped alphabet extension; no new kappa.** For `w` central UT3 targets, +arbitrary restored dirty workspace, and paid a/b calls of scalar rank at most +`k`, the exact minimum number of calls is + +`2t`, where `t = max(2, ceil(2w/k))`. + +Search aliases: D8 (the dihedral group of order eight), UT3(F2), UT_3(F2), +Heisenberg group mod 2, central commutator, rank cap, higher-rank block calls. + +Every word has at least `2w` charged rank units of **each** letter. One +construction simultaneously attains the minimum invocation count and both +rank bounds. Under nonnegative per-letter complete prices +`alpha_g + beta_g rank(N)`, the sharp abstract tariff is therefore + +`t(alpha_a + alpha_b) + 2w(beta_a + beta_b)`. + +The smallest batching improvement is `w=3,k=2`: six rank-two calls, rather +than twelve rank-one calls or eight calls from disjoint blocks of sizes two +and one. All three constructions charge twelve total rank units. At uniform +price `alpha + beta rank`, their bills are respectively `6alpha+12beta`, +`12alpha+12beta`, and `8alpha+12beta`. This improves an invocation overhead +only when the hypothetical block call really has that complete price. +It is not a recursive-moment or physical supplier improvement. + +## Exact model and predecessor boundary + +Let `G=UT_3(F2)`, with triples `(u,v,z)` and group product + +`(u,v,z)(U,V,Z)=(u+U,v+V,z+Z+uV)`. + +Set `a=(1,0,0)`, `b=(0,1,0)`, `c=abab=(0,0,1)`. Work in the **full formal** +group algebra `R=F2[G]` on any finite `r>=w>=1` scalar registers. For an integer +`k>=1`, the expanded paid alphabet is + +`D_N(g)=I+([g]+1)N`, `g in {a,b}`, `1<=rank_F2(N)<=k`. + +`N` is any binary `r-by-r` matrix; it need not be idempotent. This is one +optimistically priced **block primitive**, not a claim that its implementation +costs one rank-one call. Each factor is reversible with inverse itself: +`([g]+1)^2=0` gives `D_N(g)^2=I` even when `N^2` is neither zero nor `N`. +The endpoint is `diag([c] repeated w, 1 repeated r-w)` on arbitrary inputs. +All restored roles, every invocation and its full scalar rank are counted. +There are no free address maps, central-letter calls, clean ancillas, COPY, +ERASE, or uncharged inverse calls. + +Scalar `GL_r(F2)` mixing is free **only in this abstract screening model**. +Conjugate it through paid factors, retaining scalar rank. Augmentation sends +every paid factor and the target to identity, so the residual free scalar +map must be identity. The expanded alphabet contains all these conjugates. +Consequently the normalized paid-word model covers arbitrary free scalar +mixing with the declared complete dirty boundary. + +steph4n-gh's [PR1573](https://github.com/CrocSwap/integer-mult-bounds/pull/1573) +already proves `4w` for rank-one idempotents with arbitrary workspace. +Arham Tahir's [PR1589](https://github.com/CrocSwap/integer-mult-bounds/pull/1589) +extends that bound to all rank-one matrices; Hanson Sun's +[PR1607](https://github.com/CrocSwap/integer-mult-bounds/pull/1607) treats mixed +rank-one targets. Their zero-sum/coefficient-span proof supplies the method +below. The new part is the sharp rank-cap invocation count, cyclic block +construction and simultaneously optimal rank/invocation tariff. At `k=1` it specializes +to their central-only result. woklerx's +[PR1841](https://github.com/CrocSwap/integer-mult-bounds/pull/1841) adds a paid +central label while keeping scalar rank one, a different changed premise. +Josie Elliston's [PR1792](https://github.com/CrocSwap/integer-mult-bounds/pull/1792) +already observes that a rank-s coupling splits into s same-label rank-one +calls, preserving the rank-linear bill. That fact and the `4w` rank-volume +floor are credited consequences of predecessor work, not new savings here. +Exact heads are recorded in [SOURCES.json](SOURCES.json). No predecessor code +or source archive is imported. + +## Uniform lower bound + +The predecessor floor can also be obtained by splitting each rank-d `N` +as a sum of d rank-one matrices. Since `([g]+1)^2=0`, their same-label factors +multiply to `D_N(g)`. The rank-one lower bound therefore applies to total +rank mass. The self-contained coefficient argument below records that +inherited implication without requiring a pending executable or theorem. + +Use the predecessor quotient + +`A=F2/(X^2,Y^2, all monomials of length >=3)`. + +Its basis is `1,X,Y,XY,YX`; the map + +`(u,v,z) -> 1+uX+vY+zXY+(z+uv)YX` + +preserves the displayed group law. Thus `a->1+X`, `b->1+Y`, +`c->1+XY+YX`. This is only a necessary-condition quotient; acceptance of +the upper words uses the full formal algebra. Put `Q=diag(I_w,0)`, rank `w`. +The target's degree-one coefficients vanish and its two mixed coefficients +both equal `Q`. + +For the a factors write `N_i=U_i V_i`, where `d_i=rank(N_i)`, +`U_i` has `d_i` columns and `V_i` has `d_i` rows. Concatenate them into +`U=(U_1 ... U_p)` and `V=(V_1^T ... V_p^T)^T`, with inner dimension +`s_a=sum_i d_i`. The `X` coefficient gives `UV=sum_i N_i=0`. + +The `XY` coefficient is a sum of `N_i` times later b factors, so its column +space is contained in `col(U)`. The `YX` coefficient is a sum of earlier b +factors times `N_i`, so its row space is contained in `row(V)`. Since both +are `Q`, `rank(U)>=w` and `rank(V)>=w`. But `UV=0` implies +`image(V) subset kernel(U)` inside `F2^{s_a}`, hence + +`s_a >= rank(U)+rank(V) >= 2w`. + +Exchanging a,b proves `s_b>=2w`. No scalar commutation, idempotence, +determinant parity, register bound, or finite-search assumption is used. +Since every rank is at most `k`, `p,q >= ceil(2w/k)`. Each letter must occur +at least twice: zero occurrences cannot give the mixed coefficient `Q`, +and one occurrence would require its nonzero `N` to equal zero in the +degree-one coefficient. Therefore `p,q>=t`. + +For nonnegative tariff coefficients the complete bill is at least +`t(alpha_a+alpha_b)+2w(beta_a+beta_b)`. Negative prices are outside the model. + +## Uniform attaining construction + +Let `t=max(2,ceil(2w/k))`. Assign target coordinate `i=0,...,w-1` to two +block indices + +`2i mod t` and `(2i+1) mod t`. + +These indices differ because `t>=2`. For each block `j`, let `P_j` be the +diagonal projector onto its assigned target coordinates, zero on all dirt. +The `2w` consecutive residues distribute across `t` indices with loads +`floor(2w/t)` or `ceil(2w/t)`. Since `t<=2w` and `t>=2w/k`, every block is +nonempty and has rank at most `k`. Execute, in increasing block order, + +`D_{P_j}(a) D_{P_j}(b)`. + +Each target belongs to exactly two blocks. Its complete formal word is +`abab=c`; all other factors act identically there. Every extra dirty +coordinate sees only identity. Thus the word has the required full endpoint, +`t` calls of each letter, and rank mass `sum_j rank(P_j)=2w` per letter. +There is no preparation or extra workspace requirement. Adding any number +of identity roles preserves the construction. This proves the sharp count +and tariff for every finite `r>=w` and integer `k>=1`, including `k>w`. + +For `w=3,k=2`, the supports are `{0,1}`, `{0,2}`, `{1,2}`. Apply a then b +on each support. Overlapping these blocks removes two invocations relative +to disjoint batching; it does not remove any charged rank. + +## Exact evidence and reproduction + +The written proofs establish the arbitrary-size statement. +[verify.py](verify.py) supplies bounded exact corroboration: + +- All 64 group products check the quotient homomorphism; all 32,768 quotient + triples check associativity. +- All 530 binary scalar matrices at `r=1,2,3`, including zero as an algebra + control, check two rank implementations, rank factorizations, all 1,060 + same-label decompositions and full formal + and faithful regular involutions for both letters. The `r=3` rank counts + are `1,49,294,168` at ranks `0,1,2,3`. +- All 27,931 two-register words through three calls, over both letters and + all fifteen nonzero scalar matrices, check ordered coefficients against + both a separate dynamic recurrence and full-formal quotient projection. + Actual carrier spans and zero-sum rank bounds are checked. All 900 ordered + two-factor products additionally compare formal and faithful regular maps. +- 102 attaining fixtures cover `w=1..12`, `k=1..w+2`, each with two dirty + roles. Both engines check complete forward and inverse operators, including + 16,160 regular basis columns and exact counts/rank invoices. +- A scalar-conjugated pilot mixes dirty input into a target and restores the + complete boundary with the two permitted free scalar maps. Omitting those + maps fails in both engines. Sixty-two single-call omissions and ten model, + rank-invoice, label and dirty-boundary controls reject. A nonzero formal + off-diagonal perturbation in the quotient kernel is rejected by the faithful + engine even though the lower-bound quotient cannot see it. 306 exact rational + tariff fixtures include zero overhead, pure overhead and unequal prices. + +The formal engine uses triple convolution. The regular engine uses literal +binary 3-by-3 address matrices and their faithful eight-element action, with +different enumeration and multiplication. They share scalar bit-matrix +arithmetic and were written in one session; this is not independent human +review. [CERTIFICATE.json](CERTIFICATE.json) stores the deterministic receipt +and construction-profile digest. `--emit` prints a fresh receipt without +changing the package. Checks remain active under `-O`. + +From the repository root, standard-library Python 3.12: + +```sh +python -I -O -B research/ut3-rank-bounded-block-calls/verify.py +python -I -B research/ut3-rank-bounded-block-calls/test_verify.py +python scripts/research_package.py --package research/ut3-rank-bounded-block-calls --check-only +python scripts/research_package.py --package research/ut3-rank-bounded-block-calls +``` + +The registered command covers normal/optimized checking, read-only source +export, regenerated receipt equality, and certificate-corruption rejection. +The source exports need only verifier and certificate; generic provenance +checks additionally require Git history. Task selection, scope, exact main, +overlap and validation environment are in [TASK.json](TASK.json). + +## Limits + +The rank units above are **scalar coupling ranks in this formal alphabet**, +not an admitted supplier's recursive child ranks. Rank-linear pricing gives +the same `4w` rank bill at every cap. A nonlinear recursive tariff requires +its own analysis; this result does not optimize it. The expanded block +primitive, free scalar maps and fixed invocation overhead have no supplied +physical realization, rational-frame translation or H1-H5 admission. +Selected-source orientation passed; the selected cold replay, compiler, +common-label realization, hosting/ownership, precision/tape, outer analytic +transfer, Lean proof and independent human review were not performed. +No new multiplication exponent or maintainer acceptance is claimed. + +## Open next questions + +Can a physical bit interface realize one rank-k block call below the sum of +its rank-one complete prices? That determines whether the invocation savings +matter. Start with this `w=3,k=2` six-call boundary and charge frame changes, +scalar preparation, hosting, precision, restoration and dispatch against all +twelve rank-one calls. The blocker is a legal physical realization; neither +formal rank nor fewer invocations provides it. Structured scope and this +handoff are in [TASK.json](TASK.json). + +## Credit and license + +Credit steph4n-gh/PR1573 for the all-register rank-one central bound and +zero-sum rank argument; Arham Tahir/PR1589 for the nilpotent rank-one extension +and two-coefficient quotient; Hanson Sun (@bbMisk)/PR1607 for mixed-target +coefficient tariffs; woklerx/PR1841 for the distinct priced-central alphabet. +Credit Josie Elliston/PR1792 for the family index, D8/UT3 alias warning and +explicit rank-s decomposition/rank-linear pricing observation. +Retain juper997/PR1478 and woklerx/PR1443's finite UT3/D8 predecessors, +Gareth Davidson (@bitplane)/PR1333's scalar-normalization context and the +eumemic/PR288, Ali Romman/PR468 and David Govea/PR720 register-model lineage. +No literature-priority claim is made for rank-nullity or cyclic load balancing. + +Prepared by **Arham Tahir with substantial OpenAI Codex assistance** in proof, +implementation, verification and writing. No subagents or independent human +proof review. New work is Apache-2.0; frozen inputs and notices are unchanged. diff --git a/research/three-swap-cap2-physical-ceiling/verify.py b/research/three-swap-cap2-physical-ceiling/verify.py new file mode 100644 index 0000000000..bcfe6b55cb --- /dev/null +++ b/research/three-swap-cap2-physical-ceiling/verify.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +"""Portable transport/replay adapter; scientific checkers are retained unchanged. + +Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. +""" +from hashlib import sha256 +from pathlib import Path +import json +import os +import shutil +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +EVIDENCE_SHA256 = 'b670cc75811f6d42190029ef9cd2f65e67a588d5d147e2c9e3f47693aa7c5c1b' +TOP = Path('outputs/new-approach-ceilings-20261023') +REVIEW = Path('outputs/new-approach-verification-20261023') + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def authenticate(): + raw = (HERE/'EVIDENCE.json').read_bytes() + need(sha256(raw).hexdigest() == EVIDENCE_SHA256, 'retained inventory changed') + pins = json.loads(raw)['files'] + actual_paths = {p.relative_to(HERE).as_posix() for p in (HERE/'evidence').rglob('*') if p.is_file()} + need(actual_paths == set(pins), 'retained evidence inventory changed') + for path, digest in pins.items(): + need(sha256((HERE/path).read_bytes()).hexdigest() == digest, 'retained bytes changed: '+path) + top = HERE/'evidence'/TOP + for path, digest in json.loads((top/'FILES.json').read_bytes())['files'].items(): + need(sha256((top/path).read_bytes()).hexdigest() == digest, 'author packet changed: '+path) + physical = HERE/'evidence/physical-interface' + for path, digest in json.loads((physical/'FILES.json').read_bytes()).items(): + need(sha256((physical/path).read_bytes()).hexdigest() == digest, 'physical source packet changed: '+path) + for row in json.loads((physical/'SOURCES.json').read_bytes())['files']: + need(sha256((physical/row['local']).read_bytes()).hexdigest() == row['sha256'], 'physical source hash') + review = HERE/'evidence'/REVIEW + freeze = json.loads((review/'FREEZE.json').read_bytes()) + # FREEZE also describes unrelated p2 work; authenticate only retained direct files. + for row in freeze['files']: + if (review/row['path']).is_file(): + data = (review/row['path']).read_bytes() + need(len(data) == row['bytes'] and sha256(data).hexdigest() == row['sha256'], 'independent freeze changed') + return pins + + +def launch(path, cwd, extra=(), success=True): + args = [sys.executable, '-I'] + if sys.flags.optimize: + args.append('-O') + args.extend(['-W', 'error', '-B', str(path), *extra]) + env = {k:v for k,v in os.environ.items() if not k.startswith('GIT_') and not k.startswith('PYTHON')} + done = subprocess.run(args, cwd=cwd, env=env, capture_output=True, timeout=90, check=False) + if success: + need(done.returncode == 0, 'scientific replay failed: '+done.stderr.decode('utf-8', errors='replace')) + need(done.stderr == b'', 'warning-strict replay emitted stderr') + else: + need(done.returncode != 0, 'corrupt frozen input was accepted') + need(b'Changed source' in done.stderr or b'source manifest hash' in done.stderr, 'unexpected rejection reason') + return done.stdout + + +def main(): + before = authenticate() + suffix = '-OPTIMIZED' if sys.flags.optimize else '' + with tempfile.TemporaryDirectory(prefix='cap2-physical-ceiling-') as temp: + scratch = Path(temp) + # Copy bytes only: a read-only export must yield writable private outputs. + for relative in (TOP, REVIEW): + source_tree = HERE/'evidence'/relative + for original in source_tree.rglob('*'): + if original.is_file(): + destination = scratch/relative/original.relative_to(source_tree) + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(original, destination) + expected = (scratch/TOP/('CHECK-RESULT'+suffix+'.json')).read_bytes() + stdout = launch(scratch/TOP/'check_screen.py', scratch) + need(stdout == expected, 'author replay differs from frozen receipt') + expected_review = (scratch/REVIEW/('ECONOMIC-REVIEWS-DIRECT-RESULT'+suffix+'.json')).read_bytes() + stdout_review = launch(scratch/REVIEW/'check_economic_reviews.py', scratch, ('--direct-only',)) + message = json.loads(stdout_review) + need(message['status'] == 'PASS_SCOPED_INDEPENDENT_ECONOMIC_REVIEW_DIRECT', 'independent replay status') + need(Path(message['result']).resolve() == (scratch/REVIEW/('ECONOMIC-REVIEWS-DIRECT-RESULT'+suffix+'.json')).resolve(), 'independent result destination') + need((scratch/REVIEW/('ECONOMIC-REVIEWS-DIRECT-RESULT'+suffix+'.json')).read_bytes() == expected_review, 'independent replay differs from frozen receipt') + # A real scientific input mutation must fail each unchanged source checker. + source = scratch/TOP/'frozen/notes__three-stage-cover-bit.tex' + source.write_bytes(source.read_bytes()+b'\nCORRUPTION CONTROL\n') + launch(scratch/TOP/'check_screen.py', scratch, success=False) + launch(scratch/REVIEW/'check_economic_reviews.py', scratch, ('--direct-only',), success=False) + need(authenticate() == before, 'package changed during replay') + print(json.dumps({'status':'PASS_CAP2_PHYSICAL_CEILING_PACKAGE', + 'retained_files':len(before), + 'author_receipt':'BYTE_IDENTICAL', + 'independent_direct_receipt':'BYTE_IDENTICAL', + 'source_corruption_rejections':2, + 'package_bytes_unchanged':True, + 'native_or_formal_word_or_compiler_execution':False, + 'physical_supplier_verified':False, + 'new_kappa':None}, sort_keys=True)) + + +if __name__ == '__main__': + main()