diff --git a/research/bit-five-rank4-terminals/CONTENT-SHA256.json b/research/bit-five-rank4-terminals/CONTENT-SHA256.json new file mode 100644 index 0000000000..246b21a106 --- /dev/null +++ b/research/bit-five-rank4-terminals/CONTENT-SHA256.json @@ -0,0 +1,60 @@ +{ + "INDEPENDENT-FIVE-TERMINALS.json": "033d935df3b07b8247bf82d7e88ebac739023e7f4598588c305ff6cd6ad55875", + "LOCAL-PROVENANCE.json": "8b7af087d2518f11684c1e3f4022505010655db4b833a566dcd6beb958d8813d", + "PROOF.md": "7f76d855f5cd8988249f43bfc7222387aac515b5db51a31f67e7603b2f0d3b12", + "README.md": "e78494440efbebf9a6799913e4b765d5ec45034d9cf05788754795b77dbbe9fa", + "SOURCES.json": "18a0f28d1060d8d3b615746eea85ff709c89cb98c37d09b2d70cd11065302ac0", + "TASK.json": "4070557d709f41227b48b184e84b63e6ccf189f2cfa98626250c640a51e0c1df", + "VERIFY.json": "f838a300a4d5c65339e9a7553e2255face48a1d552f163fbbc5c4b8cf37ab676", + "WORD-ADAPTATION.patch": "a1bf54196fe2f6d51c314775b88f59eea4209660a7a59ca61fa4d8d35a2e49f8", + "WORD.json.gz": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c", + "admission/ADAPTATION-CHECK.json": "18f09c62864738cb39e8fbe52b3e811406afdbba85634f7be3f9aeb2cebc7c32", + "admission/ADAPTATION.patch": "88106c60dbc9563478351d213d3dfdd2a88d0d0d8734e4b16c41e75b72accb43", + "admission/ADMISSION-CHECK.json": "cb7e3c83d066a82fa2d458b2d8ac2cc04ae90bde2ad4f70e07fdc252888a87d0", + "admission/BUNDLE-MANIFEST.json": "82fef5ae03e7dbd738869f762437297adf57a717c360a7084ee2b50a58d0ba45", + "admission/INPUT-MANIFEST.json": "70b0515c54a63dd545d256ee3da17f2f8ce00e89d08580f7cdbcdc4bb72dac03", + "admission/README.md": "d9aacfb3c2bb7a3e3fbad8453409fba9e925bc833b399fa6e0bc94e13e2570b6", + "admission/VALIDATION.json": "2c4cb7e0e427dbc9ad4179a3423e3eaaaa8726701f8e50e26622a956b59d9cb4", + "admission/inputs/FIVE-TERMINALS-WORD.json.gz": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c", + "admission/inputs/TERMINAL-CHARTS.json": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17", + "admission/inputs/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "admission/inputs/r438-t154.json.gz": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "admission/provenance/ADMISSION-CHECK.original.json": "914c4deecd9fa972f396e942c6d6bfbf13e6ef58f6a54ad8e8d4a125b0652519", + "admission/provenance/FROZEN-MANIFEST.original.json": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7", + "admission/provenance/OWNERSHIP.original.json": "ed5b67369aa95c80a5a4a958dc030cc216954d6a8b23d01252d2c84647758fbc", + "admission/provenance/PR540-SOURCE-PINS.original.json": "2963bc4edd609c542bad37f6021f251dbaa254495948d715dc3c704c8058b31d", + "admission/provenance/TRANSFER-AUTHENTICATION.json": "e6b71af938ed1457e163390a8f304dd18493d7b6937d431561e22895c2fd6597", + "admission/provenance/TRANSFER-MANIFEST.original.json": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb", + "admission/provenance/verify_admission.original.py.txt": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194", + "admission/source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "admission/source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "admission/source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe", + "admission/source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "admission/source-context/research/pr589-five-helper-hosting/PROOF.md": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "admission/verify.py": "762357be4644da879251eca070a81dfd73ec3ef4991191cdd630896e7e9b44a3", + "moment/PORTABLE-VALIDATION.json": "b17d3fec1555249a387bd277f6325285dac8e07d0aa830267fa0dd1c17e37388", + "moment/PROOF.md": "e78080da8c475278ed0b9cba6043a2e2182f4d6c6bdc58b6e928fcba94c48972", + "moment/README.md": "85dcfafcd8931296297494e1abd5441ea5ac8f3b750cca169b78ab3fd50239cd", + "moment/RESULT.json": "face2ea5e286831ac29413f4e2d085998685d4faf332b5c224159f6b9fcdf42d", + "moment/WINDOW-PROOF.md": "6c0b0b8b2c539d1e04219ed3e057a8a6c52d96fb4324f1065d2f3e4c2d1d165c", + "moment/WINDOW-RESULT.json": "a959fcac8aa0fed2ab63baf02492ce9c697d039be32fb375abfe7dc77b18e786", + "moment/check_moment.py": "f462d1299f23cb9d9df800a2e15af5c1f15d883b0aca90e0885a932b903071d4", + "moment/check_windows.py": "32dc8b5dcd219de70d4404ea49c31d653e7b75627d6c78e4eb84e5a4d8d4a931", + "moment/independent/WINDOW-INDEPENDENT-RESULT.json": "39ec4d42d20e3008b7564dcfac675aeff39f5dd6bcd9ae14a288bd1b6a3bc7bd", + "moment/independent/WINDOW-INDEPENDENT-VALIDATION.json": "20fce6cb4c1ee3e5f6f37b9857351aac16e3b99f71f1877cf402528688478552", + "moment/independent/WINDOW-REVIEW-CERTIFICATE.json": "0ecf81685eb703b5f9b665e9b470da946dc1b356f1595c19b0ae52814a44b782", + "moment/independent/WINDOW-REVIEW.md": "3089127abc9f7e28d2cb3e0aa2d13438a9d29986a80bf5bd5c23238ecffd8e94", + "moment/independent/check_window_independent.py": "f1284452ea9dc83424a11a86639a1ec7b9e83d765e8eea737b0c1f284343601a", + "moment/independent/source-context/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "moment/independent/validate_window_independent.py": "e7ff5629085d608ca5b464eafedfaf93ce8800a06f3c3ebe81efb31b7857fc9e", + "moment/inputs/FIVE-TERMINALS.json": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58", + "moment/inputs/R438-CERTIFICATE.json": "6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c", + "moment/inputs/SOURCES.json": "2548662747a5ea2e00ebdf6cced3fd76b38c3a841526f3baf0acd0b7a0eb4ada", + "moment/inputs/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "moment/verify.py": "bb5487c78c835d2637ce84e289e969771a59e4cfeb90cc829d1b79c349ae76ac", + "predecessor/CANDIDATE.json": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58", + "predecessor/OPERATOR-BOUNDARY.md": "b268114ee08a3cb0c6fb18928361528cc7385bd5f89b90bf247b2739a513dbac", + "predecessor/verify_word.py": "64f62ecdbc77518dd7705087f0aaa852412d607cf197ee3fa9b0a2a96683750b", + "verify.py": "171ea17a6ec5f5985ac611f9c3b5445c3e4ca95328685cff2a9105883be1b620", + "verify_word.py": "526fe4422f2d761b4eaee2f562e2b504eed2c17fa73307cafaeda7b1cd38fd75" +} diff --git a/research/bit-five-rank4-terminals/INDEPENDENT-FIVE-TERMINALS.json b/research/bit-five-rank4-terminals/INDEPENDENT-FIVE-TERMINALS.json new file mode 100644 index 0000000000..d35586041c --- /dev/null +++ b/research/bit-five-rank4-terminals/INDEPENDENT-FIVE-TERMINALS.json @@ -0,0 +1,79 @@ +{ + "checked_frames": 636, + "checked_nested_pairs": 2394, + "controls": [ + "Declaring the retired helper FULL fails actual endpoint check.", + "An even integer dirty error passes F2 and fails exact helper restoration." + ], + "forward": { + "ADDs": 36005, + "COPYs": 9, + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 39, + "5": 102, + "6": 11, + "7": 18 + }, + "mass": 5101, + "positive_envelope": 8402567, + "prefix_row_L1": 1302 + }, + "geometry_sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "helper_inventory": { + "4": 5, + "8": 433 + }, + "inherited_precision_diagnostics": { + "104_bit_expression": "15105050522746917552142185212669952", + "192_bit_expression": "1737850264432662463887984248694818736482648196425093483769888768", + "bit_length_104": 114, + "bit_length_192": 211, + "both_strict_caps_pass": false + }, + "inverse": { + "ADDs": 36005, + "COPYs": 9, + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 39, + "5": 102, + "6": 11, + "7": 18 + }, + "mass": 5101, + "positive_envelope": 630744, + "prefix_row_L1": 1446 + }, + "limits": [ + "Independent finite word, dyadic projector and legal snapshot verification.", + "Generic exact-stream operator proof is separate from all-size physical owner/compiler admission.", + "Old H2/H4 syntax and 104/192-bit precision admission are not inherited; no outer exponent." + ], + "no_new_kappa": true, + "persistent_columns": 660, + "private_zero_slots": 1, + "roundtrip": { + "ADDs": 36005, + "COPYs": 9, + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 39, + "5": 102, + "6": 11, + "7": 18 + }, + "mass": 5101, + "positive_envelope": 630744, + "prefix_row_L1": 1253 + }, + "source_sha256": "526fe4422f2d761b4eaee2f562e2b504eed2c17fa73307cafaeda7b1cd38fd75", + "status": "PASS_INDEPENDENT_FIVE_TERMINAL_WORD_WITH_PRECISION_CAP_FAILURE", + "word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a" +} diff --git a/research/bit-five-rank4-terminals/LOCAL-PROVENANCE.json b/research/bit-five-rank4-terminals/LOCAL-PROVENANCE.json new file mode 100644 index 0000000000..b9df0d9aa2 --- /dev/null +++ b/research/bit-five-rank4-terminals/LOCAL-PROVENANCE.json @@ -0,0 +1,17 @@ +{ + "scope": "Only file discovery, metadata loading, and receipt source binding changed; mathematical checks retained. Historical originals preserved.", + "non_main_ast_identical": true, + "source_files": [ + { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/OPERATOR-BOUNDARY.md", + "retained_path": "predecessor/OPERATOR-BOUNDARY.md", + "sha256": "b268114ee08a3cb0c6fb18928361528cc7385bd5f89b90bf247b2739a513dbac" + }, + { + "original_path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/verify_word.py", + "retained_path": "predecessor/verify_word.py", + "sha256": "64f62ecdbc77518dd7705087f0aaa852412d607cf197ee3fa9b0a2a96683750b" + } + ], + "candidate_word_sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c" +} diff --git a/research/bit-five-rank4-terminals/PROOF.md b/research/bit-five-rank4-terminals/PROOF.md new file mode 100644 index 0000000000..c3ed8e5cff --- /dev/null +++ b/research/bit-five-rank4-terminals/PROOF.md @@ -0,0 +1,106 @@ +# Five rank-four terminals: exact stream boundary and remaining admission + +The independent finite audit passes for the word with uncompressed SHA256 +`3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a` and geometry +SHA256 `a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022`. +This is a local mixed-terminal operator under the exact stream operations +below. It is not an improved conditional kappa or a completed supplier admission. + +## Predecessors and changed interface + +The source is the pinned R438 transported word. The generic frame simulation +argument is credited to PR540 FramedReplay/OwnerTransport and its source-bound +PR589 extension in `research/pr589-five-helper-hosting/PROOF.md`, at canonical +20ecf2891d80b5acf18d980b2164fb44ea7faa90. The new construction moves helper +preconditioning to ZERO and replaces the old FULL literal A/B cleanup by an +early SOURCE cleanup plus a different signed tail. It therefore must not claim +that the old syntactic H4 checker passed unchanged. + +PR1194 (2e39c98238f543d988f9efc1b076590a4b780dca) and PR1311 +(a2875c1834b9c9ef42a84eda4890d5462cc98fa5) are relevant semantic-prefix +predecessors. Their stated substitution preserves H4; they do not directly +admit these changed terminal frames and cleanup. The contribution here is the explicit source-bound word. Elementary +preconditioning and the generic simulation lemma are prior mechanisms. PR1256 +(`research/bit-early-retirement-cut`) already lowers helper470 from width8 +to7 and prices returned idle progress; its fixed-prefix exclusions have different +premises from the ZERO preconditioning used here. No broad novelty claim is made. Existing complex-side heterogeneous restoration in +`research/e8-prefix-restoration` is also prior art for that general mechanism. + +## Exact stream interpretation + +For a frame projector P on K^8 define the address involution + + D_P(x,y)=((I-P)x+Py, Px+(I-P)y). + +Here K is any field of characteristic other than two. The independent checker +constructs all636 actual rational projectors by Gram-Schmidt, verifies their +dyadic entries and basis identities, and checks all2394 nested pairs used by +the word in either orientation. Idempotence and symmetry follow directly from +the orthogonal-basis formula. If P<=Q, their relative operation D_P D_Q is the +partial swap D_(Q-P), with rank dim(Q)-dim(P). Its exact rank survives odd +characteristic specialization: the dyadic characteristic polynomial of each +idempotent is t^(8-r)(t-1)^r. This supplies exact address operations, not their +physical compiler or tape implementation. + +Take660 arbitrary Boolean-valued input functions, one for every persistent +source, target and helper. The one private function starts zero. For each row +i let Gamma_i=D_Pi at its current frame and let the decoded function be +c_i=f_i composed with Gamma_i, where f_i is the physical payload. These are +bookkeeping bijections; no input is reset or assumed independent in value. + +A MOVE from Gamma_a to Gamma_b transports the physical payload by +Gamma_a Gamma_b^-1, so it preserves c_i. An ADD at a common frame changes the +decoded destination by the decoded source. Signed integer ADDs give the stated +integer lift; their reductions are XOR for Boolean values. A fresh COPY +transports the source into the private frame and copies its decoded function. +Every ERASE in the candidate sees precisely that unchanged decoded source and +the corresponding private snapshot; bijectivity yields the physical equality +needed for erasure. The private row is zero before its next reuse. + +Induction over every literal event therefore gives the decoded matrix checked +by `verify_word.py`. That independent implementation imports no producer or +predecessor checker. It tests all660 independent persistent input columns, +the PRIVATEZERO contract, exact integer source/helper restoration, the Boolean +public shear, and both signed forward/inverse roundtrips. The statement is for +all input functions, including arbitrarily correlated dirty helper contents. + +## Endpoint + +The source/target entrance and exit frames equal the old CLEAN R438 frames, +and the decoded Boolean endpoint is x'=x, y'=y+x. Thus their physical public +operator is unchanged. For helpers462,463,464,467,470 the decoded value is +exactly its original arbitrary helper value, but its physical residual is +D_E for the explicit terminal rank-four frame E. The other433 helpers retain +the old rank-eight residual. No dirty output is discarded, and no initial +native query is hidden in the1765 ZERO helper ADDs. + +In a reflected embedding, replace the local gauge by D_(I-P) times the shared +exterior factor. The relative endpoint from frame0 to E is still D_E, since +D_I D_(I-E)=D_E. The same induction and signed inverse apply. An actual owner +must map each E residual into its assigned pending coordinates; rank alone +does not construct the required orthogonal chart or chronological placement. + +The complete local histogram is + + H={1:1322,2:1342,3:79,4:39,5:102,6:11,7:18}. + +Its rank mass5101 equals111*14+433*8+5*4+63. All36005 ADDs and nine rank-seven +COPY calls remain paid. The lost20 helper ranks exactly equal the removed +query mass; they are not an extra unearned deficit. + +## Gates still open + +The conservative forward/reverse positive envelopes are8402567 and630744. +The inherited expressions64 F^3 R^2 and2^18 F^5 R^4 require114 and211 bits, +respectively, and fail the old104/192-bit caps. Exact signed prefix row norms +1302 and1446 are recorded diagnostics, not an automatic replacement for the +old defect and COPY/ERASE error analysis. + +This proof closes the arbitrary-input endpoint in the stated exact stream +model. The finite residual isometries and coordinate words are now supplied by +`admission/README.md`. Whole-owner chronological hosting, physical scalar/address routes, rounded-child errors, precision charges, +all-size dispatch, storage/tape costs and joint outer assembly remain separate. +The checker is finite exact evidence; this document is a written induction, +not a formal-kernel certificate. No new kappa is claimed. + +Apache-2.0; substantial OpenAI Codex assistance. diff --git a/research/bit-five-rank4-terminals/README.md b/research/bit-five-rank4-terminals/README.md new file mode 100644 index 0000000000..f703cd1cd2 --- /dev/null +++ b/research/bit-five-rank4-terminals/README.md @@ -0,0 +1,97 @@ +# Five rank-four BIT terminals and a fixed-controller cost bound + +This package retains an explicit local BIT word with 433 width-eight and five +width-four dirty helpers. Its exact stream operator restores every source and +helper over the integers and gives the required public shear modulo two. The +complete local histogram is H={1:1322,2:1342,3:79,4:39,5:102,6:11,7:18}: 2913 +children, rank mass5101, 36005 scalar ADDs, nine rank-seven COPYs and one private +zero field. No native supplier or improved multiplication exponent is claimed. + +The five terminal helpers are462,463,464,467,470. Their ZERO preconditioning +changes the old H4 cleanup syntax. `PROOF.md` supplies the exact arbitrary-function +stream interpretation; `verify_word.py` independently checks all660 persistent +input columns, integer source/helper restoration, public Boolean action, both +inverse orders, private cleanup, 636 actual rational projectors and2394 nesting +pairs. The integer lift may retain even dirty coefficients in public targets; +its real/complex endpoint is not asserted to be a clean shear. + +`admission/README.md` adds explicit reversible coordinate words for all three +terminal charts. Their Q/Q^-1 lengths are24,70,70; the complete D_E lengths +are100,284,284. These use arbitrary input coordinates, no scratch, and only +unit signed ADD, NEGATE, HALF, DOUBLE and SWAP over Z[1/2] and every odd field. +They are address-coordinate counts, not native payload or tape costs. The same +supplement gives exact dyadic prefix bounds and a defect-sensitive error model +with a counterexample to inferring exact private erasure from finite accuracy. + +The changed word requires114/211bits in the historical five-/nine-stage +prefix expressions, exceeding the inherited104/192-bit acceptance caps. +The historical arbitrary-precision implementation does not overflow: revised +64-bit charges would be128/256. Conditional invoice headroom is proved, but +no new physical invoice or rounded-child cleanup is supplied. + +`moment/PROOF.md` and its independent review state the complete cost screen. +The lost20 local query ranks equal the lost20 helper progress ranks. In the +fixed nine-stage m=64 geometry the ideal idle mass is1178, the raw deficit is +107/3 per invocation, and even arbitrary ideal rank45 idle packing has a root +below .001962938841611 (below .001962938839481 with the inherited fallback). +The stronger +`moment/WINDOW-PROOF.md` uses the pinned public intervals: their maximum rank +at nine stages is42. It proves failure for every odd stage count and every +recursion depth at b>=.002, granting fractional owners, arbitrary additional +full-progress helper stock and free omitted costs. At nine stages the ideal +rank42 root with fallback is below .001954220766880. The all-odd conclusion +is a written recipe argument; it does not assert that the historical CLI emits +all arities. The requested .002, .003 and .005 targets fail within this fixed +coverage and chronology model. These lower bounds grant free omitted costs; they are rejection +certificates, never positive compiler admission. + +## Reproduce + +Use Python3.12 and the standard library, from the repository root: + +```sh +python3.12 scripts/research_package.py --package research/bit-five-rank4-terminals +``` + +`VERIFY.json` runs the package in normal and optimized Python. The checker +resolves inputs relative to the files, so a Git-free export works from any +working directory. `SOURCES.json` pins the one external geometry input and +upstream orientation. `LOCAL-PROVENANCE.json`, `WORD-ADAPTATION.patch` and the +supplements retain authenticated local originals, transfer manifests and exact +relocation adaptations. Absolute historical paths in provenance are not runtime +dependencies. SHA256 integrity does not establish authorship or mathematical truth. + +## Open next questions + +A changed public chronology, paid fusion across old intervals, or a useful +partial-progress auxiliary contract could change the cost bound's premises. +First specify the exact arbitrary-input operator and complete tariff for one +such change. A favorable relaxation still needs integral owners, legal native +routes, exact cleanup, a full physical invoice and a compatible complex caller. + +## Scope and attribution + +This is finite exact computation, written all-input stream reasoning, and a +written cost bound with rational endpoint checks. It is not a Lean kernel proof, +chronological physical owner realization, all-size compiler, rounded supplier, +complete storage/tape invoice, or compatible joint outer construction. + +Credit Ali Romman's R438/PR1043 construction, Sagar Thakrar's transported R438 +and hosting lineage, cheesegrader's PR540 frame/owner framework, PR589 hosting, +and the frozen five-terminal construction authors. PR1256 already studies +helper470 early retirement and returned idle accounting. PR1194/1311 and +E8 prefix restoration are relevant semantic-prefix/heterogeneous precedents; +their hypotheses are retained. + +Sagar Thakrar's [PR3948](https://github.com/CrocSwap/integer-mult-bounds/pull/3948), +at `5505853988cfc05bc8ad9bfcf07879727932b0d5`, already gives the generic +idle-window formula, the nine-stage ranks {7,14,28,42}, and the observation +that deeper recursion does not merge bridge-delimited public intervals. +Those facts are credited prior work. This package adds the explicit five-terminal +word and charts, its exact twenty-for-twenty query/progress cancellation, and +the candidate-specific obstruction for all odd arities and recursion depths, +including arbitrary additional full-progress helper stock. No exhaustive +novelty claim is made. + +Apache-2.0; substantial OpenAI Codex assistance, including independent AI +mathematical review. No new kappa. diff --git a/research/bit-five-rank4-terminals/SOURCES.json b/research/bit-five-rank4-terminals/SOURCES.json new file mode 100644 index 0000000000..9441965655 --- /dev/null +++ b/research/bit-five-rank4-terminals/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "usage": "input", + "git_blob": "e12a566658a4b2c8b6ae0ecc34fd41290f68f5e8", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + } + ] +} diff --git a/research/bit-five-rank4-terminals/TASK.json b/research/bit-five-rank4-terminals/TASK.json new file mode 100644 index 0000000000..3f10da2927 --- /dev/null +++ b/research/bit-five-rank4-terminals/TASK.json @@ -0,0 +1,61 @@ +{ + "schema_version": 1, + "task_id": "bit-helper-contract", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. 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", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + "scope_status": "changed", + "actual_scope": "Audit an explicit five-terminal BIT word, construct its finite residual charts and price its complete inherited global coverage model.", + "scope_change_reason": "User assigned the authenticated five-helper early-retirement candidate and local packaging of completed results; this changes the original single helper-star experiment.", + "bottleneck_link": "Five width-eight to width-four retirements remove twenty local ranks and twenty hosted progress ranks together. Complete idle pricing decides whether these local savings can support the requested exponent.", + "budget_minutes": 240, + "stop_rule": "Preserve an exact finite construction and a decisive scoped cost screen; do not build a native compiler once the unchanged coverage model fails the target.", + "outcome": "completed", + "evidence": "PROOF.md, INDEPENDENT-FIVE-TERMINALS.json, admission/README.md and moment/PROOF.md", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance, including separate exact circuit and moment reviewers. No human or formal-kernel review.", + "open_questions": [ + { + "question": "Can a changed coverage/controller law improve the full moment with these terminals?", + "why_it_matters": "The inherited coverage model does not attain the requested .002 target.", + "first_step": "Specify a different source-window or coverage law and a complete charged invoice before further search.", + "blocked_by": "No native chronological owner allocation, exact rounded cleanup, physical tape/storage compiler or compatible admitted joint caller." + } + ] +} diff --git a/research/bit-five-rank4-terminals/VERIFY.json b/research/bit-five-rank4-terminals/VERIFY.json new file mode 100644 index 0000000000..ef4cfaa43c --- /dev/null +++ b/research/bit-five-rank4-terminals/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-r438-transport-rehost/words/r438-t154.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "All660 dirty columns, both inverses, private return, exact charts, signed/defect bounds, strict moment enclosure and independent controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 240, + "checks": "Same complete checks with Python optimization; explicit fail-closed predicates remain active." + } + ] +} diff --git a/research/bit-five-rank4-terminals/WORD-ADAPTATION.patch b/research/bit-five-rank4-terminals/WORD-ADAPTATION.patch new file mode 100644 index 0000000000..c6a43b266e --- /dev/null +++ b/research/bit-five-rank4-terminals/WORD-ADAPTATION.patch @@ -0,0 +1,25 @@ +--- predecessor/verify_word.py ++++ verify_word.py +@@ -10,7 +10,8 @@ + from pathlib import Path + import argparse, gzip, json + HERE=Path(__file__).resolve().parent +-LANE=HERE.parent/'bit-boundaries' ++# Relocation-only adaptation; frozen source is retained under predecessor/. ++GEOMETRY=HERE.parent/'bit-r438-transport-rehost/words/r438-t154.json.gz' + EXPECTED_WORD='3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a' + EXPECTED_GEOMETRY='a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022' + N=660 +@@ -91,10 +92,9 @@ + + def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');a=ap.parse_args() +- receipt=json.loads((LANE/'FIVE-TERMINALS.json').read_text()) +- blob=gzip.decompress((LANE/'FIVE-TERMINALS-WORD.json.gz').read_bytes()) ++ blob=gzip.decompress((HERE/'WORD.json.gz').read_bytes()) + need(sha256(blob).hexdigest()==EXPECTED_WORD,'independent frozen candidate word') +- source=Path(next(iter(receipt['source'])));rawbytes=source.read_bytes() ++ source=GEOMETRY;rawbytes=source.read_bytes() + need(sha256(rawbytes).hexdigest()==EXPECTED_GEOMETRY,'independent frozen geometry') + raw=json.loads(gzip.decompress(rawbytes));word=json.loads(blob);frames=Frames(raw) + rows,forward=replay(word,frames) diff --git a/research/bit-five-rank4-terminals/WORD.json.gz b/research/bit-five-rank4-terminals/WORD.json.gz new file mode 100644 index 0000000000..aa9ec3c341 Binary files /dev/null and b/research/bit-five-rank4-terminals/WORD.json.gz differ diff --git a/research/bit-five-rank4-terminals/admission/ADAPTATION-CHECK.json b/research/bit-five-rank4-terminals/admission/ADAPTATION-CHECK.json new file mode 100644 index 0000000000..4020c20acc --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/ADAPTATION-CHECK.json @@ -0,0 +1,21 @@ +{ + "unchanged_non_main_functions": [ + "apply_gate", + "chart_program", + "double", + "identity", + "invert_gate", + "magnitude_and_defects", + "matrix_product", + "need", + "partial_swap", + "rank", + "sha", + "transpose", + "verify_chart" + ], + "main_mathematical_checks_byte_identical": true, + "original_script_preserved_sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194", + "portable_script_sha256": "762357be4644da879251eca070a81dfd73ec3ef4991191cdd630896e7e9b44a3", + "exact_replacement_count": 8 +} diff --git a/research/bit-five-rank4-terminals/admission/ADAPTATION.patch b/research/bit-five-rank4-terminals/admission/ADAPTATION.patch new file mode 100644 index 0000000000..43b974f71e --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/ADAPTATION.patch @@ -0,0 +1,57 @@ +--- provenance/verify_admission.original.py.txt ++++ verify.py +@@ -14,9 +14,8 @@ + import json + + HERE = Path(__file__).resolve().parent +-RUN = HERE.parent +-INPUT = RUN.parent / 'kappa-four-coordinate-20261019T0717Z' +-REPO = Path('/Users/ross/git/math/integer-mult-bounds') ++INPUT = HERE / 'inputs' ++REPO = HERE / 'source-context' + + + def need(p, msg): +@@ -241,9 +240,8 @@ + p = argparse.ArgumentParser() + p.add_argument('--write', action='store_true') + args = p.parse_args() +- own = json.loads((RUN/'OWNERSHIP.json').read_text()) +- for k in ('input_manifest', 'frozen_manifest'): +- need(sha(own[k+'_path']) == own[k+'_sha256'], 'ownership manifest authentication') ++ bundle = json.loads((HERE/'INPUT-MANIFEST.json').read_text()) ++ own = {'decompressed_word_sha256': bundle['decompressed_word_sha256']} + seen = {} + def authenticate(x): + if isinstance(x, list): +@@ -251,22 +249,23 @@ + authenticate(y) + elif isinstance(x, dict): + if 'path' in x and 'sha256' in x: +- need(sha(x['path']) == x['sha256'], 'pinned file changed: '+x['path']) ++ path = Path(x['path']) ++ need(not path.is_absolute() and '..' not in path.parts, 'bundle-relative input') ++ need(sha(HERE/path) == x['sha256'], 'pinned file changed: '+x['path']) + seen[x['path']] = x['sha256'] + for y in x.values(): + if isinstance(y, (dict, list)): + authenticate(y) +- authenticate(json.loads(Path(own['input_manifest_path']).read_text())) +- authenticate(json.loads(Path(own['frozen_manifest_path']).read_text())) +- wordfile = INPUT/'bit-boundaries/FIVE-TERMINALS-WORD.json.gz' ++ authenticate(bundle['files']) ++ wordfile = INPUT/'FIVE-TERMINALS-WORD.json.gz' + blob = gzip.decompress(wordfile.read_bytes()) + need(sha256(blob).hexdigest() == own['decompressed_word_sha256'], 'literal word hash') + word = json.loads(blob) +- rawpath = REPO/'research/bit-r438-transport-rehost/words/r438-t154.json.gz' +- fullpath = REPO/'research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz' ++ rawpath = INPUT/'r438-t154.json.gz' ++ fullpath = INPUT/'bitE8-r865.json.gz' + raw = json.loads(gzip.decompress(rawpath.read_bytes())) + full = json.loads(gzip.decompress(fullpath.read_bytes())) +- charts = json.loads((INPUT/'bit-boundaries/TERMINAL-CHARTS.json').read_text())['charts'] ++ charts = json.loads((INPUT/'TERMINAL-CHARTS.json').read_text())['charts'] + need([x['terminal_frame'] for x in charts] == [506, 508, 509], 'three exact frames') + checked = [verify_chart(c, raw, full) for c in charts] + controls = [] diff --git a/research/bit-five-rank4-terminals/admission/ADMISSION-CHECK.json b/research/bit-five-rank4-terminals/admission/ADMISSION-CHECK.json new file mode 100644 index 0000000000..29d075a455 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/ADMISSION-CHECK.json @@ -0,0 +1,5699 @@ +{ + "authenticated_unique_files": 20, + "controls": [ + "nonorthogonal chart rejected", + "wrong actual terminal span rejected", + "COPY defect survives inverse source shear at 256 bits" + ], + "forward": { + "opcode_counts": { + "0": 2904, + "1": 36005, + "2": 9, + "3": 9 + }, + "positive_envelope_exact_erase_only": 8402567, + "private_bounds_after_each_erase": [ + 290, + 586, + 906, + 1330, + 1892, + 2222, + 2528, + 2994, + 3762 + ], + "unit_defect_all_prefix_bound": 662069, + "unit_defect_persistent_endpoint_bound": 662069, + "unit_defect_private_endpoint_bound": 3762 + }, + "independent_charts": [ + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 17, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "4", + "inverse": [ + [ + "swap", + 5, + 0 + ], + [ + "swap", + 6, + 1 + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 2, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 6, + 7, + "-1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "4", + "missing_final_gate_rejected": true, + "primitive_count": 24, + "primitive_histogram": { + "add": 10, + "scale:-1": 2, + "scale:1/2": 4, + "scale:2": 4, + "swap": 4 + }, + "program": [ + [ + "add", + 6, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 2, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "swap", + 6, + 1 + ], + [ + "swap", + 5, + 0 + ] + ], + "residual_16_coordinate_primitive_count": 100, + "residual_16_coordinate_program": [ + [ + "swap", + 5, + 0 + ], + [ + "swap", + 6, + 1 + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 2, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 6, + 7, + "-1" + ], + [ + "swap", + 13, + 8 + ], + [ + "swap", + 14, + 9 + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 14, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 15, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "swap", + 13, + 12 + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 10, + 15, + "1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 14, + 15, + "-1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 6, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 2, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "swap", + 6, + 1 + ], + [ + "swap", + 5, + 0 + ], + [ + "add", + 14, + 15, + "1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 10, + 15, + "-1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "swap", + 13, + 12 + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 15, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 14, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "swap", + 14, + 9 + ], + [ + "swap", + 13, + 8 + ] + ], + "residual_max_prefix_denominator": 2, + "residual_max_prefix_row_l1": "4", + "scratch_field_elements": 0 + }, + "frame": 506, + "max_denominator": 2, + "rank": 4 + }, + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 44, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "8", + "inverse": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "-1" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "-1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "8", + "missing_final_gate_rejected": true, + "primitive_count": 70, + "primitive_histogram": { + "add": 40, + "scale:-1": 4, + "scale:1/2": 12, + "scale:2": 12, + "swap": 2 + }, + "program": [ + [ + "add", + 5, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ] + ], + "residual_16_coordinate_primitive_count": 284, + "residual_16_coordinate_program": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "-1" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "-1" + ], + [ + "add", + 8, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 8, + 11, + "-1" + ], + [ + "add", + 9, + 11, + "1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "-1" + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 8, + 12, + "1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "swap", + 14, + 13 + ], + [ + "scale", + 13, + "1/2" + ], + [ + "add", + 8, + 13, + "-1" + ], + [ + "add", + 9, + 13, + "1" + ], + [ + "add", + 12, + 13, + "-1" + ], + [ + "scale", + 14, + "1/2" + ], + [ + "add", + 9, + 14, + "1" + ], + [ + "add", + 10, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 13, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 9, + 15, + "1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 13, + 15, + "-1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 5, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 13, + 15, + "1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 9, + 15, + "-1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 13, + 14, + "1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "1" + ], + [ + "add", + 9, + 14, + "-1" + ], + [ + "scale", + 14, + "2" + ], + [ + "add", + 12, + 13, + "1" + ], + [ + "add", + 9, + 13, + "-1" + ], + [ + "add", + 8, + 13, + "1" + ], + [ + "scale", + 13, + "2" + ], + [ + "swap", + 14, + 13 + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 8, + 12, + "-1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "1" + ], + [ + "add", + 13, + 11, + "1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "add", + 9, + 11, + "-1" + ], + [ + "add", + 8, + 11, + "1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "1" + ], + [ + "scale", + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ] + ], + "residual_max_prefix_denominator": 4, + "residual_max_prefix_row_l1": "10", + "scratch_field_elements": 0 + }, + "frame": 508, + "max_denominator": 2, + "rank": 4 + }, + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 44, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "8", + "inverse": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "scale", + 6, + "-1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "8", + "missing_final_gate_rejected": true, + "primitive_count": 70, + "primitive_histogram": { + "add": 40, + "scale:-1": 4, + "scale:1/2": 12, + "scale:2": 12, + "swap": 2 + }, + "program": [ + [ + "add", + 5, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "scale", + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ] + ], + "residual_16_coordinate_primitive_count": 284, + "residual_16_coordinate_program": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "scale", + 6, + "-1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 8, + 11, + "1" + ], + [ + "add", + 9, + 11, + "-1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "1" + ], + [ + "add", + 14, + 11, + "1" + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 8, + 12, + "1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 13, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "swap", + 14, + 13 + ], + [ + "scale", + 13, + "1/2" + ], + [ + "add", + 8, + 13, + "-1" + ], + [ + "add", + 9, + 13, + "1" + ], + [ + "add", + 12, + 13, + "-1" + ], + [ + "scale", + 14, + "1/2" + ], + [ + "scale", + 14, + "-1" + ], + [ + "add", + 9, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 13, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 9, + 15, + "-1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 13, + 15, + "1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 5, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "scale", + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 13, + 15, + "-1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 9, + 15, + "1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 13, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "1" + ], + [ + "add", + 9, + 14, + "1" + ], + [ + "scale", + 14, + "-1" + ], + [ + "scale", + 14, + "2" + ], + [ + "add", + 12, + 13, + "1" + ], + [ + "add", + 9, + 13, + "-1" + ], + [ + "add", + 8, + 13, + "1" + ], + [ + "scale", + 13, + "2" + ], + [ + "swap", + 14, + 13 + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 8, + 12, + "-1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "-1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "add", + 9, + 11, + "1" + ], + [ + "add", + 8, + 11, + "-1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ] + ], + "residual_max_prefix_denominator": 4, + "residual_max_prefix_row_l1": "10", + "scratch_field_elements": 0 + }, + "frame": 509, + "max_denominator": 2, + "rank": 4 + } + ], + "inverse": { + "opcode_counts": { + "0": 2904, + "1": 36005, + "2": 9, + "3": 9 + }, + "positive_envelope_exact_erase_only": 630744, + "private_bounds_after_each_erase": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36 + ], + "unit_defect_all_prefix_bound": 47917, + "unit_defect_persistent_endpoint_bound": 47917, + "unit_defect_private_endpoint_bound": 36 + }, + "limits": "No exact rounded-child cleanup, chronological owners, paid native routes, all-size compiler, tape or outer admission.", + "no_new_kappa": true, + "precision": { + "conditional_depth_two": { + "charged_bits": 512, + "child_count_max": 1048575, + "extra_invoice_max": "1645504557321206042154969182557350504982735865633579863348609023", + "scope": "Sufficient conditional arithmetic only; no compiler or owner invoice is supplied.", + "upper_bound_bits": 463 + }, + "five_stage_bits": 114, + "five_stage_integer_bound": "15105050522746917552142185212669952", + "five_stage_multiple_of_64": 128, + "nine_stage_bits": 211, + "nine_stage_integer_bound": "1737850264432662463887984248694818736482648196425093483769888768", + "nine_stage_multiple_of_64": 256 + }, + "script_sha256": "762357be4644da879251eca070a81dfd73ec3ef4991191cdd630896e7e9b44a3", + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "research/pr589-five-helper-hosting/PROOF.md": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + "status": "PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER", + "word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a" +} diff --git a/research/bit-five-rank4-terminals/admission/BUNDLE-MANIFEST.json b/research/bit-five-rank4-terminals/admission/BUNDLE-MANIFEST.json new file mode 100644 index 0000000000..f1bb3fba3c --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/BUNDLE-MANIFEST.json @@ -0,0 +1,119 @@ +{ + "files": [ + { + "bytes": 559, + "path": "ADAPTATION-CHECK.json", + "sha256": "18f09c62864738cb39e8fbe52b3e811406afdbba85634f7be3f9aeb2cebc7c32" + }, + { + "bytes": 2718, + "path": "ADAPTATION.patch", + "sha256": "88106c60dbc9563478351d213d3dfdd2a88d0d0d8734e4b16c41e75b72accb43" + }, + { + "bytes": 90205, + "path": "ADMISSION-CHECK.json", + "sha256": "cb7e3c83d066a82fa2d458b2d8ac2cc04ae90bde2ad4f70e07fdc252888a87d0" + }, + { + "bytes": 3717, + "path": "INPUT-MANIFEST.json", + "sha256": "70b0515c54a63dd545d256ee3da17f2f8ce00e89d08580f7cdbcdc4bb72dac03" + }, + { + "bytes": 5183, + "path": "README.md", + "sha256": "d9aacfb3c2bb7a3e3fbad8453409fba9e925bc833b399fa6e0bc94e13e2570b6" + }, + { + "bytes": 1209, + "path": "VALIDATION.json", + "sha256": "2c4cb7e0e427dbc9ad4179a3423e3eaaaa8726701f8e50e26622a956b59d9cb4" + }, + { + "bytes": 105171, + "path": "inputs/FIVE-TERMINALS-WORD.json.gz", + "sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c" + }, + { + "bytes": 8718, + "path": "inputs/TERMINAL-CHARTS.json", + "sha256": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17" + }, + { + "bytes": 33865, + "path": "inputs/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 42305, + "path": "inputs/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "bytes": 90205, + "path": "provenance/ADMISSION-CHECK.original.json", + "sha256": "914c4deecd9fa972f396e942c6d6bfbf13e6ef58f6a54ad8e8d4a125b0652519" + }, + { + "bytes": 7198, + "path": "provenance/FROZEN-MANIFEST.original.json", + "sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7" + }, + { + "bytes": 1452, + "path": "provenance/OWNERSHIP.original.json", + "sha256": "ed5b67369aa95c80a5a4a958dc030cc216954d6a8b23d01252d2c84647758fbc" + }, + { + "bytes": 709, + "path": "provenance/PR540-SOURCE-PINS.original.json", + "sha256": "2963bc4edd609c542bad37f6021f251dbaa254495948d715dc3c704c8058b31d" + }, + { + "bytes": 5330, + "path": "provenance/TRANSFER-AUTHENTICATION.json", + "sha256": "e6b71af938ed1457e163390a8f304dd18493d7b6937d431561e22895c2fd6597" + }, + { + "bytes": 7489, + "path": "provenance/TRANSFER-MANIFEST.original.json", + "sha256": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb" + }, + { + "bytes": 14647, + "path": "provenance/verify_admission.original.py.txt", + "sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194" + }, + { + "bytes": 7155, + "path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce" + }, + { + "bytes": 8609, + "path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" + }, + { + "bytes": 6048, + "path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py", + "sha256": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe" + }, + { + "bytes": 16791, + "path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + { + "bytes": 12438, + "path": "source-context/research/pr589-five-helper-hosting/PROOF.md", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "bytes": 14417, + "path": "verify.py", + "sha256": "762357be4644da879251eca070a81dfd73ec3ef4991191cdd630896e7e9b44a3" + } + ] +} diff --git a/research/bit-five-rank4-terminals/admission/INPUT-MANIFEST.json b/research/bit-five-rank4-terminals/admission/INPUT-MANIFEST.json new file mode 100644 index 0000000000..f9316733da --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/INPUT-MANIFEST.json @@ -0,0 +1,106 @@ +{ + "decompressed_word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a", + "files": [ + { + "bytes": 559, + "path": "ADAPTATION-CHECK.json", + "sha256": "18f09c62864738cb39e8fbe52b3e811406afdbba85634f7be3f9aeb2cebc7c32" + }, + { + "bytes": 2718, + "path": "ADAPTATION.patch", + "sha256": "88106c60dbc9563478351d213d3dfdd2a88d0d0d8734e4b16c41e75b72accb43" + }, + { + "bytes": 5183, + "path": "README.md", + "sha256": "d9aacfb3c2bb7a3e3fbad8453409fba9e925bc833b399fa6e0bc94e13e2570b6" + }, + { + "bytes": 105171, + "path": "inputs/FIVE-TERMINALS-WORD.json.gz", + "sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c" + }, + { + "bytes": 8718, + "path": "inputs/TERMINAL-CHARTS.json", + "sha256": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17" + }, + { + "bytes": 33865, + "path": "inputs/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 42305, + "path": "inputs/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "bytes": 90205, + "path": "provenance/ADMISSION-CHECK.original.json", + "sha256": "914c4deecd9fa972f396e942c6d6bfbf13e6ef58f6a54ad8e8d4a125b0652519" + }, + { + "bytes": 7198, + "path": "provenance/FROZEN-MANIFEST.original.json", + "sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7" + }, + { + "bytes": 1452, + "path": "provenance/OWNERSHIP.original.json", + "sha256": "ed5b67369aa95c80a5a4a958dc030cc216954d6a8b23d01252d2c84647758fbc" + }, + { + "bytes": 709, + "path": "provenance/PR540-SOURCE-PINS.original.json", + "sha256": "2963bc4edd609c542bad37f6021f251dbaa254495948d715dc3c704c8058b31d" + }, + { + "bytes": 5330, + "path": "provenance/TRANSFER-AUTHENTICATION.json", + "sha256": "e6b71af938ed1457e163390a8f304dd18493d7b6937d431561e22895c2fd6597" + }, + { + "bytes": 7489, + "path": "provenance/TRANSFER-MANIFEST.original.json", + "sha256": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb" + }, + { + "bytes": 14647, + "path": "provenance/verify_admission.original.py.txt", + "sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194" + }, + { + "bytes": 7155, + "path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce" + }, + { + "bytes": 8609, + "path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" + }, + { + "bytes": 6048, + "path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py", + "sha256": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe" + }, + { + "bytes": 16791, + "path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + { + "bytes": 12438, + "path": "source-context/research/pr589-five-helper-hosting/PROOF.md", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "bytes": 14417, + "path": "verify.py", + "sha256": "762357be4644da879251eca070a81dfd73ec3ef4991191cdd630896e7e9b44a3" + } + ], + "version": 1 +} diff --git a/research/bit-five-rank4-terminals/admission/README.md b/research/bit-five-rank4-terminals/admission/README.md new file mode 100644 index 0000000000..556ca3ac68 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/README.md @@ -0,0 +1,95 @@ +# Portable five-terminal chart and arithmetic supplement + +Run with Python 3.11 or later and the standard library: + +```sh +python3 -I -B verify.py +python3 -I -O -B verify.py +``` + +The script resolves every input relative to itself. It needs no old run, +repository checkout, Git, generated bytecode, third-party modules, or network. +`--write` deliberately replaces the local result receipt; normal runs compare +the recomputation against the shipped receipt. Run from any working directory. + +The mathematical inputs are four files in `inputs/`: the five-terminal literal +word, its three terminal charts, the original R438 geometry, and the E8 root +skeleton. `source-context/` contains only five literal historical files used +to bind the envelope/invoice interpretation; they are hashed but never imported +or executed. Their dependency directories were not copied. + +The checker authenticates all files listed in `INPUT-MANIFEST.json`, replays +the three coordinate charts and their inverses, computes the signed-word +positive envelopes and additive-defect bounds in both orientations, checks +the precision inequalities and retains the original negative controls. It +does not duplicate the independent full 660-column BIT operator audit. + +## Mathematical result and domain + +Each saved Q is orthogonal over Z[1/2], and its first four columns span the +specified actual rank-four terminal frame E. The literal programs prove + + D_E = diag(Q,Q) D_coordinate4 diag(Q^T,Q^T). + +Q programs use 24,70,70 invertible coordinate primitives for frames506,508,509. +The complete 16-coordinate residual programs use 100,284,284 primitives. Their +alphabet is unit signed ADD, NEGATE, DOUBLE, HALF and SWAP. Every coordinate +input is arbitrary; no extra field element is used. The programs and their +exact inverses work over any Z[1/2]-module and hence every odd field. These are +coordinate-arithmetic costs, not recursive payload or physical tape tariffs. + +The chart programs have maximum prefix denominators2 and infinity norms4,8,8. +The complete residual programs have maximum prefix denominators2,4,4 and +infinity norms4,10,10. These exact matrix bounds give reachable dyadic-grid +statements when the input is dyadic; they do not license approximate rounding. + +The scalar word gives F=8402567, R=630744. The historical five-/nine-stage +expressions need114/211bits and fail104/192-bit caps. New multiples-of-64 charges +would be128/256. For the historical depth-two formula, writing C=P9+B and paid +child count E, the explicit sufficient premises B<2^210 and E<2^20 give a +two-level quantity with at most463bits, below512. No missing compiler invoice +is supplied by these sufficient bounds. + +For the defect calculation, gauges are exact isometries of bounded functions, +scalar ADDs are exact, and each MOVE/COPY/ERASE may introduce an independent +destination error of norm at most delta. COPY and ERASE are extended as source +shears; private errors are never reset. Starting from zero errors, propagate + + ADD d += c s: e_d <- e_d + |c| e_s + MOVE d: e_d <- e_d + 1 + COPY/ERASE: e_private <- e_private + e_source + 1. + +The triangle inequality proves the resulting bound by induction. Maximum +prefix errors are at most662069 delta forward and47917 delta inverse; private +endpoint errors are bounded by3762 delta and36 delta. This compares with the +signed integer lift, whose clean BIT public endpoint is obtained only modulo2. +It is not a rounded implementation of the Boolean supplier. A nonzero COPY +defect survives exact source subtraction, so finite accuracy alone cannot +prove an exact ERASE. Actual rounded-child cleanup remains open. + +## Provenance and adaptation + +`provenance/` retains the authenticated transfer manifests, ownership receipt, +original checker and result, source-context pins and the copy authentication +record. Their absolute paths are historical metadata only; no runtime path is +taken from them. This preserves the original run's provenance without requiring +live ownership files to rerun the mathematics. Hash integrity is not a digital +signature or a proof of mathematical truth. + +See `ADAPTATION.patch` for the complete eight exact text replacements and +`ADAPTATION-CHECK.json` for the source comparison. The original checker is +unchanged in `provenance/verify_admission.original.py.txt`. The 13 non-main +functions have identical ASTs; the main chart, defect, precision, invoice and +negative-control section is byte-identical. Only bundle-root discovery, +manifest authentication and four input locations changed. Provenance file count +and executing-script hash consequently differ from the old result; mathematical +result fields must agree exactly. + +This supplement establishes finite exact coordinate programs and bounded +arithmetic diagnostics. Chronological owners, native routes, exact rounded +cleanup, storage/tape accounting, all-size dispatch and compatible joint moments +remain separate. No new kappa, formal-kernel replay, or native supplier admission. + +Credit the R438/PR589 and E8 geometry lineage, the frozen five-terminal authors, +cheesegrader's PR540 framework and the PR589 hosting proof authors. Apache-2.0; +substantial OpenAI Codex assistance. diff --git a/research/bit-five-rank4-terminals/admission/VALIDATION.json b/research/bit-five-rank4-terminals/admission/VALIDATION.json new file mode 100644 index 0000000000..08420d22ad --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/VALIDATION.json @@ -0,0 +1,35 @@ +{ + "excluded_metadata_only": [ + "authenticated_unique_files", + "script_sha256" + ], + "input_manifest_sha256": "70b0515c54a63dd545d256ee3da17f2f8ce00e89d08580f7cdbcdc4bb72dac03", + "mathematical_receipt_unchanged": true, + "no_bytecode_generated": true, + "no_new_kappa": true, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "relocated_results": [ + { + "cwd": "/", + "exit_code": 0, + "flags": [ + "-I", + "-B" + ], + "stdout": "PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER\n{\"charts\": 3, \"guards\": [114, 211], \"defect_bounds\": [662069, 47917], \"conditional_two_level_bits\": 463}\n" + }, + { + "cwd": "/", + "exit_code": 0, + "flags": [ + "-I", + "-B", + "-O" + ], + "stdout": "PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER\n{\"charts\": 3, \"guards\": [114, 211], \"defect_bounds\": [662069, 47917], \"conditional_two_level_bits\": 463}\n" + } + ], + "relocation_copy_removed": true, + "status": "PASS_PORTABLE_NORMAL_OPTIMIZED_AND_RELOCATED", + "unchanged_original_checker_sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194" +} diff --git a/research/bit-five-rank4-terminals/admission/inputs/FIVE-TERMINALS-WORD.json.gz b/research/bit-five-rank4-terminals/admission/inputs/FIVE-TERMINALS-WORD.json.gz new file mode 100644 index 0000000000..aa9ec3c341 Binary files /dev/null and b/research/bit-five-rank4-terminals/admission/inputs/FIVE-TERMINALS-WORD.json.gz differ diff --git a/research/bit-five-rank4-terminals/admission/inputs/TERMINAL-CHARTS.json b/research/bit-five-rank4-terminals/admission/inputs/TERMINAL-CHARTS.json new file mode 100644 index 0000000000..832e64f726 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/inputs/TERMINAL-CHARTS.json @@ -0,0 +1,551 @@ +{ + "charts": [ + { + "Q_columns": [ + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "-1/2", + "0", + "1/2", + "0", + "0", + "1/2" + ], + [ + "0", + "1/2", + "-1/2", + "0", + "-1/2", + "0", + "0", + "-1/2" + ] + ], + "cold_full_root_labels": [ + 0, + 3, + 12, + 15 + ], + "determinant_unit_over_every_odd_field": true, + "inside_full_root_labels": [ + 5, + 6, + 9, + 10 + ], + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "terminal_frame": 506 + }, + { + "Q_columns": [ + [ + "1/2", + "0", + "-1/2", + "0", + "1/2", + "0", + "-1/2", + "0" + ], + [ + "1/2", + "-1/2", + "0", + "0", + "0", + "0", + "1/2", + "-1/2" + ], + [ + "0", + "0", + "1/2", + "1/2", + "1/2", + "-1/2", + "0", + "0" + ], + [ + "0", + "1/2", + "0", + "1/2", + "0", + "1/2", + "0", + "-1/2" + ], + [ + "1/2", + "0", + "1/2", + "0", + "-1/2", + "0", + "-1/2", + "0" + ], + [ + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "1/2", + "1/2" + ], + [ + "0", + "0", + "1/2", + "-1/2", + "1/2", + "1/2", + "0", + "0" + ], + [ + "0", + "1/2", + "0", + "-1/2", + "0", + "-1/2", + "0", + "-1/2" + ] + ], + "cold_full_root_labels": [ + 19, + 24, + 100, + 111 + ], + "determinant_unit_over_every_odd_field": true, + "inside_full_root_labels": [ + 21, + 29, + 97, + 105 + ], + "projector": [ + [ + "1/2", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "-1/4", + "1/2", + "0", + "1/4", + "0", + "1/4", + "-1/4", + "0" + ], + [ + "-1/4", + "0", + "1/2", + "1/4", + "0", + "-1/4", + "1/4", + "0" + ], + [ + "0", + "1/4", + "1/4", + "1/2", + "1/4", + "0", + "0", + "-1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "1/2", + "-1/4", + "-1/4", + "0" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "-1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "-1/4", + "0", + "1/2", + "-1/4" + ], + [ + "-1/4", + "0", + "0", + "-1/4", + "0", + "-1/4", + "-1/4", + "1/2" + ] + ], + "terminal_frame": 508 + }, + { + "Q_columns": [ + [ + "1/2", + "0", + "1/2", + "0", + "-1/2", + "0", + "-1/2", + "0" + ], + [ + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "1/2", + "1/2" + ], + [ + "0", + "0", + "1/2", + "-1/2", + "1/2", + "1/2", + "0", + "0" + ], + [ + "0", + "1/2", + "0", + "-1/2", + "0", + "-1/2", + "0", + "-1/2" + ], + [ + "1/2", + "0", + "-1/2", + "0", + "1/2", + "0", + "-1/2", + "0" + ], + [ + "1/2", + "-1/2", + "0", + "0", + "0", + "0", + "1/2", + "-1/2" + ], + [ + "0", + "0", + "1/2", + "1/2", + "1/2", + "-1/2", + "0", + "0" + ], + [ + "0", + "1/2", + "0", + "1/2", + "0", + "1/2", + "0", + "-1/2" + ] + ], + "cold_full_root_labels": [ + 21, + 29, + 97, + 105 + ], + "determinant_unit_over_every_odd_field": true, + "inside_full_root_labels": [ + 19, + 24, + 100, + 111 + ], + "projector": [ + [ + "1/2", + "1/4", + "1/4", + "0", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "1/4", + "1/2", + "0", + "-1/4", + "0", + "-1/4", + "1/4", + "0" + ], + [ + "1/4", + "0", + "1/2", + "-1/4", + "0", + "1/4", + "-1/4", + "0" + ], + [ + "0", + "-1/4", + "-1/4", + "1/2", + "-1/4", + "0", + "0", + "1/4" + ], + [ + "-1/4", + "0", + "0", + "-1/4", + "1/2", + "1/4", + "1/4", + "0" + ], + [ + "0", + "-1/4", + "1/4", + "0", + "1/4", + "1/2", + "0", + "1/4" + ], + [ + "0", + "1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "1/4" + ], + [ + "1/4", + "0", + "0", + "1/4", + "0", + "1/4", + "1/4", + "1/2" + ] + ], + "terminal_frame": 509 + } + ], + "identity": "D_E=diag(Q,Q) D_coordinate4 diag(Q^T,Q^T); Q^T Q=I over Z[1/2], hence over every odd field.", + "no_new_kappa": true, + "scope": "This gives actual coordinate-width4 residual charts. Chronological whole-owner availability, paid ADDRESS adapter execution and source/tape costs are separate obligations.", + "source": { + "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + "status": "PASS_THREE_DYADIC_ORTHOGONAL_RANK4_TERMINAL_CHARTS" +} diff --git a/research/bit-five-rank4-terminals/admission/inputs/bitE8-r865.json.gz b/research/bit-five-rank4-terminals/admission/inputs/bitE8-r865.json.gz new file mode 100644 index 0000000000..8bec1751f7 Binary files /dev/null and b/research/bit-five-rank4-terminals/admission/inputs/bitE8-r865.json.gz differ diff --git a/research/bit-five-rank4-terminals/admission/inputs/r438-t154.json.gz b/research/bit-five-rank4-terminals/admission/inputs/r438-t154.json.gz new file mode 100644 index 0000000000..e12a566658 Binary files /dev/null and b/research/bit-five-rank4-terminals/admission/inputs/r438-t154.json.gz differ diff --git a/research/bit-five-rank4-terminals/admission/provenance/ADMISSION-CHECK.original.json b/research/bit-five-rank4-terminals/admission/provenance/ADMISSION-CHECK.original.json new file mode 100644 index 0000000000..4282d3e2da --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/ADMISSION-CHECK.original.json @@ -0,0 +1,5699 @@ +{ + "authenticated_unique_files": 27, + "controls": [ + "nonorthogonal chart rejected", + "wrong actual terminal span rejected", + "COPY defect survives inverse source shear at 256 bits" + ], + "forward": { + "opcode_counts": { + "0": 2904, + "1": 36005, + "2": 9, + "3": 9 + }, + "positive_envelope_exact_erase_only": 8402567, + "private_bounds_after_each_erase": [ + 290, + 586, + 906, + 1330, + 1892, + 2222, + 2528, + 2994, + 3762 + ], + "unit_defect_all_prefix_bound": 662069, + "unit_defect_persistent_endpoint_bound": 662069, + "unit_defect_private_endpoint_bound": 3762 + }, + "independent_charts": [ + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 17, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "4", + "inverse": [ + [ + "swap", + 5, + 0 + ], + [ + "swap", + 6, + 1 + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 2, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 6, + 7, + "-1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "4", + "missing_final_gate_rejected": true, + "primitive_count": 24, + "primitive_histogram": { + "add": 10, + "scale:-1": 2, + "scale:1/2": 4, + "scale:2": 4, + "swap": 4 + }, + "program": [ + [ + "add", + 6, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 2, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "swap", + 6, + 1 + ], + [ + "swap", + 5, + 0 + ] + ], + "residual_16_coordinate_primitive_count": 100, + "residual_16_coordinate_program": [ + [ + "swap", + 5, + 0 + ], + [ + "swap", + 6, + 1 + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 2, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 6, + 7, + "-1" + ], + [ + "swap", + 13, + 8 + ], + [ + "swap", + 14, + 9 + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 14, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 15, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "swap", + 13, + 12 + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 10, + 15, + "1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 14, + 15, + "-1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 6, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 2, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "swap", + 5, + 4 + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 7, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 6, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "swap", + 6, + 1 + ], + [ + "swap", + 5, + 0 + ], + [ + "add", + 14, + 15, + "1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 10, + 15, + "-1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "swap", + 13, + 12 + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 15, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 14, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "swap", + 14, + 9 + ], + [ + "swap", + 13, + 8 + ] + ], + "residual_max_prefix_denominator": 2, + "residual_max_prefix_row_l1": "4", + "scratch_field_elements": 0 + }, + "frame": 506, + "max_denominator": 2, + "rank": 4 + }, + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 44, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "8", + "inverse": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "-1" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "-1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "8", + "missing_final_gate_rejected": true, + "primitive_count": 70, + "primitive_histogram": { + "add": 40, + "scale:-1": 4, + "scale:1/2": 12, + "scale:2": 12, + "swap": 2 + }, + "program": [ + [ + "add", + 5, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ] + ], + "residual_16_coordinate_primitive_count": 284, + "residual_16_coordinate_program": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "-1" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "-1" + ], + [ + "add", + 8, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 8, + 11, + "-1" + ], + [ + "add", + 9, + 11, + "1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "-1" + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 8, + 12, + "1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "swap", + 14, + 13 + ], + [ + "scale", + 13, + "1/2" + ], + [ + "add", + 8, + 13, + "-1" + ], + [ + "add", + 9, + 13, + "1" + ], + [ + "add", + 12, + 13, + "-1" + ], + [ + "scale", + 14, + "1/2" + ], + [ + "add", + 9, + 14, + "1" + ], + [ + "add", + 10, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 13, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 9, + 15, + "1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 13, + 15, + "-1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 5, + 7, + "1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 13, + 15, + "1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 9, + 15, + "-1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 13, + 14, + "1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "1" + ], + [ + "add", + 9, + 14, + "-1" + ], + [ + "scale", + 14, + "2" + ], + [ + "add", + 12, + 13, + "1" + ], + [ + "add", + 9, + 13, + "-1" + ], + [ + "add", + 8, + 13, + "1" + ], + [ + "scale", + 13, + "2" + ], + [ + "swap", + 14, + 13 + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 8, + 12, + "-1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "1" + ], + [ + "add", + 13, + 11, + "1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "add", + 9, + 11, + "-1" + ], + [ + "add", + 8, + 11, + "1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "1" + ], + [ + "scale", + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ] + ], + "residual_max_prefix_denominator": 4, + "residual_max_prefix_row_l1": "10", + "scratch_field_elements": 0 + }, + "frame": 508, + "max_denominator": 2, + "rank": 4 + }, + { + "address_basis_columns": 16, + "coordinate_program": { + "elementary_factors": 44, + "forward_max_prefix_denominator": 2, + "forward_max_prefix_row_l1": "8", + "inverse": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "scale", + 6, + "-1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "1" + ] + ], + "inverse_max_prefix_denominator": 2, + "inverse_max_prefix_row_l1": "8", + "missing_final_gate_rejected": true, + "primitive_count": 70, + "primitive_histogram": { + "add": 40, + "scale:-1": 4, + "scale:1/2": 12, + "scale:2": 12, + "swap": 2 + }, + "program": [ + [ + "add", + 5, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "scale", + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ] + ], + "residual_16_coordinate_primitive_count": 284, + "residual_16_coordinate_program": [ + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "-1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 3, + "-1" + ], + [ + "add", + 0, + 3, + "1" + ], + [ + "add", + 1, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "1" + ], + [ + "add", + 6, + 3, + "1" + ], + [ + "add", + 7, + 3, + "1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 0, + 4, + "1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 3, + 4, + "1" + ], + [ + "add", + 5, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 6, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "add", + 7, + 4, + "1" + ], + [ + "swap", + 6, + 5 + ], + [ + "scale", + 5, + "1/2" + ], + [ + "add", + 0, + 5, + "-1" + ], + [ + "add", + 1, + 5, + "1" + ], + [ + "add", + 4, + 5, + "-1" + ], + [ + "scale", + 6, + "1/2" + ], + [ + "scale", + 6, + "-1" + ], + [ + "add", + 1, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 3, + 6, + "1" + ], + [ + "add", + 5, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "add", + 7, + 6, + "1" + ], + [ + "scale", + 7, + "1/2" + ], + [ + "scale", + 7, + "-1" + ], + [ + "add", + 1, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "1" + ], + [ + "add", + 5, + 7, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "-1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 11, + "-1" + ], + [ + "add", + 8, + 11, + "1" + ], + [ + "add", + 9, + 11, + "-1" + ], + [ + "add", + 10, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "1" + ], + [ + "add", + 14, + 11, + "1" + ], + [ + "add", + 15, + 11, + "1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 8, + 12, + "1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 11, + 12, + "1" + ], + [ + "add", + 13, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 14, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "add", + 15, + 12, + "1" + ], + [ + "swap", + 14, + 13 + ], + [ + "scale", + 13, + "1/2" + ], + [ + "add", + 8, + 13, + "-1" + ], + [ + "add", + 9, + 13, + "1" + ], + [ + "add", + 12, + 13, + "-1" + ], + [ + "scale", + 14, + "1/2" + ], + [ + "scale", + 14, + "-1" + ], + [ + "add", + 9, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 11, + 14, + "1" + ], + [ + "add", + 13, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "add", + 15, + 14, + "1" + ], + [ + "scale", + 15, + "1/2" + ], + [ + "scale", + 15, + "-1" + ], + [ + "add", + 9, + 15, + "-1" + ], + [ + "add", + 11, + 15, + "1" + ], + [ + "add", + 13, + 15, + "1" + ], + [ + "swap", + 0, + 8 + ], + [ + "swap", + 1, + 9 + ], + [ + "swap", + 2, + 10 + ], + [ + "swap", + 3, + 11 + ], + [ + "add", + 5, + 7, + "-1" + ], + [ + "add", + 3, + 7, + "-1" + ], + [ + "add", + 1, + 7, + "1" + ], + [ + "scale", + 7, + "-1" + ], + [ + "scale", + 7, + "2" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 7, + 6, + "-1" + ], + [ + "add", + 5, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 3, + 6, + "-1" + ], + [ + "add", + 2, + 6, + "1" + ], + [ + "add", + 1, + 6, + "1" + ], + [ + "scale", + 6, + "-1" + ], + [ + "scale", + 6, + "2" + ], + [ + "add", + 4, + 5, + "1" + ], + [ + "add", + 1, + 5, + "-1" + ], + [ + "add", + 0, + 5, + "1" + ], + [ + "scale", + 5, + "2" + ], + [ + "swap", + 6, + 5 + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 7, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 6, + 4, + "-1" + ], + [ + "add", + 5, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 3, + 4, + "-1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 1, + 4, + "1" + ], + [ + "add", + 0, + 4, + "-1" + ], + [ + "scale", + 4, + "-1" + ], + [ + "add", + 7, + 3, + "-1" + ], + [ + "add", + 6, + 3, + "-1" + ], + [ + "add", + 5, + 3, + "-1" + ], + [ + "add", + 2, + 3, + "1" + ], + [ + "add", + 1, + 3, + "1" + ], + [ + "add", + 0, + 3, + "-1" + ], + [ + "scale", + 3, + "-1" + ], + [ + "swap", + 4, + 3 + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 5, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 4, + 2, + "1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "add", + 3, + 2, + "-1" + ], + [ + "scale", + 2, + "2" + ], + [ + "scale", + 2, + "1/2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 7, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 6, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 4, + 1, + "1" + ], + [ + "scale", + 1, + "2" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "add", + 2, + 1, + "-1" + ], + [ + "scale", + 1, + "2" + ], + [ + "add", + 0, + 1, + "1" + ], + [ + "scale", + 1, + "1/2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 6, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 4, + 0, + "-1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 2, + 0, + "1" + ], + [ + "scale", + 0, + "2" + ], + [ + "scale", + 0, + "1/2" + ], + [ + "add", + 13, + 15, + "-1" + ], + [ + "add", + 11, + 15, + "-1" + ], + [ + "add", + 9, + 15, + "1" + ], + [ + "scale", + 15, + "-1" + ], + [ + "scale", + 15, + "2" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 15, + 14, + "-1" + ], + [ + "add", + 13, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 11, + 14, + "-1" + ], + [ + "add", + 10, + 14, + "1" + ], + [ + "add", + 9, + 14, + "1" + ], + [ + "scale", + 14, + "-1" + ], + [ + "scale", + 14, + "2" + ], + [ + "add", + 12, + 13, + "1" + ], + [ + "add", + 9, + 13, + "-1" + ], + [ + "add", + 8, + 13, + "1" + ], + [ + "scale", + 13, + "2" + ], + [ + "swap", + 14, + 13 + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 15, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 14, + 12, + "-1" + ], + [ + "add", + 13, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 11, + 12, + "-1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 9, + 12, + "1" + ], + [ + "add", + 8, + 12, + "-1" + ], + [ + "scale", + 12, + "-1" + ], + [ + "add", + 15, + 11, + "-1" + ], + [ + "add", + 14, + 11, + "-1" + ], + [ + "add", + 13, + 11, + "-1" + ], + [ + "add", + 10, + 11, + "1" + ], + [ + "add", + 9, + 11, + "1" + ], + [ + "add", + 8, + 11, + "-1" + ], + [ + "scale", + 11, + "-1" + ], + [ + "swap", + 12, + 11 + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 13, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 12, + 10, + "1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "add", + 11, + 10, + "-1" + ], + [ + "scale", + 10, + "2" + ], + [ + "scale", + 10, + "1/2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 15, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 14, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 12, + 9, + "1" + ], + [ + "scale", + 9, + "2" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "add", + 10, + 9, + "-1" + ], + [ + "scale", + 9, + "2" + ], + [ + "add", + 8, + 9, + "1" + ], + [ + "scale", + 9, + "1/2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 14, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 12, + 8, + "-1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ], + [ + "add", + 10, + 8, + "1" + ], + [ + "scale", + 8, + "2" + ], + [ + "scale", + 8, + "1/2" + ] + ], + "residual_max_prefix_denominator": 4, + "residual_max_prefix_row_l1": "10", + "scratch_field_elements": 0 + }, + "frame": 509, + "max_denominator": 2, + "rank": 4 + } + ], + "inverse": { + "opcode_counts": { + "0": 2904, + "1": 36005, + "2": 9, + "3": 9 + }, + "positive_envelope_exact_erase_only": 630744, + "private_bounds_after_each_erase": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36 + ], + "unit_defect_all_prefix_bound": 47917, + "unit_defect_persistent_endpoint_bound": 47917, + "unit_defect_private_endpoint_bound": 36 + }, + "limits": "No exact rounded-child cleanup, chronological owners, paid native routes, all-size compiler, tape or outer admission.", + "no_new_kappa": true, + "precision": { + "conditional_depth_two": { + "charged_bits": 512, + "child_count_max": 1048575, + "extra_invoice_max": "1645504557321206042154969182557350504982735865633579863348609023", + "scope": "Sufficient conditional arithmetic only; no compiler or owner invoice is supplied.", + "upper_bound_bits": 463 + }, + "five_stage_bits": 114, + "five_stage_integer_bound": "15105050522746917552142185212669952", + "five_stage_multiple_of_64": 128, + "nine_stage_bits": 211, + "nine_stage_integer_bound": "1737850264432662463887984248694818736482648196425093483769888768", + "nine_stage_multiple_of_64": 256 + }, + "script_sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194", + "source_sha256": { + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe", + "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "research/pr589-five-helper-hosting/PROOF.md": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + "status": "PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER", + "word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a" +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/FROZEN-MANIFEST.original.json b/research/bit-five-rank4-terminals/admission/provenance/FROZEN-MANIFEST.original.json new file mode 100644 index 0000000000..7f45ffc27e --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/FROZEN-MANIFEST.original.json @@ -0,0 +1,149 @@ +{ + "continuation": "Use a new owned directory. Never run write-mode producers in this frozen directory. Parent audit files are snapshot pins owned and separately frozen by parent.", + "frozen_at_utc": "2026-10-19T08:11:56.552443+00:00", + "generic_proof_source": [ + { + "bytes": 12438, + "path": "/Users/ross/git/math/integer-mult-bounds/research/pr589-five-helper-hosting/PROOF.md", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + } + ], + "no_new_kappa": true, + "owned_directory": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries", + "owned_files": [ + { + "bytes": 105274, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/A-TERMINAL-CONES-WORD.json.gz", + "sha256": "29e2a3bba12ec1342741b7c74df0c4ccb4ce771c32b76d13420d0d6ba8460c58" + }, + { + "bytes": 7692, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/A-TERMINAL-CONES.json", + "sha256": "1d92c8eadeba566b0e54523e26a8944f93e6f972d911f994fe4ce4579e30e200" + }, + { + "bytes": 105171, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FIVE-TERMINALS-WORD.json.gz", + "sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c" + }, + { + "bytes": 9579, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FIVE-TERMINALS.json", + "sha256": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58" + }, + { + "bytes": 10529, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/HANDOFF.md", + "sha256": "39660a7edd09e8d638efff6d0beccdb3ac2e5e964b89ed5c3faf29a94b3da2ec" + }, + { + "bytes": 2232, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/PAIRED-TERMINAL-PROBE.json", + "sha256": "3333d562ec6c35411b6bb3891f10b3eed263e115df66d155bcd096b6675cb4e6" + }, + { + "bytes": 8718, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/TERMINAL-CHARTS.json", + "sha256": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17" + }, + { + "bytes": 9834, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/a_terminal_cones.py", + "sha256": "05543e41aca4eddef96399a68ee863a969a925931e64f76ae061bf1b1ac61ca0" + }, + { + "bytes": 2315, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/boundary_model.py", + "sha256": "0f9c8ed604980a8df04a53d4fbde1df43f198ca2230bff3e2ba758c59d1e78cf" + }, + { + "bytes": 9356, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/five_terminals.py", + "sha256": "51ba9eaa47e5c5eeda085f16d02996e55f3ec0dfa60c5393080e2c865c62473b" + }, + { + "bytes": 10115, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/paired_terminal_probe.py", + "sha256": "9a12e29c86c3bf95e07996287cae54ea82b50592c4a84991efab89f73b0b10b5" + }, + { + "bytes": 2973, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/terminal_charts.py", + "sha256": "97168bdd294f12dcb5dd569226546320c606ec48230bd88078cd372142f905af" + } + ], + "parent_audit_checkpoint_snapshots": [ + { + "bytes": 8521, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/verify_word.py", + "sha256": "64f62ecdbc77518dd7705087f0aaa852412d607cf197ee3fa9b0a2a96683750b" + }, + { + "bytes": 2078, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/INDEPENDENT-FIVE-TERMINALS.json", + "sha256": "628139c3ab4d55ee2cafec1ba7353ddc78c5fec3f741ebf59e5c998bc94f948a" + }, + { + "bytes": 5818, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/OPERATOR-BOUNDARY.md", + "sha256": "b268114ee08a3cb0c6fb18928361528cc7385bd5f89b90bf247b2739a513dbac" + } + ], + "python_version": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "read_only_runtime_data": [ + { + "bytes": 42305, + "path": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "bytes": 33865, + "path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + } + ], + "read_only_runtime_modules": [ + { + "bytes": 13065, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/old_kernel_boost.py", + "sha256": "71070cceb72b089d745f080e642dce26c1404508411288265b6bf3f4a004ea20" + }, + { + "bytes": 15496, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/global_kernel_boost.py", + "sha256": "22773bd9f955130ca3c1fe2fa2c047ee7d831759df08567e2a6c987349b18272" + }, + { + "bytes": 7405, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/helper_tail_retime.py", + "sha256": "815f20725a20ea05064695064f4b34c4e4e6e6feaa7e42dfceb1e7031d4fed1d" + }, + { + "bytes": 12976, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/physical_code.py", + "sha256": "1188b1884a1d8b6873ea118d39f17f939f9e78ca778fa2a821d8a8fe2fd3d043" + }, + { + "bytes": 7569, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/cold_cosets.py", + "sha256": "b266d71551ea82a767029727bf2ce6b594d0f5b4d49719a146abbe6348a7d050" + }, + { + "bytes": 10050, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/kernel_entrances.py", + "sha256": "921f18dc02df3a799a4fae60aa861b1f7e908957b01b81dd395f5cd8dac222cc" + } + ], + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "status": "FROZEN_HANDOFF_DO_NOT_MUTATE", + "validation": { + "A_terminal_cones_independent": false, + "A_terminal_cones_normal": true, + "A_terminal_cones_optimized": false, + "five_terminal_normal": true, + "five_terminal_optimized": true, + "independent_parent_word_normal_and_optimized_reported_and_saved": true, + "terminal_charts_normal": true, + "terminal_charts_optimized": true + } +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/OWNERSHIP.original.json b/research/bit-five-rank4-terminals/admission/provenance/OWNERSHIP.original.json new file mode 100644 index 0000000000..0308c61201 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/OWNERSHIP.original.json @@ -0,0 +1,23 @@ +{ + "status": "ACCEPTED_OWNERSHIP", + "accepted_at_utc": "2026-10-19T08:13:51.114018+00:00", + "thread_id": "01a15338-c1ea-73e1-9773-2b43ef4058c2", + "run_directory": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z", + "input_manifest_path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/BIT-TRANSFER-MANIFEST.json", + "input_manifest_sha256": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb", + "frozen_manifest_path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FROZEN-MANIFEST.json", + "frozen_manifest_sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7", + "decompressed_word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a", + "verified_entries": 51, + "frozen_source_paths": [ + "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries", + "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit" + ], + "scope": [ + "five-helper BIT feasibility and fully charged compatible joint moment assessment", + "unpublished findings inventory and local reviewable packaging" + ], + "publication_policy": "local only; no push, PR, workflow dispatch, or scientific post without direct user approval", + "parent_clock_untouched": true, + "no_new_kappa": true +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/PR540-SOURCE-PINS.original.json b/research/bit-five-rank4-terminals/admission/provenance/PR540-SOURCE-PINS.original.json new file mode 100644 index 0000000000..328927e679 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/PR540-SOURCE-PINS.original.json @@ -0,0 +1,18 @@ +{ + "source_repository": "CrocSwap/integer-mult-bounds", + "files": [ + { + "commit": "acc1917034d10f464271ab115fda314fd4eee7a3", + "path": "research/lean-multi-host-source/FramedReplay.lean", + "sha256": "d051b68253e9ffea22d09c644796ab64dd66ae4393bd592dc5c0aa6e80bbb122", + "local_path": "source-snapshots/FramedReplay.lean" + }, + { + "commit": "acc1917034d10f464271ab115fda314fd4eee7a3", + "path": "research/lean-multi-host-source/OwnerTransport.lean", + "sha256": "cdc9374538c716c85a3dfed949395a92d738f2bf6cba108d1a9f0ea2270ffc5c", + "local_path": "source-snapshots/OwnerTransport.lean" + } + ], + "scope": "Read-only source snapshots; Lean kernel not executed." +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-AUTHENTICATION.json b/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-AUTHENTICATION.json new file mode 100644 index 0000000000..e55d94f1ca --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-AUTHENTICATION.json @@ -0,0 +1,87 @@ +{ + "authenticated_unique_transfer_files": 27, + "copied_files": [ + { + "local_path": "inputs/FIVE-TERMINALS-WORD.json.gz", + "sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FIVE-TERMINALS-WORD.json.gz" + }, + { + "local_path": "inputs/TERMINAL-CHARTS.json", + "sha256": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/TERMINAL-CHARTS.json" + }, + { + "local_path": "inputs/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022", + "source": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz" + }, + { + "local_path": "inputs/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "source": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz" + }, + { + "local_path": "provenance/verify_admission.original.py.txt", + "sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194", + "source": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/admission/verify_admission.py" + }, + { + "local_path": "provenance/ADMISSION-CHECK.original.json", + "sha256": "914c4deecd9fa972f396e942c6d6bfbf13e6ef58f6a54ad8e8d4a125b0652519", + "source": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/admission/ADMISSION-CHECK.json" + }, + { + "local_path": "provenance/OWNERSHIP.original.json", + "sha256": "ed5b67369aa95c80a5a4a958dc030cc216954d6a8b23d01252d2c84647758fbc", + "source": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/OWNERSHIP.json" + }, + { + "local_path": "provenance/TRANSFER-MANIFEST.original.json", + "sha256": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/BIT-TRANSFER-MANIFEST.json" + }, + { + "local_path": "provenance/FROZEN-MANIFEST.original.json", + "sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7", + "source": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FROZEN-MANIFEST.json" + }, + { + "local_path": "provenance/PR540-SOURCE-PINS.original.json", + "sha256": "2963bc4edd609c542bad37f6021f251dbaa254495948d715dc3c704c8058b31d", + "source": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/admission/PR540-SOURCE-PINS.json" + }, + { + "local_path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp", + "sha256": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "source": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp" + }, + { + "local_path": "source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp", + "sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "source": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp" + }, + { + "local_path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py", + "sha256": "4bf6768224a3fac81ccda26df24f3763f9a4fbc35ad62bef2888595cdae519fe", + "source": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py" + }, + { + "local_path": "source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "source": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py" + }, + { + "local_path": "source-context/research/pr589-five-helper-hosting/PROOF.md", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647", + "source": "/Users/ross/git/math/integer-mult-bounds/research/pr589-five-helper-hosting/PROOF.md" + } + ], + "decompressed_word_sha256": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a", + "frozen_manifest_sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7", + "input_manifest_sha256": "7e13112436a72e1f646c9a3fdf417dbab8522730d720709b7059fd85d4c9f6eb", + "original_checker_sha256": "c5b30e5a3422a61ba560459bf39f27d825d83154f95593672785b2f7ceaa5194", + "original_scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "Integrity linkage to authenticated local transfer; not a digital signature or proof of mathematical truth. Original paths are historical provenance, never runtime dependencies.", + "status": "AUTHENTICATED_BEFORE_PORTABLE_COPY" +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-MANIFEST.original.json b/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-MANIFEST.original.json new file mode 100644 index 0000000000..8981491022 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/TRANSFER-MANIFEST.original.json @@ -0,0 +1,148 @@ +{ + "checked_at_utc": "2026-10-19T08:13:04.721043+00:00", + "files": [ + { + "bytes": 105274, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/A-TERMINAL-CONES-WORD.json.gz", + "sha256": "29e2a3bba12ec1342741b7c74df0c4ccb4ce771c32b76d13420d0d6ba8460c58" + }, + { + "bytes": 7692, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/A-TERMINAL-CONES.json", + "sha256": "1d92c8eadeba566b0e54523e26a8944f93e6f972d911f994fe4ce4579e30e200" + }, + { + "bytes": 105171, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FIVE-TERMINALS-WORD.json.gz", + "sha256": "c46ccd7d3eedabc6a7efbb1a91ec13f2928bad8ee0bac57c6e593a092d13d96c" + }, + { + "bytes": 9579, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FIVE-TERMINALS.json", + "sha256": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58" + }, + { + "bytes": 10529, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/HANDOFF.md", + "sha256": "39660a7edd09e8d638efff6d0beccdb3ac2e5e964b89ed5c3faf29a94b3da2ec" + }, + { + "bytes": 2232, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/PAIRED-TERMINAL-PROBE.json", + "sha256": "3333d562ec6c35411b6bb3891f10b3eed263e115df66d155bcd096b6675cb4e6" + }, + { + "bytes": 8718, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/TERMINAL-CHARTS.json", + "sha256": "489216ea25f47f061675ab7b7e4a17289a531bce6fe77cca166a13265bfcbb17" + }, + { + "bytes": 9834, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/a_terminal_cones.py", + "sha256": "05543e41aca4eddef96399a68ee863a969a925931e64f76ae061bf1b1ac61ca0" + }, + { + "bytes": 2315, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/boundary_model.py", + "sha256": "0f9c8ed604980a8df04a53d4fbde1df43f198ca2230bff3e2ba758c59d1e78cf" + }, + { + "bytes": 9356, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/five_terminals.py", + "sha256": "51ba9eaa47e5c5eeda085f16d02996e55f3ec0dfa60c5393080e2c865c62473b" + }, + { + "bytes": 10115, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/paired_terminal_probe.py", + "sha256": "9a12e29c86c3bf95e07996287cae54ea82b50592c4a84991efab89f73b0b10b5" + }, + { + "bytes": 2973, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/terminal_charts.py", + "sha256": "97168bdd294f12dcb5dd569226546320c606ec48230bd88078cd372142f905af" + }, + { + "bytes": 8521, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/verify_word.py", + "sha256": "64f62ecdbc77518dd7705087f0aaa852412d607cf197ee3fa9b0a2a96683750b" + }, + { + "bytes": 2078, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/INDEPENDENT-FIVE-TERMINALS.json", + "sha256": "628139c3ab4d55ee2cafec1ba7353ddc78c5fec3f741ebf59e5c998bc94f948a" + }, + { + "bytes": 5818, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit/OPERATOR-BOUNDARY.md", + "sha256": "b268114ee08a3cb0c6fb18928361528cc7385bd5f89b90bf247b2739a513dbac" + }, + { + "bytes": 42305, + "path": "/Users/ross/git/math/integer-mult-bounds/research/bit-r438-transport-rehost/words/r438-t154.json.gz", + "sha256": "a353999bceac4ac957f540adfd3e5f8768297138b27132eeb83332e2ea4b1022" + }, + { + "bytes": 33865, + "path": "/Users/ross/git/math/integer-mult-bounds/research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz", + "sha256": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55" + }, + { + "bytes": 13065, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/old_kernel_boost.py", + "sha256": "71070cceb72b089d745f080e642dce26c1404508411288265b6bf3f4a004ea20" + }, + { + "bytes": 15496, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/global_kernel_boost.py", + "sha256": "22773bd9f955130ca3c1fe2fa2c047ee7d831759df08567e2a6c987349b18272" + }, + { + "bytes": 7405, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/helper_tail_retime.py", + "sha256": "815f20725a20ea05064695064f4b34c4e4e6e6feaa7e42dfceb1e7031d4fed1d" + }, + { + "bytes": 12976, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/physical_code.py", + "sha256": "1188b1884a1d8b6873ea118d39f17f939f9e78ca778fa2a821d8a8fe2fd3d043" + }, + { + "bytes": 7569, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/cold_cosets.py", + "sha256": "b266d71551ea82a767029727bf2ce6b594d0f5b4d49719a146abbe6348a7d050" + }, + { + "bytes": 10050, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/bit-native-caller/kernel_entrances.py", + "sha256": "921f18dc02df3a799a4fae60aa861b1f7e908957b01b81dd395f5cd8dac222cc" + }, + { + "bytes": 12438, + "path": "/Users/ross/git/math/integer-mult-bounds/research/pr589-five-helper-hosting/PROOF.md", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "bytes": 7198, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FROZEN-MANIFEST.json", + "sha256": "362ad0246d221584b35bfad2e850ed20b344a9f96a706c9988e3b3d2b7ff85a7" + }, + { + "bytes": 87, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries/FROZEN-MANIFEST.sha256", + "sha256": "7af1b111723c19e7c6b7910c8cde2379db97caa4a48fa3f0157ef7dfb1993953" + }, + { + "bytes": 7223, + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/BIT-TRANSFER.md", + "sha256": "664b0d69489e47c5009f31c7d4e044095d5e06def825b2aa83501a276272f31f" + } + ], + "frozen_directories": [ + "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/bit-boundaries", + "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/root-bit-audit" + ], + "no_new_kappa": true, + "policy": "Neither parent nor receiving task modifies frozen inputs. Receiving task works in own directory. No push or PR without direct user approval.", + "receiving_directory": "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z", + "status": "FROZEN_INPUTS_VERIFIED_AWAITING_NEW_THREAD_OWNERSHIP" +} diff --git a/research/bit-five-rank4-terminals/admission/provenance/verify_admission.original.py.txt b/research/bit-five-rank4-terminals/admission/provenance/verify_admission.original.py.txt new file mode 100644 index 0000000000..352bed3005 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/provenance/verify_admission.original.py.txt @@ -0,0 +1,342 @@ +#!/usr/bin/env python3 +"""Independent finite chart and coefficient audit; no supplier admission. + +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +Imports only the standard library; writes only its own requested receipt. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json + +HERE = Path(__file__).resolve().parent +RUN = HERE.parent +INPUT = RUN.parent / 'kappa-four-coordinate-20261019T0717Z' +REPO = Path('/Users/ross/git/math/integer-mult-bounds') + + +def need(p, msg): + if not p: + raise ValueError(msg) + + +def sha(p): + return sha256(Path(p).read_bytes()).hexdigest() + + +def matrix_product(a, b): + return [[sum((x * y for x, y in zip(row, col)), Q(0)) + for col in zip(*b)] for row in a] + + +def identity(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def transpose(a): + return [list(x) for x in zip(*a)] + + +def rank(rows): + a = deepcopy(rows) + k = 0 + for j in range(len(a[0]) if a else 0): + p = next((i for i in range(k, len(a)) if a[i][j]), None) + if p is None: + continue + a[k], a[p] = a[p], a[k] + d = a[k][j] + a[k] = [x / d for x in a[k]] + for i in range(len(a)): + if i != k: + d = a[i][j] + a[i] = [x - d*y for x, y in zip(a[i], a[k])] + k += 1 + return k + + +def partial_swap(p): + n = len(p) + return [[(Q(i % n == j % n) - p[i % n][j % n]) + if i // n == j // n else p[i % n][j % n] + for j in range(2*n)] for i in range(2*n)] + + +def double(a): + return [[a[i % 8][j % 8] if i // 8 == j // 8 else Q(0) + for j in range(16)] for i in range(16)] + + +def apply_gate(a, gate): + op, i, j = gate[:3] + if op == 'swap': + a[i], a[j] = a[j], a[i] + elif op == 'scale': + a[i] = [Q(j)*x for x in a[i]] + elif op == 'add': + a[i] = [x+Q(gate[3])*y for x, y in zip(a[i], a[j])] + else: + raise ValueError('unknown chart gate') + + +def invert_gate(g): + if g[0] == 'swap': + return list(g) + if g[0] == 'scale': + return [g[0], g[1], str(1/Q(g[2]))] + return [g[0], g[1], g[2], str(-Q(g[3]))] + + +def chart_program(chart): + """In-place Q via exact unit ADD, NEGATE, DOUBLE/HALVE, SWAP. + + Reduction is nomination only; all emitted programs are independently + replayed as rational matrices, including every prefix denominator. + """ + a = deepcopy(chart) + reduction = [] + for j in range(8): + i = next(i for i in range(j, 8) if a[i][j]) + if i != j: + g = ['swap', i, j]; apply_gate(a, g); reduction.append(g) + if a[j][j] != 1: + g = ['scale', j, str(1/a[j][j])]; apply_gate(a, g); reduction.append(g) + for i in range(8): + if i != j and a[i][j]: + g = ['add', i, j, str(-a[i][j])]; apply_gate(a, g); reduction.append(g) + need(a == identity(8), 'chart reduction reaches identity') + factored = [invert_gate(g) for g in reversed(reduction)] + program = [] + for g in factored: + op, i, j = g[:3] + if op == 'swap': + program.append(g) + elif op == 'scale': + c = Q(j) + need(abs(c) in (Q(1), Q(2), Q(1, 2)), 'dyadic unit scale') + if c < 0: + program.append(['scale', i, '-1']) + if abs(c) != 1: + program.append(['scale', i, str(abs(c))]) + else: + c = Q(g[3]) + need(abs(c) in (Q(1), Q(2), Q(1, 2)), 'allowed dyadic shear') + unit = '1' if c > 0 else '-1' + if abs(c) == Q(1, 2): + program += [['scale', j, '1/2'], ['add', i, j, unit], ['scale', j, '2']] + else: + program += [['add', i, j, unit]] * int(abs(c)) + inverse = [invert_gate(g) for g in reversed(program)] + def replay(gs): + matrix = identity(8) + max_norm = Q(1); max_denominator = 1 + for g in gs: + apply_gate(matrix, g) + max_norm = max(max_norm, max(sum(map(abs, row)) for row in matrix)) + max_denominator = max(max_denominator, max(x.denominator for row in matrix for x in row)) + return matrix, str(max_norm), max_denominator + m, norm, den = replay(program) + mi, inorm, iden = replay(inverse) + need(m == chart and mi == transpose(chart), 'exact forward/inverse matrix') + need(matrix_product(mi, m) == identity(8), 'all-input inverse restoration') + need(replay(program[:-1])[0] != chart, 'missing-final-gate control') + def shifted(g, k): + out = list(g); out[1] += k + if out[0] in ('add', 'swap'): + out[2] += k + return out + residual = ([shifted(g, k) for k in (0, 8) for g in inverse] + + [['swap', i, i+8] for i in range(4)] + + [shifted(g, k) for k in (0, 8) for g in program]) + state = identity(16); rnorm = Q(1); rden = 1 + for g in residual: + apply_gate(state, g) + rnorm = max(rnorm, max(sum(map(abs, row)) for row in state)) + rden = max(rden, max(x.denominator for row in state for x in row)) + p = matrix_product([r[:4] for r in chart], transpose([r[:4] for r in chart])) + need(state == partial_swap(p), 'literal residual coordinate program') + invresidual = [invert_gate(g) for g in reversed(residual)] + for g in invresidual: + apply_gate(state, g) + need(state == identity(16), 'literal residual inverse restoration') + return {'elementary_factors': len(factored), 'program': program, 'inverse': inverse, + 'primitive_count': len(program), 'primitive_histogram': dict(Counter( + g[0] + (':'+g[2] if g[0] == 'scale' else '') for g in program)), + 'forward_max_prefix_row_l1': norm, 'inverse_max_prefix_row_l1': inorm, + 'forward_max_prefix_denominator': den, 'inverse_max_prefix_denominator': iden, + 'residual_16_coordinate_program': residual, + 'residual_16_coordinate_primitive_count': len(residual), + 'residual_max_prefix_row_l1': str(rnorm), 'residual_max_prefix_denominator': rden, + 'scratch_field_elements': 0, 'missing_final_gate_rejected': True} + + +def verify_chart(c, raw, full): + cols = [[Q(x) for x in r] for r in c['Q_columns']] + need(len(cols) == 8 and all(len(r) == 8 for r in cols), 'chart size') + need(matrix_product(cols, transpose(cols)) == identity(8), 'orthonormal columns') + labels = c['inside_full_root_labels'] + c['cold_full_root_labels'] + need(cols == [[Q(x, 2) for x in full['lines'][j]] for j in labels], 'root labels') + need(all(x.denominator in (1, 2) for r in cols for x in r), 'half integral chart') + e = [[Q(x) for x in raw['lines'][j]] for j in raw['frames'][c['terminal_frame']]] + need(rank(e) == 4 and rank(e + cols[:4]) == 4, 'actual rank four terminal span') + p = matrix_product(transpose(cols[:4]), cols[:4]) + need(p == [[Q(x) for x in r] for r in c['projector']], 'saved projector') + pc = [[Q(i == j and i < 4) for j in range(8)] for i in range(8)] + chart = transpose(cols) + need(matrix_product(matrix_product(double(chart), partial_swap(pc)), double(cols)) + == partial_swap(p), 'all sixteen address basis columns') + return {'frame': c['terminal_frame'], 'rank': 4, + 'address_basis_columns': 16, 'max_denominator': 2, + 'coordinate_program': chart_program(chart)} + + +def magnitude_and_defects(records, inverse=False): + """Exact-integer reset bound plus extended-shear no-reset defect bound. + + Scalar ADD is exact. MOVE, COPY and ERASE may each inject an arbitrary + additive defect of norm at most one in the single destination row. + COPY/ERASE are extended to +/- source shears, not zero assignments. + """ + mag = [1]*660 + [0] + error = [0]*661 + max_mag = 1 + max_error = 0 + opened = None + erased = [] + count = Counter() + for z in reversed(records) if inverse else records: + op, d, s, c, f, phase = z + count[str(op)] += 1 + if op == 0: + error[d] += 1 + elif op == 1: + mag[d] += abs(c)*mag[s] + error[d] += abs(c)*error[s] + elif op == (3 if inverse else 2): + need(opened is None, 'fresh episode') + opened = d + mag[660] = mag[d] + error[660] += error[d] + 1 + else: + need(op == (2 if inverse else 3) and opened == d, 'matching episode') + opened = None + mag[660] = 0 + error[660] += error[d] + 1 + erased.append(error[660]) + max_mag = max(max_mag, max(mag)) + max_error = max(max_error, max(error)) + need(opened is None, 'all episodes close') + return {'positive_envelope_exact_erase_only': max_mag, + 'unit_defect_all_prefix_bound': max_error, + 'unit_defect_persistent_endpoint_bound': max(error[:660]), + 'unit_defect_private_endpoint_bound': error[660], + 'private_bounds_after_each_erase': erased, 'opcode_counts': dict(count)} + + +def main(): + p = argparse.ArgumentParser() + p.add_argument('--write', action='store_true') + args = p.parse_args() + own = json.loads((RUN/'OWNERSHIP.json').read_text()) + for k in ('input_manifest', 'frozen_manifest'): + need(sha(own[k+'_path']) == own[k+'_sha256'], 'ownership manifest authentication') + seen = {} + def authenticate(x): + if isinstance(x, list): + for y in x: + authenticate(y) + elif isinstance(x, dict): + if 'path' in x and 'sha256' in x: + need(sha(x['path']) == x['sha256'], 'pinned file changed: '+x['path']) + seen[x['path']] = x['sha256'] + for y in x.values(): + if isinstance(y, (dict, list)): + authenticate(y) + authenticate(json.loads(Path(own['input_manifest_path']).read_text())) + authenticate(json.loads(Path(own['frozen_manifest_path']).read_text())) + wordfile = INPUT/'bit-boundaries/FIVE-TERMINALS-WORD.json.gz' + blob = gzip.decompress(wordfile.read_bytes()) + need(sha256(blob).hexdigest() == own['decompressed_word_sha256'], 'literal word hash') + word = json.loads(blob) + rawpath = REPO/'research/bit-r438-transport-rehost/words/r438-t154.json.gz' + fullpath = REPO/'research/e8-bit-carrier-skeleton/data/bit/bitE8-r865.json.gz' + raw = json.loads(gzip.decompress(rawpath.read_bytes())) + full = json.loads(gzip.decompress(fullpath.read_bytes())) + charts = json.loads((INPUT/'bit-boundaries/TERMINAL-CHARTS.json').read_text())['charts'] + need([x['terminal_frame'] for x in charts] == [506, 508, 509], 'three exact frames') + checked = [verify_chart(c, raw, full) for c in charts] + controls = [] + bad = deepcopy(charts[0]); bad['Q_columns'][0][0] = '1' + try: + verify_chart(bad, raw, full) + except ValueError: + controls.append('nonorthogonal chart rejected') + else: + raise ValueError('chart mutation accepted') + bad = deepcopy(charts[0]); bad['terminal_frame'] = 0 + try: + verify_chart(bad, raw, full) + except ValueError: + controls.append('wrong actual terminal span rejected') + else: + raise ValueError('frame mutation accepted') + forward = magnitude_and_defects(word['records']) + reverse = magnitude_and_defects(word['records'], True) + F = forward['positive_envelope_exact_erase_only'] + R = reverse['positive_envelope_exact_erase_only'] + need((F, R) == (8402567, 630744), 'both positive bounds') + p5 = 64*F**3*R**2 + p9 = 2**18*F**5*R**4 + need((p5.bit_length(), p9.bit_length()) == (114, 211), 'exact precision thresholds') + # Exact signed scalar minimal witness: a nonzero COPY defect survives + # its exact inverse source shear, irrespective of how small it is. + epsilon = Q(1, 2**256) + source = Q(0); temporary = source + epsilon + temporary -= source + need(temporary == epsilon and temporary != 0, 'positive finite precision does not imply exact ERASE') + controls.append('COPY defect survives inverse source shear at 256 bits') + # Sufficient conditional finite-invoice budget for depth two. + # coefficient = prefix + B. This is NOT a bound on an unbuilt compiler. + Bcap = 2**210 - 1 + Ecap = 2**20 - 1 + two_cap = (p9+Bcap+1)**2*(Ecap+1)**2 + need(two_cap < 2**512, 'conditional two-level invoice fits inherited 512 bits') + sources = [ + 'research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp', + 'research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp', + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py', + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py', + 'research/pr589-five-helper-hosting/PROOF.md', + ] + result = {'status': 'PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER', + 'no_new_kappa': True, 'authenticated_unique_files': len(seen), + 'word_sha256': own['decompressed_word_sha256'], + 'independent_charts': checked, 'forward': forward, 'inverse': reverse, + 'precision': {'five_stage_integer_bound': str(p5), 'five_stage_bits': 114, + 'five_stage_multiple_of_64': 128, 'nine_stage_integer_bound': str(p9), + 'nine_stage_bits': 211, 'nine_stage_multiple_of_64': 256, + 'conditional_depth_two': {'extra_invoice_max': str(Bcap), + 'child_count_max': Ecap, 'upper_bound_bits': two_cap.bit_length(), + 'charged_bits': 512, + 'scope': 'Sufficient conditional arithmetic only; no compiler or owner invoice is supplied.'}}, + 'controls': controls, + 'source_sha256': {x: sha(REPO/x) for x in sources}, + 'script_sha256': sha(__file__), + 'limits': 'No exact rounded-child cleanup, chronological owners, paid native routes, all-size compiler, tape or outer admission.'} + outfile = HERE/'ADMISSION-CHECK.json' + if args.write: + outfile.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(outfile.read_text()) == result, 'receipt matches independent recomputation') + print(result['status']) + print(json.dumps({'charts': len(checked), 'guards': [114,211], + 'defect_bounds': [forward['unit_defect_all_prefix_bound'],reverse['unit_defect_all_prefix_bound']], + 'conditional_two_level_bits': two_cap.bit_length()})) + + +if __name__ == '__main__': + main() diff --git a/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp b/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp new file mode 100644 index 0000000000..00c5a3a5d8 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp @@ -0,0 +1,48 @@ +// Generalization (Dylan Crow, with Anthropic Claude assistance): the copied-centre count is the macro NCOPY, defaulting to +// HDIM, so the unmodified PR #346/#352 build (no -DNCOPY) is exactly the original checker. The E8 bit word has 9 +// retained totals at h = 8 (-DNCOPY=9). +#ifndef NCOPY +#define NCOPY HDIM +#endif +#include "json.hpp" +#include +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=4*v+r,temp=global; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.srca((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +if(stage==1||stage==2||stage==4){int b=stage==1?0:stage==2?1:2;for(auto q:bridges[b])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<4;bank+=2)for(int i=0;i()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=2*KPAIRS*v+r,temp=global;const int S=2*KPAIRS+1; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.src>active;std::vectorbackward;std::vector>>after(S); +auto X=[](int p){return 2*(p-1);};auto Y=[](int p){return 2*(p-1)+1;}; +for(int t=0;t=3&&t%2==1);backward.push_back(b);active.push_back(b?std::array{Y(p),X(p)}:std::array{X(p),Y(p)});} +for(int q=2;q<=KPAIRS;q++){after[2*q-3].push_back({X(q-1),X(q),1});after[2*q-3].push_back({Y(q),Y(q-1),-1}); + after[2*q-2].push_back({Y(q),Y(q-1),1});after[2*q-2].push_back({X(q-1),X(q),-1});} +for(int p=KPAIRS;p>=2;p--){after[S-1].push_back({Y(p-1),Y(p),-1});after[S-1].push_back({X(p),X(p-1),1});} +int nbridges=0;for(auto&a:after)nbridges+=a.size();need(nbridges==6*(KPAIRS-1),"twin bridge count"); +size_t words=(global+63)/64;std::vectora((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +for(auto q:after[stage])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<2*KPAIRS;bank+=2)for(int i=0;ib(2*KPAIRS);for(int z=0;z<2*KPAIRS;z++)b[z]=1u<()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< 1 +res = dict(status='PASS_NINE_STAGE_WHOLE_HOSTED_BIT_PRICE_AND_CITED_ASSEMBLY', R=R, stages=L, replicas=T, bit_lower=str(c), bit_lower_decimal=root_['lower'], + next_grid_point_rejected=str(chi), bit=dict(live=W, physical=physical, maxchild=max(P), rank_mass=mass, hosted_residuals=audit['hosted_residuals'], + bank_assignments=audit.get('bank_assignments'), prefix_bits=prefix.bit_length(), charged_prefix_bits=charged_prefix, coefficient_bits=coefficient.bit_length(), + two_level_coefficient_bits=two.bit_length(), charged_two_level_coefficient_bits=charged_two, row_coefficient=row, halving_depth=DEPTH), + bit_profile={str(r): n for r, n in sorted(P.items())}, emitted_program_sha256=bg.get('emitted_program_sha256'), kappa={}) +def ceil(x): return -((-x.numerator) // x.denominator) +for name in names: + b = Q(cited[name]["b"]) + eta = beta = Q(1, 10 ** 18); grid = Q(1, 10 ** 18); s = min(c, (1 - beta) * b) - Q(1, 10 ** 24) + assert 0 < s < c and s < (1 - beta) * b + chain = [Q(384599, 10 ** 10)]; cutoffs = [] + for j in range(6): + old = chain[-1]; a = (1 - s) * s + s * old + gap = min(s - a, 1 - a - s, 1 - a - s * (1 - old), 1 - s); assert old < a < s < 1 - a and gap > 0 + cutoff = max(ceil(36 / gap ** 2), ceil(2 * (4 + charged_two) / gap)); assert cutoff * gap ** 2 >= 36 and cutoff * gap >= 2 * (4 + charged_two) + cutoffs.append(dict(gap=str(gap), cutoff_log2=str(cutoff))); chain.append(a) + q = chain[-1] * (1 - 2 * eta); margin = (1 - eta) * q / (1 + q); ticks = margin / grid; k = grid * ((ticks.numerator - 1) // ticks.denominator) + bridge = {'semantic': {'C0': {'base': 2, 'exponent': 210000}, 'strict_literal_gap': 1}, 'rows': {'degree_gap': Q(10 ** 6) - Q(51 * 20161, 25)}} + a = Outer.assembly(chain[-1], b, bridge, k, eta=eta, beta=beta) + assert len(a['strict_constraints']) == 47 and all(x > 0 for x in a['strict_constraints'].values()) + controls = [] + for cname, kk, ee, bb in [('next_grid', k + grid, eta, beta), ('zero_eta', k, Q(0), beta), ('zero_beta', k, eta, Q(0)), ('unit_beta', k, eta, Q(1))]: + try: Outer.assembly(chain[-1], b, bridge, kk, eta=ee, beta=bb) + except AssertionError: controls.append(cname) + else: raise AssertionError(cname) + res['kappa'][name] = dict(complex_lower=str(b), kappa=str(k), kappa_decimal=format(float(k), '.18f'), + binding_component='bit' if c < (1 - beta) * b else 'complex', strict_outer_constraints=47, outer_controls=controls) +outp.write_text(json.dumps(res, indent=1) + '\n') +print(' nine-stage bit c = %s = %s; profile %s; prefix %d bits, two-level %d bits (charged %d), row %d, depth %d' + % (c, root_['lower'], res['bit_profile'], prefix.bit_length(), two.bit_length(), charged_two, row, DEPTH)) +for name, x in res['kappa'].items(): print(' %s: b %s kappa %s (%s-bound) 47/47, controls %s' % (name, x['complex_lower'], x['kappa_decimal'], x['binding_component'], ','.join(x['outer_controls']))) diff --git a/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py b/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py new file mode 100644 index 0000000000..3df12bd632 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/source-context/research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py @@ -0,0 +1,264 @@ +# Generalised from PR #443's global_kernel.py to an arbitrary odd stage count S = 2K+1 (compressed window m = 1+7S) +# by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. At the defaults (S = 9, 32 replicas) the emitted +# GLOBAL-TEMPLATE.json.gz and GLOBAL.json equal PR #443's (GLOBAL.json except wall-clock seconds). +# Kernel integration of PR436/PR386 by chafreaky, with OpenAI Codex assistance. +# Original copyright and attribution retained below. This variant uses explicit +# residual isometries and mixed-width banks; the original all-zero-start +# requirement is replaced by the verified kernel entrance contract. +"""Source-bound compressed S-stage (S = 2K+1 odd, default 9) bit template with independent replicas. +PR386 global identity and PR436 generalization by Zhihao Chen and eumemic, +with their disclosed OpenAI Codex and Anthropic Claude assistance, Apache-2.0. +PR439 explicit residual routes and this replication extension by chafreaky, +with OpenAI Codex assistance. All owner assignments and emitted calls are checked. +Historical PR386 regression is performed by the unchanged parent wrapper. +""" +import argparse, gzip, hashlib, json, struct, time +from collections import Counter +from pathlib import Path +import os, sys +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../e8-r740-replica32/code')) +from bank_routes_k import placement, validate_isometries +from config import REPLICAS + +H,L,K,T,M=8,9,4,REPLICAS,64 # overwritten in main() from --stages / --replicas +NAMES={5:'FIVE',7:'SEVEN',9:'NINE',11:'ELEVEN',13:'THIRTEEN'} +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def write(p,x): p.write_text(json.dumps(x,indent=2)+'\n') + +def recipe(K): + out=[dict(kind='local',stage=0,pair=0,reverse=False)]; stage=1 + for j in range(K): + out.append(dict(kind='local',stage=stage,pair=j,reverse=True)); stage+=1 + if j=5 and a.stages%2==1; L=a.stages; K=(L-1)//2; T=a.replicas; M=1+7*L; NOBANK=a.no_banks + if L!=9: assert NOBANK, 'bank tiling is only emitted for the nine-stage layout; use --no-banks and host every residual' + DEFICIT=T*(2*K*120-9*H*L) + wp=a.word; w=json.loads(gzip.decompress(wp.read_bytes()) if wp.suffix=='.gz' else wp.read_bytes()) + V,R=w['v'],w['R']; LOCAL=2*V+R; DATA=2*K*V*T; LIVE=DATA+L*R + assert (w['h'],V,w['form'])==(8,120,'/2') + geo=json.loads((out/'GEOMETRY.json').read_text()) + assert geo['status']=='PASS_COMPRESSED_%s_BIT_GEOMETRY_AND_BANK_BLOCKS'%NAMES[L] and geo['stages']==L and geo['m']==M + # the port routes depend only on the labels: same 120 label vectors, in the same order + assert len(geo['ports'])==V and all(p['port']==t and p['q']==w['lines'][t] for t,p in enumerate(geo['ports'])) + rp=a.local_check/'records/249-records.bin'; raw=rp.read_bytes(); rec=list(struct.iter_unpack('<6i',raw)) + state=json.loads((a.local_check/'records/249-states.json').read_text()) + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + dims={int(f):z['dim'] for f,z in fs.items()} + lg=json.loads((a.local_check/'cout/legality.json').read_text()) + cc=json.loads((a.local_check/'cout/columns.json').read_text()) + assert lg['status'].startswith('PASS') and cc['status'].startswith('PASS') + assert (state['v'],state['n'])==(V,LOCAL) and lg['copies']==lg['erasures']==9 + ADDS=lg['common_frame_ADDs'] + assert cc['formal_columns_checked']==4*V+R and cc['local_scalar_additions']==ADDS + initial=[state['initial'][str(i)] for i in range(LOCAL)] + final=[state['final'][str(i)] for i in range(LOCAL)] + assert all(dims[final[i]]==H for i in range(2*V,LOCAL)) + widths=[H-dims[initial[i]] for i in range(2*V,LOCAL)] + ENT=sum(H-z for z in widths) + if NOBANK: place,NB=None,None; LIVE=DATA + else: + place,NB=placement(widths,T,M) + assert T%8==0 and T*(H*R-ENT)%M==0 and NB==T*(H*R-ENT)//M + LIVE=DATA+L*NB + isometries=json.loads(a.isometries.read_text()) + assert validate_isometries(isometries,w['frames'],w['lines'],dims)==set(initial[2*V:]) + streams={}; checks={}; localH=None + for reverse in (False,True): + cur=(final if reverse else initial)[:]+[-1]; val=[1<=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x=0 to b has axes 8+7a,...,7+7b. +This follows directly from the data levels: source levels are P_q at -1 and +I_8+E_a at a>=0; target levels are 0 at -1 and I_8-P_q+E_a at a>=0. +Here E_a is the first a exterior seven-blocks. The difference is the same +for both members. The source rho_s interchanges q-perpendicular directions +with exterior block s; its displayed block matrix gives these boundary +identities in both call orientations. + +For a descriptor (child, offset, 8), let S be the corresponding eight entries +in that ordered pending list. Define pi_S by mapping local axes 0,...,7 to +the ordered entries of S, then mapping the remaining axes to the unused +ambient axes in increasing order. Put sigma_S=A_q pi_S. This is an explicit +orthogonal matrix; it maps the full local residual projector to precisely S. + +For the common invocation d the helper owner is + + (F, g), g = d sigma_S^-1. + +For data use g=d rho_s,q and sigma=rho_s,q^-1. Consequently g sigma=d +for every role. The private temporary uses a separate reserved family and +class d. Within a call, different data roles have different families; hosted +families belong to inactive pairs; the private family is outside the live +data stock. Helpers sharing F have different actual pi_S, not merely different +text descriptors. The verifier checks the slot supports and their disjointness +even when one call uses several idle children of that same family. + +If two such helpers had the same physical class, canceling d and the common +A_q would give pi_S=pi_T. Applying them to a basis vector distinguishes them +over every K. Thus all 661 dirty roles and the private role have injective +physical owners at each fixed d. This does not assert disjointness across d. + +For stage 2, replica 0, pair 0, the helpers 232,...,236 in family 666 use child +4 and supports 1..8, 9..16, 17..24, 25..32, 33..40. The pending support is +1..42, leaving 41,42. The checker conjugates all five full local swaps by +their actual permutations and checks completion on all 128 address basis +columns. The five distinct streams can carry correlated values without aliasing. + +## 3. Whole-call simulation and the rank-seven issue + +Work at a fixed common invocation d. Pull each owned physical row back by +bar(d), obtaining a common-address row f_i. Give it a bookkeeping gauge +Gamma_i and decoded row c_i=f_i composed with Gamma_i. A gauge is a bijection, +not a data reset. At stage s use the partial swap on the frame projector plus +E_s; for a reflected call use I_8-P_frame plus E_s. + +MOVE from Gamma_a to Gamma_b changes the payload to +f_i composed with Gamma_a composed with Gamma_b^-1, so its decoded value is +unchanged. ADD between equal frames changes the decoded destination by the +decoded source. Fresh COPY uses the same transport into the private row, and +therefore copies its decoded value. If temporary and source decoded rows are +equal, bijectivity gives + + f_temp = f_source composed with Gamma_source composed with Gamma_temp^-1. + +This is precisely the physical ERASE guard. Zero decoded payload is equivalent +to zero physical payload, so no dirty private value is silently discarded. +Induction over the literal events proves simultaneous execution correctness. +Injective physical owners ensure each event leaves all other streams unchanged. +The equation g sigma=d means a chart-routed ADD is exactly a common native +address ADD, rather than an additional unpriced data-dependent routing rule. + +This is the generic simulation argument of PR540's FramedReplay and +OwnerTransport, instantiated here with PR589's word and owner construction. +The checker reconstructs every record directly from the pinned word and checks +equality with both template programs and their hashes. It propagates all 661 +input columns simultaneously, including dirty helper columns. MOVE labels, +common ADD frames, clean COPY destinations, centre immutability, every ERASE +guard, and the final private zero are checked in that same chronological run. +The final decoded map is x'=x, h'=h, y'=y+x, for both orientations in their +local role ordering. This identity of Boolean-linear maps also holds after +substituting arbitrary correlated input functions. + +PR540's concrete rank-eight COPY lemma cannot be reused unchanged. PR589 copies +sources 472,...,480 from frames 510,...,518 to frame 0. These frames have rank +seven. In the forward call, Gamma_510 Gamma_0^-1 = D_P510 on the local block; +the common E_s factor cancels. In the reflected call the relative map is +D_(I-P510) D_I = D_P510, again rank seven. The same calculation supplies +each matching ERASE transport. All nine frame pairs are checked exactly in +both orientations. The receipt includes distinguishing basis columns against +both a full rank-eight swap and a different rank-seven projector. + +For a helper, the difference between its entry and exit gauges is the full +local eight-dimensional swap in either orientation. Returning to the native +physical stream (F,g) turns this into D on g A_q S. Data output formulas use +only that call's input data, because no helper column remains in decoded data +outputs. They agree exactly with the unhosted call using the same data owners, +regardless of the distinct and evolving bank/helper contents in the comparison. + +## 4. Cover sweeps and chronological composition + +Apply the complete-call result before commuting anything. For a fixed helper +slot, d -> d sigma^-1 is a bijection of the full group G. Thus its cover sweep +applies its residual once to every class of its host family. Different d's +may revisit a stream through other slots. They use its **current** contents. +Since the complete-call result held for arbitrary dirty functions, this is +legal without a fresh-input or independence assumption. Active data families +are disjoint from hosted families throughout that sweep. Residuals on disjoint +axes commute within each fixed (family,g) stream. + +The checker independently walks the actual nine-stage schedule. Each local +stage enters its required level; every bridge has equal levels; idle children +have the actual source level; all pairs reach level eight before exchange. +For every host slot its stage lies after the last local/bridge touch of that +pair and strictly before its nominated idle child. Across those positions, +complete calls and bridges on other pairs have no endpoint dependence on this +family. Any intervening idle/host operations on this family use disjoint axes, +checked in the same fixed A_q chart. Consequently its residual can move to +its nominated child after complete calls have been reduced to their endpoints. + +For each (family,g,child), the moved residuals occupy disjoint subsets of the +pending projector, and the remainder is exactly the complement. The partial +swap product identity in section 1 therefore reconstructs the original idle +child. Repeat for every child. All data, inactive streams and the private zero +are retained throughout; no prior bank output or hosted output is reinitialized. +This proves the retained-data equality in the stated exact stream model. + +The count check yields the unchanged formal profile +{1:381024, 2:400416, 3:22752, 4:26880, 5:29376, 6:17376, 7:26784, 42:288}, +rank mass 1808352 and deficit 10272. These are recursive rank counts. They do +not establish a new routing invoice or justify changing the selected result. + +## Remaining obligations + +The Python certificates and this written induction have not been ported into +PR540's Lean source provider. Its proof of the older PR442 call is not a formal +proof of this newer call. A finite-group operator proof also does not implement +the all-size injective compiler, child algorithms, common grid, restored work, +tape, precision, row, exceptional-class or analytic transfer contracts. Full +native supplier replay and finite invoice admission are separate checks. + +Predecessors: DaysSky (PR442 hosting); Zhihao Chen, chafreaky and eumemic +(compressed geometry and retained supplier chain); DreamingOfClouds/eumemic +(PR545/555/589 punctured and tuned words); cheesegrader (PR540 formal framework); +commdata2338 (PR1307 ambient-axis census and PR1421 projector ledger); +1337isnot1337/CinnaDavis (PR1351/1371 physical-family operator checks). +Prepared with substantial OpenAI Codex assistance, Apache-2.0. diff --git a/research/bit-five-rank4-terminals/admission/verify.py b/research/bit-five-rank4-terminals/admission/verify.py new file mode 100644 index 0000000000..2fd5d76645 --- /dev/null +++ b/research/bit-five-rank4-terminals/admission/verify.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +"""Independent finite chart and coefficient audit; no supplier admission. + +Apache-2.0. Prepared with substantial OpenAI Codex assistance. +Imports only the standard library; writes only its own requested receipt. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import json + +HERE = Path(__file__).resolve().parent +INPUT = HERE / 'inputs' +REPO = HERE / 'source-context' + + +def need(p, msg): + if not p: + raise ValueError(msg) + + +def sha(p): + return sha256(Path(p).read_bytes()).hexdigest() + + +def matrix_product(a, b): + return [[sum((x * y for x, y in zip(row, col)), Q(0)) + for col in zip(*b)] for row in a] + + +def identity(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def transpose(a): + return [list(x) for x in zip(*a)] + + +def rank(rows): + a = deepcopy(rows) + k = 0 + for j in range(len(a[0]) if a else 0): + p = next((i for i in range(k, len(a)) if a[i][j]), None) + if p is None: + continue + a[k], a[p] = a[p], a[k] + d = a[k][j] + a[k] = [x / d for x in a[k]] + for i in range(len(a)): + if i != k: + d = a[i][j] + a[i] = [x - d*y for x, y in zip(a[i], a[k])] + k += 1 + return k + + +def partial_swap(p): + n = len(p) + return [[(Q(i % n == j % n) - p[i % n][j % n]) + if i // n == j // n else p[i % n][j % n] + for j in range(2*n)] for i in range(2*n)] + + +def double(a): + return [[a[i % 8][j % 8] if i // 8 == j // 8 else Q(0) + for j in range(16)] for i in range(16)] + + +def apply_gate(a, gate): + op, i, j = gate[:3] + if op == 'swap': + a[i], a[j] = a[j], a[i] + elif op == 'scale': + a[i] = [Q(j)*x for x in a[i]] + elif op == 'add': + a[i] = [x+Q(gate[3])*y for x, y in zip(a[i], a[j])] + else: + raise ValueError('unknown chart gate') + + +def invert_gate(g): + if g[0] == 'swap': + return list(g) + if g[0] == 'scale': + return [g[0], g[1], str(1/Q(g[2]))] + return [g[0], g[1], g[2], str(-Q(g[3]))] + + +def chart_program(chart): + """In-place Q via exact unit ADD, NEGATE, DOUBLE/HALVE, SWAP. + + Reduction is nomination only; all emitted programs are independently + replayed as rational matrices, including every prefix denominator. + """ + a = deepcopy(chart) + reduction = [] + for j in range(8): + i = next(i for i in range(j, 8) if a[i][j]) + if i != j: + g = ['swap', i, j]; apply_gate(a, g); reduction.append(g) + if a[j][j] != 1: + g = ['scale', j, str(1/a[j][j])]; apply_gate(a, g); reduction.append(g) + for i in range(8): + if i != j and a[i][j]: + g = ['add', i, j, str(-a[i][j])]; apply_gate(a, g); reduction.append(g) + need(a == identity(8), 'chart reduction reaches identity') + factored = [invert_gate(g) for g in reversed(reduction)] + program = [] + for g in factored: + op, i, j = g[:3] + if op == 'swap': + program.append(g) + elif op == 'scale': + c = Q(j) + need(abs(c) in (Q(1), Q(2), Q(1, 2)), 'dyadic unit scale') + if c < 0: + program.append(['scale', i, '-1']) + if abs(c) != 1: + program.append(['scale', i, str(abs(c))]) + else: + c = Q(g[3]) + need(abs(c) in (Q(1), Q(2), Q(1, 2)), 'allowed dyadic shear') + unit = '1' if c > 0 else '-1' + if abs(c) == Q(1, 2): + program += [['scale', j, '1/2'], ['add', i, j, unit], ['scale', j, '2']] + else: + program += [['add', i, j, unit]] * int(abs(c)) + inverse = [invert_gate(g) for g in reversed(program)] + def replay(gs): + matrix = identity(8) + max_norm = Q(1); max_denominator = 1 + for g in gs: + apply_gate(matrix, g) + max_norm = max(max_norm, max(sum(map(abs, row)) for row in matrix)) + max_denominator = max(max_denominator, max(x.denominator for row in matrix for x in row)) + return matrix, str(max_norm), max_denominator + m, norm, den = replay(program) + mi, inorm, iden = replay(inverse) + need(m == chart and mi == transpose(chart), 'exact forward/inverse matrix') + need(matrix_product(mi, m) == identity(8), 'all-input inverse restoration') + need(replay(program[:-1])[0] != chart, 'missing-final-gate control') + def shifted(g, k): + out = list(g); out[1] += k + if out[0] in ('add', 'swap'): + out[2] += k + return out + residual = ([shifted(g, k) for k in (0, 8) for g in inverse] + + [['swap', i, i+8] for i in range(4)] + + [shifted(g, k) for k in (0, 8) for g in program]) + state = identity(16); rnorm = Q(1); rden = 1 + for g in residual: + apply_gate(state, g) + rnorm = max(rnorm, max(sum(map(abs, row)) for row in state)) + rden = max(rden, max(x.denominator for row in state for x in row)) + p = matrix_product([r[:4] for r in chart], transpose([r[:4] for r in chart])) + need(state == partial_swap(p), 'literal residual coordinate program') + invresidual = [invert_gate(g) for g in reversed(residual)] + for g in invresidual: + apply_gate(state, g) + need(state == identity(16), 'literal residual inverse restoration') + return {'elementary_factors': len(factored), 'program': program, 'inverse': inverse, + 'primitive_count': len(program), 'primitive_histogram': dict(Counter( + g[0] + (':'+g[2] if g[0] == 'scale' else '') for g in program)), + 'forward_max_prefix_row_l1': norm, 'inverse_max_prefix_row_l1': inorm, + 'forward_max_prefix_denominator': den, 'inverse_max_prefix_denominator': iden, + 'residual_16_coordinate_program': residual, + 'residual_16_coordinate_primitive_count': len(residual), + 'residual_max_prefix_row_l1': str(rnorm), 'residual_max_prefix_denominator': rden, + 'scratch_field_elements': 0, 'missing_final_gate_rejected': True} + + +def verify_chart(c, raw, full): + cols = [[Q(x) for x in r] for r in c['Q_columns']] + need(len(cols) == 8 and all(len(r) == 8 for r in cols), 'chart size') + need(matrix_product(cols, transpose(cols)) == identity(8), 'orthonormal columns') + labels = c['inside_full_root_labels'] + c['cold_full_root_labels'] + need(cols == [[Q(x, 2) for x in full['lines'][j]] for j in labels], 'root labels') + need(all(x.denominator in (1, 2) for r in cols for x in r), 'half integral chart') + e = [[Q(x) for x in raw['lines'][j]] for j in raw['frames'][c['terminal_frame']]] + need(rank(e) == 4 and rank(e + cols[:4]) == 4, 'actual rank four terminal span') + p = matrix_product(transpose(cols[:4]), cols[:4]) + need(p == [[Q(x) for x in r] for r in c['projector']], 'saved projector') + pc = [[Q(i == j and i < 4) for j in range(8)] for i in range(8)] + chart = transpose(cols) + need(matrix_product(matrix_product(double(chart), partial_swap(pc)), double(cols)) + == partial_swap(p), 'all sixteen address basis columns') + return {'frame': c['terminal_frame'], 'rank': 4, + 'address_basis_columns': 16, 'max_denominator': 2, + 'coordinate_program': chart_program(chart)} + + +def magnitude_and_defects(records, inverse=False): + """Exact-integer reset bound plus extended-shear no-reset defect bound. + + Scalar ADD is exact. MOVE, COPY and ERASE may each inject an arbitrary + additive defect of norm at most one in the single destination row. + COPY/ERASE are extended to +/- source shears, not zero assignments. + """ + mag = [1]*660 + [0] + error = [0]*661 + max_mag = 1 + max_error = 0 + opened = None + erased = [] + count = Counter() + for z in reversed(records) if inverse else records: + op, d, s, c, f, phase = z + count[str(op)] += 1 + if op == 0: + error[d] += 1 + elif op == 1: + mag[d] += abs(c)*mag[s] + error[d] += abs(c)*error[s] + elif op == (3 if inverse else 2): + need(opened is None, 'fresh episode') + opened = d + mag[660] = mag[d] + error[660] += error[d] + 1 + else: + need(op == (2 if inverse else 3) and opened == d, 'matching episode') + opened = None + mag[660] = 0 + error[660] += error[d] + 1 + erased.append(error[660]) + max_mag = max(max_mag, max(mag)) + max_error = max(max_error, max(error)) + need(opened is None, 'all episodes close') + return {'positive_envelope_exact_erase_only': max_mag, + 'unit_defect_all_prefix_bound': max_error, + 'unit_defect_persistent_endpoint_bound': max(error[:660]), + 'unit_defect_private_endpoint_bound': error[660], + 'private_bounds_after_each_erase': erased, 'opcode_counts': dict(count)} + + +def main(): + p = argparse.ArgumentParser() + p.add_argument('--write', action='store_true') + args = p.parse_args() + bundle = json.loads((HERE/'INPUT-MANIFEST.json').read_text()) + own = {'decompressed_word_sha256': bundle['decompressed_word_sha256']} + seen = {} + def authenticate(x): + if isinstance(x, list): + for y in x: + authenticate(y) + elif isinstance(x, dict): + if 'path' in x and 'sha256' in x: + path = Path(x['path']) + need(not path.is_absolute() and '..' not in path.parts, 'bundle-relative input') + need(sha(HERE/path) == x['sha256'], 'pinned file changed: '+x['path']) + seen[x['path']] = x['sha256'] + for y in x.values(): + if isinstance(y, (dict, list)): + authenticate(y) + authenticate(bundle['files']) + wordfile = INPUT/'FIVE-TERMINALS-WORD.json.gz' + blob = gzip.decompress(wordfile.read_bytes()) + need(sha256(blob).hexdigest() == own['decompressed_word_sha256'], 'literal word hash') + word = json.loads(blob) + rawpath = INPUT/'r438-t154.json.gz' + fullpath = INPUT/'bitE8-r865.json.gz' + raw = json.loads(gzip.decompress(rawpath.read_bytes())) + full = json.loads(gzip.decompress(fullpath.read_bytes())) + charts = json.loads((INPUT/'TERMINAL-CHARTS.json').read_text())['charts'] + need([x['terminal_frame'] for x in charts] == [506, 508, 509], 'three exact frames') + checked = [verify_chart(c, raw, full) for c in charts] + controls = [] + bad = deepcopy(charts[0]); bad['Q_columns'][0][0] = '1' + try: + verify_chart(bad, raw, full) + except ValueError: + controls.append('nonorthogonal chart rejected') + else: + raise ValueError('chart mutation accepted') + bad = deepcopy(charts[0]); bad['terminal_frame'] = 0 + try: + verify_chart(bad, raw, full) + except ValueError: + controls.append('wrong actual terminal span rejected') + else: + raise ValueError('frame mutation accepted') + forward = magnitude_and_defects(word['records']) + reverse = magnitude_and_defects(word['records'], True) + F = forward['positive_envelope_exact_erase_only'] + R = reverse['positive_envelope_exact_erase_only'] + need((F, R) == (8402567, 630744), 'both positive bounds') + p5 = 64*F**3*R**2 + p9 = 2**18*F**5*R**4 + need((p5.bit_length(), p9.bit_length()) == (114, 211), 'exact precision thresholds') + # Exact signed scalar minimal witness: a nonzero COPY defect survives + # its exact inverse source shear, irrespective of how small it is. + epsilon = Q(1, 2**256) + source = Q(0); temporary = source + epsilon + temporary -= source + need(temporary == epsilon and temporary != 0, 'positive finite precision does not imply exact ERASE') + controls.append('COPY defect survives inverse source shear at 256 bits') + # Sufficient conditional finite-invoice budget for depth two. + # coefficient = prefix + B. This is NOT a bound on an unbuilt compiler. + Bcap = 2**210 - 1 + Ecap = 2**20 - 1 + two_cap = (p9+Bcap+1)**2*(Ecap+1)**2 + need(two_cap < 2**512, 'conditional two-level invoice fits inherited 512 bits') + sources = [ + 'research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp', + 'research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp', + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py', + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/code/assemble9.py', + 'research/pr589-five-helper-hosting/PROOF.md', + ] + result = {'status': 'PASS_FINITE_ADMISSION_DIAGNOSTICS_NOT_NATIVE_SUPPLIER', + 'no_new_kappa': True, 'authenticated_unique_files': len(seen), + 'word_sha256': own['decompressed_word_sha256'], + 'independent_charts': checked, 'forward': forward, 'inverse': reverse, + 'precision': {'five_stage_integer_bound': str(p5), 'five_stage_bits': 114, + 'five_stage_multiple_of_64': 128, 'nine_stage_integer_bound': str(p9), + 'nine_stage_bits': 211, 'nine_stage_multiple_of_64': 256, + 'conditional_depth_two': {'extra_invoice_max': str(Bcap), + 'child_count_max': Ecap, 'upper_bound_bits': two_cap.bit_length(), + 'charged_bits': 512, + 'scope': 'Sufficient conditional arithmetic only; no compiler or owner invoice is supplied.'}}, + 'controls': controls, + 'source_sha256': {x: sha(REPO/x) for x in sources}, + 'script_sha256': sha(__file__), + 'limits': 'No exact rounded-child cleanup, chronological owners, paid native routes, all-size compiler, tape or outer admission.'} + outfile = HERE/'ADMISSION-CHECK.json' + if args.write: + outfile.write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(outfile.read_text()) == result, 'receipt matches independent recomputation') + print(result['status']) + print(json.dumps({'charts': len(checked), 'guards': [114,211], + 'defect_bounds': [forward['unit_defect_all_prefix_bound'],reverse['unit_defect_all_prefix_bound']], + 'conditional_two_level_bits': two_cap.bit_length()})) + + +if __name__ == '__main__': + main() diff --git a/research/bit-five-rank4-terminals/moment/PORTABLE-VALIDATION.json b/research/bit-five-rank4-terminals/moment/PORTABLE-VALIDATION.json new file mode 100644 index 0000000000..dba1ed7d85 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/PORTABLE-VALIDATION.json @@ -0,0 +1,87 @@ +{ + "status": "PASS_PORTABLE_READ_ONLY_RELOCATED_NORMAL_OPTIMIZED_AND_CORRUPTION_CONTROLS", + "checked_at_utc": "2026-10-19T08:37:10.158733+00:00", + "commands": [ + { + "location": "portable", + "argv": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "verify.py" + ], + "exit_code": 0, + "stdout": "PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS no_new_kappa\nnative optimistic root: 0.00196293884161 0.001962938841611\nfallback optimistic root: 0.00196293883948 0.001962938839481\nb=1/500 raw excess/call=0.675747514950634313488383535\nb=3/1000 raw excess/call=18.9419819069957543419643958\nb=1/200 raw excess/call=55.6656543107476896324751170\nall odd L>=3: b=.002 impossible at depth<=10; b=.002019323862 impossible even with idle rank m\ndepth11/rank60 unbuilt budget: 0.00231398661483780488008181456\nPASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION no_new_kappa\nsource nine-stage public idle ranks:14,7,28,7,42,7,42,28,14,0\nall inherited odd arities, all depths, any full-progress extra stock: b>=.002 rejected\nrank42 inherited fallback root: 0.001954220766879 0.00195422076688\nb=.002 nine-stage excess: 0.838420449631868152277021036\nPASS_FIVE_TERMINAL_MOMENT_AND_FIXED_WINDOW_OBSTRUCTION no_new_kappa\n", + "stderr": "", + "read_only": true + }, + { + "location": "portable", + "argv": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-O", + "-B", + "verify.py" + ], + "exit_code": 0, + "stdout": "PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS no_new_kappa\nnative optimistic root: 0.00196293884161 0.001962938841611\nfallback optimistic root: 0.00196293883948 0.001962938839481\nb=1/500 raw excess/call=0.675747514950634313488383535\nb=3/1000 raw excess/call=18.9419819069957543419643958\nb=1/200 raw excess/call=55.6656543107476896324751170\nall odd L>=3: b=.002 impossible at depth<=10; b=.002019323862 impossible even with idle rank m\ndepth11/rank60 unbuilt budget: 0.00231398661483780488008181456\nPASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION no_new_kappa\nsource nine-stage public idle ranks:14,7,28,7,42,7,42,28,14,0\nall inherited odd arities, all depths, any full-progress extra stock: b>=.002 rejected\nrank42 inherited fallback root: 0.001954220766879 0.00195422076688\nb=.002 nine-stage excess: 0.838420449631868152277021036\nPASS_FIVE_TERMINAL_MOMENT_AND_FIXED_WINDOW_OBSTRUCTION no_new_kappa\n", + "stderr": "", + "read_only": true + }, + { + "location": "relocation-check", + "argv": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-B", + "verify.py" + ], + "exit_code": 0, + "stdout": "PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS no_new_kappa\nnative optimistic root: 0.00196293884161 0.001962938841611\nfallback optimistic root: 0.00196293883948 0.001962938839481\nb=1/500 raw excess/call=0.675747514950634313488383535\nb=3/1000 raw excess/call=18.9419819069957543419643958\nb=1/200 raw excess/call=55.6656543107476896324751170\nall odd L>=3: b=.002 impossible at depth<=10; b=.002019323862 impossible even with idle rank m\ndepth11/rank60 unbuilt budget: 0.00231398661483780488008181456\nPASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION no_new_kappa\nsource nine-stage public idle ranks:14,7,28,7,42,7,42,28,14,0\nall inherited odd arities, all depths, any full-progress extra stock: b>=.002 rejected\nrank42 inherited fallback root: 0.001954220766879 0.00195422076688\nb=.002 nine-stage excess: 0.838420449631868152277021036\nPASS_FIVE_TERMINAL_MOMENT_AND_FIXED_WINDOW_OBSTRUCTION no_new_kappa\n", + "stderr": "", + "read_only": true + }, + { + "location": "relocation-check", + "argv": [ + "/opt/homebrew/opt/python@3.14/bin/python3.14", + "-O", + "-B", + "verify.py" + ], + "exit_code": 0, + "stdout": "PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS no_new_kappa\nnative optimistic root: 0.00196293884161 0.001962938841611\nfallback optimistic root: 0.00196293883948 0.001962938839481\nb=1/500 raw excess/call=0.675747514950634313488383535\nb=3/1000 raw excess/call=18.9419819069957543419643958\nb=1/200 raw excess/call=55.6656543107476896324751170\nall odd L>=3: b=.002 impossible at depth<=10; b=.002019323862 impossible even with idle rank m\ndepth11/rank60 unbuilt budget: 0.00231398661483780488008181456\nPASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION no_new_kappa\nsource nine-stage public idle ranks:14,7,28,7,42,7,42,28,14,0\nall inherited odd arities, all depths, any full-progress extra stock: b>=.002 rejected\nrank42 inherited fallback root: 0.001954220766879 0.00195422076688\nb=.002 nine-stage excess: 0.838420449631868152277021036\nPASS_FIVE_TERMINAL_MOMENT_AND_FIXED_WINDOW_OBSTRUCTION no_new_kappa\n", + "stderr": "", + "read_only": true + } + ], + "negative_controls": [ + { + "mutated": "RESULT.json", + "rejected": true, + "exit_code": 1, + "reason": "ValueError: shipped mathematical result differs: RESULT.json" + }, + { + "mutated": "inputs/FIVE-TERMINALS.json", + "rejected": true, + "exit_code": 1, + "reason": "ValueError: input digest: /Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/relocation-check/inputs/FIVE-TERMINALS.json" + } + ], + "portable_files": { + "WINDOW-RESULT.json": "a959fcac8aa0fed2ab63baf02492ce9c697d039be32fb375abfe7dc77b18e786", + "PROOF.md": "e78080da8c475278ed0b9cba6043a2e2182f4d6c6bdc58b6e928fcba94c48972", + "check_moment.py": "f462d1299f23cb9d9df800a2e15af5c1f15d883b0aca90e0885a932b903071d4", + "RESULT.json": "face2ea5e286831ac29413f4e2d085998685d4faf332b5c224159f6b9fcdf42d", + "check_windows.py": "32dc8b5dcd219de70d4404ea49c31d653e7b75627d6c78e4eb84e5a4d8d4a931", + "README.md": "85dcfafcd8931296297494e1abd5441ea5ac8f3b750cca169b78ab3fd50239cd", + "WINDOW-PROOF.md": "4bac2a8826350061d8bd9eade8465f9a01989422d4027b5d2830506662fa016d", + "verify.py": "bb5487c78c835d2637ce84e289e969771a59e4cfeb90cc829d1b79c349ae76ac", + "inputs/SOURCES.json": "2548662747a5ea2e00ebdf6cced3fd76b38c3a841526f3baf0acd0b7a0eb4ada", + "inputs/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "inputs/R438-CERTIFICATE.json": "6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c", + "inputs/FIVE-TERMINALS.json": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58" + }, + "no_new_kappa": true, + "independent_review": "parent unary-review final review pending", + "relocation_removed": true +} diff --git a/research/bit-five-rank4-terminals/moment/PROOF.md b/research/bit-five-rank4-terminals/moment/PROOF.md new file mode 100644 index 0000000000..fe3d46560f --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/PROOF.md @@ -0,0 +1,284 @@ +# Five-terminal BIT: complete-moment obstruction in the inherited coverage model + +The frozen five-terminal word cannot support a joint target κ ≥ .002 under +the inherited odd-stage geometry and two-level child contraction. This remains +true after granting fractional owners, the best possible remainder ranks, +arbitrary additional full-progress stock, zero adapter cost, and zero BIT +fallback charge. In fact, the same obstruction holds through depth ten. +This is a bound on a specified complete pricing model, not a general BIT +lower bound or a rejection of the finite word. + +The later `WINDOW-PROOF.md` strengthens this to every depth under the pinned +public controller chronology. The rank60 allowance below requires changing +that chronology and is unavailable in its actual public idle windows. + +The exact finite word, integer restoration, and public Boolean action are +inputs established by the frozen producer and independent checker. They are +not reproved by this moment checker. No physical source-to-native compiler, +chronological owner allocation, rounded-error theorem, or outer release is +claimed here. Everything stays local; no new κ. + +## Inputs and exact accounting + +The portable checker authenticates three bundled files by fixed SHA256: +the frozen `FIVE-TERMINALS.json` profile, the R438 certificate at scientific +Git pin `20ecf2891d80b5acf18d980b2164fb44ea7faa90`, and the controller source. +The full original handoff manifest and word were authenticated in the run +that produced this package. They are not runtime dependencies of this +arithmetic package. The actual literal word and independent operator audit +belong to the separately bound finite-word contribution; this package assumes +the authenticated local histogram and does not execute that operator check. +See `inputs/SOURCES.json` for hashes and provenance. No sources are modified. + +The paid local histogram is + +``` +H = {1:1322, 2:1342, 3:79, 4:39, 5:102, 6:11, 7:18}. +``` + +It has 2913 children and mass C=5101. All 36005 scalar ADDs, nine rank-seven +COPYs and one private field remain. In particular, + +``` +C = 111*14 + 433*8 + 5*4 + 9*7 = 5101. +``` + +The old R438 local histogram is H+5e4, of mass5121. The changed five helpers +contribute 3484 ranks of helper progress instead of3504. Exactly20 progress +ranks and exactly20 local query ranks disappear together. No extra20 units of +zero-exponent deficit result. + +For the original nine-stage, 32-replica public geometry, m=64, calls=288 and +live public stock W=28416. Write w=W/calls=296/3. The full coverage identity is + +``` +total rank mass/call = (m-1)w + 63 = 6279, +raw stock/call = mw = 18944/3, +deficit/call = w-63 = 107/3. +``` + +Consequently fully hosted old idle mass1158 becomes new idle mass1178. Holding +the old idle invoice fixed after deleting5e4 loses20 ranks of required global +progress. If instead a dedicated helper bank shrinks by its fractional +20/m units of stock, both its raw stock and its full progress bill shrink +by20; the zero-exponent deficit again does not gain20. Actual integral banks +and chronological restrictions can only make this favorable relaxation more +expensive. + +## Fixed nine-stage bound, including inherited fallback + +Use the raw moment convention + +``` +F(b) = sum_r Hglobal[r] * r * (m/r)^b, +F(b) < mW. +``` + +For every 00. +The inherited two-level strict contraction `m² > 2r²` gives R=45 at m=64. +Thus even arbitrary fractional packing of all1178 idle ranks has cost at least + +``` +Fideal(b) = A64(b) + 1178*(64/45)^b, +Am(b) = sum_r H[r]*r*(m/r)^b. +``` + +The inherited conservative BIT fallback is +`τ(m) m^b` per child, where `τ(m)=32m²/10^16`. The smallest possible +fractional child count in this relaxation is `2913+1178/45`. Adding that +charge still gives only a lower bound on the actual complete bill: additional +owner splits, padding, adapters, private transformations or controller +children have not been constructed and have deliberately been priced at zero. + +Exact rational enclosures give the following **positive excess** over raw +stock, per local invocation: + +| b | optimistic excess, inherited fallback included | +|---|---:| +| .002 | > .67574751495063431348 | +| .003 | > 18.9419819069957543419 | +| .005 | > 55.6656543107476896324 | + +Strict monotonicity gives unique optimistic roots. Adjacent exact endpoints +are certified on both sides, rather than inferring rejection from a failed +upper-bound test: + +``` +without fallback: .001962938841610 < root < .001962938841611, +with fallback: .001962938839480 < root < .001962938839481. +``` + +For comparison of the old and new *ideal* invoices, the maximum gain from +the five retirements is exactly + +``` +20*((64/4)^b-(64/45)^b) + + τ(64)*(5-20/45)*64^b. +``` + +At b=.002 this is only .09711782074669793524... raw units per call. It is +not a20-unit net saving. Improving old owners as well is already granted by +the new all-idle-at45 lower bound above. + +## All odd stage counts and arbitrary additional stock + +The following is an all-parameter written proof, with exact finite endpoint +checks. Its premises are the **unchanged one-unpaid-coordinate coverage law** +and the same local H. For an odd integer L≥3, set + +``` +m = 7L+1, +w = 111(L-1)/L, +T = (m-1)w+63 = 777L-714. +``` + +Allow any additional independent full-progress stock X≥0, measured per local +invocation. Its complete progress mass is mX. The nonnegative remaining idle +mass must be `I=T+mX-C`. Hence + +``` +X ≥ Xmin = max(0,(C-T)/m). +``` + +This relaxes integrality, arbitrary dirty-input physical ownership and all +chronological windows. It also grants freely usable ideal channels. At depth d, +the strict halving rule is `m^d>2r^d`, so the cost per idle rank is greater +than `c=2^(b/d)`. A favorable lower bound on excess is + +``` +E(L,b,d,X) = Am(b) + (T+mX-C)c - m(w+X). +``` + +Increasing X by ΔX increases this expression by `mΔX(c-1)≥0`. Therefore the +most favorable stock is Xmin. For L=3,5,7, this gives I=0. At b=.002, exact +checks yield excesses greater than13.5540428589,3.8049595866,.8340592145, +respectively, independently of d. + +For L≥9, Xmin=0 and I=777L-5815, giving + +``` +E(L,b,d) = Am(b) + (777L-5815)c - (777L-666-111/L). +``` + +Treat L as real. Since `Am(b)≥C` and `log(2)>2/3`, + +``` +dE/dL = 7b Am(b)/(7L+1) + 777(c-1) - 111/L² + ≥ 7bC/(7L+1) + 518b/d - 111/L². +``` + +The strict elementary inequality `log(2)>2/3` follows already from the first +positive term of `2 atanh(1/3)`. Multiplying the last lower bound by the +positive `L²(7L+1)` produces + +``` +P(L) = (518b/d)L²(7L+1) + 7bC L² - 111(7L+1). +``` + +At b=1/500,d=2, write L=9+x. The coefficients of P in ascending powers of x +are exactly + +``` +(682923, 699447, 84917, 1813)/500. +``` + +Every coefficient is positive. Thus E increases on every real L≥9. Its exact +value at L=9 is greater than .66243383606313119872, even after permitting +the nonintegral ideal idle rank64/sqrt(2). Together with L=3,5,7, this proves +failure at b=.002 for every odd L≥3. Each child's raw moment is increasing in +b, so the same statement holds for every b≥.002; in particular .003 and .005. + +The same proof strengthens the depth boundary. At d=10, write L=11+x. The +coefficients of P are exactly + +``` +(2402177, 2649087, 238623, 1813)/2500. +``` + +Again they are all positive. Exact lower bounds at L=9 and L=11 are +.00894020087916594600 and .01463184725423174600. Therefore all odd L≥3 fail +at b=.002 through depth10. Smaller d has larger c and cannot improve this. +These are global moment screens; they do not certify any depth's native +compiler or precision cost. + +## Limits if contraction or coverage is changed + +Granting even idle rank m, which is invalid as an actual recursive child, +sets c=1 and drops all idle pressure. With the same fixed H and coverage, +all odd L≥3 still fail at b=.002019323862. The checker verifies L=3,5,7,9,11,13 +exactly and proves positive derivative for every real L≥13 using the same +polynomial with `518b/d=0`. Its weakest tested arity L=11 has the cap-free +root strictly between .002019323861174 and .002019323861175. Thus .003/.005 +are excluded in this unchanged coverage model even without the depth guard. + +There is a narrowly passing *unbuilt* .002 screen outside the inherited +depth-two contract: at L=9 allow fractional idle rank60. The minimum halving +depth for rank60 is11, since `64^11>2*60^11` but `64^10≤2*60^10`. With the +inherited fallback it leaves only + +``` +raw allowance/call = .00231398661483780488008... +``` + +for every extra obligation combined. There is no rank60 owner schedule, +source-to-native compiler or depth11 precision/tape proof in this result. +This fractional invoice cannot be used as a supplier. Its existence also +prevents promoting the inherited-model .002 obstruction into a universal +claim about arbitrary changed depth or changed ownership geometry. + +New coverage with additional unpaid physical directions, fewer paid COPYs, +different public endpoints, higher-rank consolidation of local children, +changed local H, or useful partial progress across calls changes a premise. +Such proposals require a new complete operator and tariff and are not ruled +out here. A changed rounded precision envelope, by itself, does not change +the local H or coverage equations. The inherited104/192-bit cap failures are +not used as a mathematical obstruction: a valid dynamically charged128/256-bit +or other precision argument could repair precision without repairing the +moment failure. + +## Joint and outer consequences + +The previous modern planning transfer uses a common supplier exponent b and +produces K.002. The BIT lower-bound failure above is +already decisive for the inherited coverage/depth model, regardless of a +complex-side gain. The parent's current complex four-bank mass68/stock48 +invoice independently has no positive deficit; it must not be combined with +this BIT local saving as if either side had passed. + +No new joint parameter is claimed. If any changed supplier is eventually +constructed, the owner must bind its full histogram, fallback policy, precision +and row costs, integral whole-helper ownership and arbitrary-input hosting, +native ADDRESS and scalar interfaces, source access, physical storage, +halting/head return, all-size recurrence and every outer inequality at the +same b. The construction/owner and native/rounding specialists own those +separate obligations. This proof does not make any of them implicit. + +## Reproduction, arithmetic and scope of evidence + +Run from this directory: + +``` +python3 -B check_moment.py +python3 -O -B check_moment.py +``` + +The checker uses only Python's standard library, authenticates frozen sources, +and writes `RESULT.json` in this owned directory. Logs/exp use exact rational +atanh and positive Taylor series with explicit tails and outward rounding. +At every requested rational target, independent integer/rational-power tests +check each logarithmic enclosure by raising its rational endpoints to the +target denominator; no floating-point value decides a sign. Decimal strings +are display only. Five negative controls reject lost idle mass, inflated old +helper stock, rank46 at depth2, rank64 recursion and corrupted word identity. + +This consists of an all-parameter written inequality proof and reproducible +finite exact arithmetic. It is neither an exhaustive construction search nor +a formal-kernel proof. Historical source premises remain explicit. Credit the +R438 and PR589 geometry, hosting and native-interface predecessors and the +frozen five-terminal producer/auditor; the predecessor joint-frontier screen +supplied the modern raw-moment and fallback conventions. This worker adds +the exact retirement invoice and all-arity/depth obstruction. + +Apache-2.0; substantial OpenAI Codex assistance. diff --git a/research/bit-five-rank4-terminals/moment/README.md b/research/bit-five-rank4-terminals/moment/README.md new file mode 100644 index 0000000000..72394ec410 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/README.md @@ -0,0 +1,43 @@ +# Five-terminal BIT moment and fixed-window obstruction + +The frozen local word cannot reach a joint target κ≥.002 within the pinned +one-unpaid-coordinate controller family. The written argument covers every +odd arity of that recipe, every recursive depth, fractional public owners, +and arbitrary additional full-progress helper stock. At nine stages the +source's maximum public idle rank is42; even ideal remainder packing has +positive raw moment excess greater than .83842044963186815 per local call at +b=.002 before any fallback or adapter costs. + +Read [WINDOW-PROOF.md](WINDOW-PROOF.md) for the strongest result and exact +scope. [PROOF.md](PROOF.md) records the earlier broader fractional-idle +screens and the20-for20 helper-progress cancellation. Its rank60 arithmetic +allowance is unavailable in the pinned controller chronology. Changed public +chronology, useful partial-progress auxiliary contracts, changed local words, +coverage or COPY tariffs remain outside these obstructions. No new κ and no +native/all-size supplier admission are claimed. + +From this directory, run: + +``` +python3 -B verify.py +python3 -O -B verify.py +``` + +Default execution is read-only and compares every mathematical field with +the shipped results. It ignores only runtime timestamp/Python metadata. To +regenerate both result files explicitly, use `python3 -B verify.py --write`. +The standard-library scripts can run from any working directory and need no +Git checkout, network, or preceding research directory. + +The minimal source inputs are the three files listed in +[inputs/SOURCES.json](inputs/SOURCES.json): the frozen local profile report, +the pinned R438 certificate, and the literal caller source. Their SHA256 +values are fixed in the checker. Actual finite-word validation is a separate +source-bound contribution; this arithmetic package does not re-execute that +word or its native compiler. `check_moment.py` checks exact target powers by +rational exponentiation as well as explicit log/exp series; independent +nth-root and written reviews are supplied by the containing package. + +Retain the source authors and AI disclosures in `inputs/global_k.py` and the +predecessor references in the proofs. Apache-2.0; substantial OpenAI Codex +assistance. diff --git a/research/bit-five-rank4-terminals/moment/RESULT.json b/research/bit-five-rank4-terminals/moment/RESULT.json new file mode 100644 index 0000000000..aaea142a51 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/RESULT.json @@ -0,0 +1,356 @@ +{ + "all_odd_arity_obstructions": [ + { + "b": "1/500", + "depth": 2, + "finite_cases": [ + { + "L": 3, + "excess_per_call": { + "decimal_lower": "13.5540428589069553897486536", + "decimal_upper": "13.5540428589069553897486536", + "lower": "1355404285890695538974865362168956199469933442454473840276388748129/100000000000000000000000000000000000000000000000000000000000000000", + "upper": "135540428589069553897486536216895619946993344245447384027638905929/10000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 5, + "excess_per_call": { + "decimal_lower": "3.80495958669732755520652890", + "decimal_upper": "3.80495958669732755520652890", + "lower": "190247979334866377760326445171440502573625930368439431206363883349/50000000000000000000000000000000000000000000000000000000000000000", + "upper": "380495958669732755520652890342881005147251860736878862412728077859/100000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 7, + "excess_per_call": { + "decimal_lower": "0.834059214560461288736158167", + "decimal_upper": "0.834059214560461288736158167", + "lower": "116768290038464580423062143366102335181706534071326579090066056707/140000000000000000000000000000000000000000000000000000000000000000", + "upper": "291920725096161451057655358415255837954266335178316447725166230831/350000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 9, + "excess_per_call": { + "decimal_lower": "0.662433836063131198722148958", + "decimal_upper": "0.662433836063131198722148958", + "lower": "198730150818939359616644687414183853308315804808537654988648813531/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "49682537704734839904161171853545963327078951202134413747162490647/75000000000000000000000000000000000000000000000000000000000000000" + } + } + ], + "monotone_for_real_L_at_least": 9, + "positive_derivative_numerator_coefficients_in_L_minus_start": [ + "682923/500", + "699447/500", + "84917/500", + "1813/500" + ] + }, + { + "b": "1/500", + "depth": 10, + "finite_cases": [ + { + "L": 3, + "excess_per_call": { + "decimal_lower": "13.5540428589069553897486536", + "decimal_upper": "13.5540428589069553897486536", + "lower": "1355404285890695538974865362168956199469933442454473840276388748129/100000000000000000000000000000000000000000000000000000000000000000", + "upper": "135540428589069553897486536216895619946993344245447384027638905929/10000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 5, + "excess_per_call": { + "decimal_lower": "3.80495958669732755520652890", + "decimal_upper": "3.80495958669732755520652890", + "lower": "190247979334866377760326445171440502573625930368439431206363883349/50000000000000000000000000000000000000000000000000000000000000000", + "upper": "380495958669732755520652890342881005147251860736878862412728077859/100000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 7, + "excess_per_call": { + "decimal_lower": "0.834059214560461288736158167", + "decimal_upper": "0.834059214560461288736158167", + "lower": "116768290038464580423062143366102335181706534071326579090066056707/140000000000000000000000000000000000000000000000000000000000000000", + "upper": "291920725096161451057655358415255837954266335178316447725166230831/350000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 9, + "excess_per_call": { + "decimal_lower": "0.00894020087916594600021095163", + "decimal_upper": "0.00894020087916594600021095163", + "lower": "2682060263749783800063285489531840781694231641250611706791904233/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "268206026374978380006328548953184078169423164125061170679305329/30000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 11, + "excess_per_call": { + "decimal_lower": "0.0146318472542317460016418738", + "decimal_upper": "0.0146318472542317460016418738", + "lower": "4023757994913730150451515291458595203950762264961834996455749141/275000000000000000000000000000000000000000000000000000000000000000", + "upper": "16095031979654920601806061165834380815803049059847339985828252507/1100000000000000000000000000000000000000000000000000000000000000000" + } + } + ], + "monotone_for_real_L_at_least": 11, + "positive_derivative_numerator_coefficients_in_L_minus_start": [ + "2402177/2500", + "2649087/2500", + "238623/2500", + "1813/2500" + ] + }, + { + "b": "1009661931/500000000000", + "depth": null, + "finite_cases": [ + { + "L": 3, + "excess_per_call": { + "decimal_lower": "13.7918864235035829990011890", + "decimal_upper": "13.7918864235035829990011890", + "lower": "275837728470071659980023780431237776207158008704810663340250626987/20000000000000000000000000000000000000000000000000000000000000000", + "upper": "86199290146897393743757431384761805064736877720253332293828340381/6250000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 5, + "excess_per_call": { + "decimal_lower": "4.09186567594533237117606173", + "decimal_upper": "4.09186567594533237117606173", + "lower": "409186567594533237117606173440197451756862779132546662805275105311/100000000000000000000000000000000000000000000000000000000000000000", + "upper": "51148320949316654639700771680024681469607847391568332850659427059/12500000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 7, + "excess_per_call": { + "decimal_lower": "1.15374610865503008964639060", + "decimal_upper": "1.15374610865503008964639060", + "lower": "20190556901463026568811835492221752885660612003036526872252109143/17500000000000000000000000000000000000000000000000000000000000000", + "upper": "807622276058521062752473419688870115426424480121461074890086543847/700000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 9, + "excess_per_call": { + "decimal_lower": "0.189972411888440758902446561", + "decimal_upper": "0.189972411888440758902446561", + "lower": "56991723566532227670733968430458809410046027677433544622897018681/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "14247930891633056917683492107614702352511506919358386155724488041/75000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 11, + "excess_per_call": { + "decimal_lower": "1.55504144780130002381806746E-8", + "decimal_upper": "1.55504144780130002381806746E-8", + "lower": "427636398145357506549968550650696336043194365402113924661/27500000000000000000000000000000000000000000000000000000000000000", + "upper": "17105455925814300261998742026027853441727774616084560409211/1100000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "L": 13, + "excess_per_call": { + "decimal_lower": "0.160890685701019375218259819", + "decimal_upper": "0.160890685701019375218259819", + "lower": "209157891411325187783737764636262510202366067957424996596093218837/1300000000000000000000000000000000000000000000000000000000000000000", + "upper": "104578945705662593891868882318131255101183033978712498298048649411/650000000000000000000000000000000000000000000000000000000000000000" + } + } + ], + "monotone_for_real_L_at_least": 13, + "positive_derivative_numerator_coefficients_in_L_minus_start": [ + "986787758366673/500000000000", + "274425981412821/250000000000", + "36051998570217/500000000000", + "0" + ] + } + ], + "authentication": { + "operator_validation": "separate finite-word producer and independent audit; not executed here", + "source_mode": "portable pinned profile, R438 certificate and controller", + "word_decompressed_sha256_provenance": "3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a" + }, + "cap_free_L11_root": { + "decimal_lower": "0.002019323861174", + "decimal_upper": "0.002019323861175", + "lower": "1009661930587/500000000000000", + "lower_excess": { + "decimal_lower": "-1.49158961766390399670844037E-11", + "decimal_upper": "-1.49158961766390399670844037E-11", + "lower": "-1640748579430294396379284403476789699227349124040899811/110000000000000000000000000000000000000000000000000000000000000000", + "upper": "-16407485794302943963792844034767896992273491240405575339/1100000000000000000000000000000000000000000000000000000000000000000" + }, + "upper": "80772954447/40000000000000", + "upper_excess": { + "decimal_lower": "3.92832945794400568879883355E-12", + "decimal_upper": "3.92832945794400568879883355E-12", + "lower": "1080290600934601564419679225364435168723442692886326661/275000000000000000000000000000000000000000000000000000000000000000", + "upper": "864232480747681251535743380291548134978754154309745883/220000000000000000000000000000000000000000000000000000000000000000" + } + }, + "checked_at_utc": "2026-10-19T08:35:17.007161+00:00", + "fixed_model": { + "deficit_per_call": "107/3", + "extra_adapters": 0, + "idle_mass_per_call": 1178, + "local_child_count": 2913, + "m": 64, + "meaning": "lower bound on actual bill; no owner realization", + "native_halving_rank_cap": 45, + "optimistic_fallback_call_count": "132263/45", + "stock_per_call": "296/3", + "total_mass_per_call": 6279 + }, + "inputs": { + "inputs/FIVE-TERMINALS.json": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58", + "inputs/R438-CERTIFICATE.json": "6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c" + }, + "negative_controls": [ + "retirement_without_returned_idle", + "old_width8_stock_for_five_width4_terminals", + "rank46_under_two_level_guard", + "rank64_as_actual_recursive_child", + "corrupted_frozen_word_digest" + ], + "no_new_kappa": true, + "optimistic_roots": { + "conservative_fallback": { + "decimal_lower": "0.00196293883948", + "decimal_upper": "0.001962938839481", + "lower": "49073470987/25000000000000", + "lower_excess": { + "decimal_lower": "-7.55523835561338519793726536E-12", + "decimal_upper": "-7.55523835561338519793726536E-12", + "lower": "-69170273031128404522130725351458126356504407250530789822596919001/9155273437500000000000000000000000000000000000000000000000000000000000000000", + "upper": "-2593885238667315169579902200679679738368915271893589626968592214807/343322753906250000000000000000000000000000000000000000000000000000000000000000" + }, + "upper": "1962938839481/1000000000000000", + "upper_excess": { + "decimal_lower": "1.06768933259942253597592488E-11", + "decimal_upper": "1.06768933259942253597592488E-11", + "lower": "488749389312479798572963661816179608754710057178271227747285419151/45776367187500000000000000000000000000000000000000000000000000000000000000000", + "upper": "1832810209921799244648613731810673532830162714419175475214738906619/171661376953125000000000000000000000000000000000000000000000000000000000000000" + } + }, + "native_no_fallback": { + "decimal_lower": "0.00196293884161", + "decimal_upper": "0.001962938841611", + "lower": "196293884161/100000000000000", + "lower_excess": { + "decimal_lower": "-1.32919478098025826303150864E-11", + "decimal_upper": "-1.32919478098025826303150864E-11", + "lower": "-1993792171470387394547262955647744970326299827428949381/150000000000000000000000000000000000000000000000000000000000000000", + "upper": "-797516868588154957818905182259097988130519930971349941/60000000000000000000000000000000000000000000000000000000000000000" + }, + "upper": "1962938841611/1000000000000000", + "upper_excess": { + "decimal_lower": "4.94018387177857926517370731E-12", + "decimal_upper": "4.94018387177857926517370731E-12", + "lower": "1482055161533573779552112193127534173248509624472654089/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "370513790383393444888028048281883543312127406118451169/75000000000000000000000000000000000000000000000000000000000000000" + } + } + }, + "python": "3.14.6 (main, Jun 10 2026, 10:03:53) [Clang 21.0.0 (clang-2100.0.123.102)]", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "scope": "All-parameter written proof plus exact rational endpoint checks; no native, precision, chronological owner or outer admission. Fixed H and unchanged one-unpaid-coordinate coverage. No new kappa.", + "status": "PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS", + "targets": [ + { + "b": "1/500", + "complete_optimistic_excess_per_call": { + "decimal_lower": "0.675747514950634313488383535", + "decimal_upper": "0.675747514950634313488383535", + "lower": "463998995556313234054218430552007658287351674326678643553535475623894206572829/686645507812500000000000000000000000000000000000000000000000000000000000000000", + "upper": "15466633185210441135140614351733588609578389144222621451784603520221726368943/22888183593750000000000000000000000000000000000000000000000000000000000000000" + }, + "max_retirement_gain_per_call_vs_old_ideal": { + "decimal_lower": "0.0971178207466979352393869504", + "decimal_upper": "0.0971178207466979352393869504", + "lower": "22228505114753250558331363771341962512816173606086877078110158249189204224893/228881835937500000000000000000000000000000000000000000000000000000000000000000", + "upper": "66685515344259751674994091314025887538448520818260631234335734713082781690611/686645507812500000000000000000000000000000000000000000000000000000000000000000" + }, + "without_fallback_excess_per_call": { + "decimal_lower": "0.675747476104470106690107451", + "decimal_upper": "0.675747476104470106690107451", + "lower": "202724242831341032007032235432394284655358713543180599854355112843/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "2027242428313410320070322354323942846553587135431805998543562619/3000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "b": "3/1000", + "complete_optimistic_excess_per_call": { + "decimal_lower": "18.9419819069957543419643958", + "decimal_upper": "18.9419819069957543419643958", + "lower": "1445158531722698542935516034704019185261814075280879084435110529900416063278769/76293945312500000000000000000000000000000000000000000000000000000000000000000", + "upper": "13006426785504286886419644312336172667356326677527911759915997400713852007520007/686645507812500000000000000000000000000000000000000000000000000000000000000000" + }, + "max_retirement_gain_per_call_vs_old_ideal": { + "decimal_lower": "0.145904693062107438627772367", + "decimal_upper": "0.145904693062107438627772367", + "lower": "6261550128741106737375027182473368227918698917865129429258652913032415347189/42915344238281250000000000000000000000000000000000000000000000000000000000000", + "upper": "5565822336658761544333357495531882869261065704769003937119094990485195644567/38146972656250000000000000000000000000000000000000000000000000000000000000000" + }, + "without_fallback_excess_per_call": { + "decimal_lower": "18.9419818679876970661660371", + "decimal_upper": "18.9419818679876970661660371", + "lower": "5682594560396309119849811121755345006795553601149937428689836479109/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "5682594560396309119849811121755345006795553601149937428689837628877/300000000000000000000000000000000000000000000000000000000000000000" + } + }, + { + "b": "1/200", + "complete_optimistic_excess_per_call": { + "decimal_lower": "55.6656543107476896324751170", + "decimal_upper": "55.6656543107476896324751170", + "lower": "38222571471918427024252018208270504700419941250012992672094784596079363913309301/686645507812500000000000000000000000000000000000000000000000000000000000000000", + "upper": "6370428578653071170708669701378417450069990208335498778682464537677020249634127/114440917968750000000000000000000000000000000000000000000000000000000000000000" + }, + "max_retirement_gain_per_call_vs_old_ideal": { + "decimal_lower": "0.243936503451183236625790703", + "decimal_upper": "0.243936503451183236625790703", + "lower": "18610878254027041368544822895346677273242525385556899495879263111714742938911/76293945312500000000000000000000000000000000000000000000000000000000000000000", + "upper": "167497904286243372316903406058120095459182728470012095462918627970947855466131/686645507812500000000000000000000000000000000000000000000000000000000000000000" + }, + "without_fallback_excess_per_call": { + "decimal_lower": "55.6656542714138193177548744", + "decimal_upper": "55.6656542714138193177548744", + "lower": "16699696281424145795326462328640110889076196465040866008247669396779/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "4174924070356036448831615582160027722269049116260216502061917636459/75000000000000000000000000000000000000000000000000000000000000000" + } + } + ], + "unbuilt_depth11_rank60_target_002_excess_per_call": { + "decimal_lower": "-0.00231398661483780488008181456", + "decimal_upper": "-0.00231398661483780488008181456", + "lower": "-529629504738877459735522742315153485489942820313131666008515319829120961059/228881835937500000000000000000000000000000000000000000000000000000000000000000", + "upper": "-105925900947775491947104548463030697097988564062626333201527731781985228243/45776367187500000000000000000000000000000000000000000000000000000000000000000" + }, + "word": { + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 39, + "5": 102, + "6": 11, + "7": 18 + }, + "adds": 36005, + "copies7": 9, + "helpers4": 5, + "helpers8": 433, + "mass": 5101, + "private_fields": 1 + } +} diff --git a/research/bit-five-rank4-terminals/moment/WINDOW-PROOF.md b/research/bit-five-rank4-terminals/moment/WINDOW-PROOF.md new file mode 100644 index 0000000000..1652028e52 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/WINDOW-PROOF.md @@ -0,0 +1,200 @@ +# Fixed controller: all-depth obstruction for the five-terminal BIT word + +This strengthens `PROOF.md`: **with the pinned controller's public touch +chronology, the frozen five-terminal local histogram cannot reach b=.002 +at any halving depth or any permitted odd arity**, even after granting +fractional owners, arbitrary dedicated full-progress helper stock, zero +fallback/adapters, and full-rank idle work on that dedicated stock. +Consequently `.002/.003/.005` joint targets through an outer map K0 put `u=(m/R(L))^b>1`. Ignoring fallback and all adapters, the actual +raw excess is bounded below by + +``` +A_m(b) + (T-C+q)u + (mX-q) - m(w+X) + = A_m(b) + (T-C)u - mw + q(u-1). +``` + +The extra stock X cancels only because its idle work has been granted the +unrealistically favorable unit cost. The coefficient of q remains positive. +Hence the minimum is attained at qmin. For L=5,7 this minimum becomes +`A_m(b)-C-(w-63)`, as in the earlier proof. At the formal L=3 case there are +no public idle slots (R=0): all3484 helper-progress ranks must use dedicated +stock, giving the same expression directly, without dividing by R. +At L≥9, qmin=0; moving any +helpers to extra banks only increases this lower bound. This covers added +full-progress stock without incorrectly assuming its idle ranks obey the +public source-window cap. + +It does not cover auxiliary streams having a new useful partial-progress +endpoint instead of complete progress m; that is a changed recursive contract. + +## All arities, independently of depth + +At L≥9 define `I=T-C=777L-5815=111m-5926` and + +``` +E(L,b)=A_m(b)-C-(w-63) + J(m,b), +J(m,b)=I*((m/(m-22))^b-1). +``` + +Fix b=.002. For every 00` and `f(x)=(1+x)^b-1`. Then + +``` +J=2442*f(x)/x - 3484*f(x). +``` + +The function f is increasing and concave with f(0)=0, so f(x)/x is +nonincreasing in x. As m increases, x decreases: both displayed terms are +therefore nondecreasing, and the second is strictly increasing. In particular +`dJ/dL≥0`. Since `A_m(b)≥C`, + +``` +dE/dL ≥ 7bC/(7L+1)-111/L². +``` + +At b=1/500, multiply by the positive `L²(7L+1)` and write L=13+y. The +numerator becomes + +``` +(928483 + 539882*y + 35707*y²)/500, +``` + +whose coefficients are all positive. Hence E increases on every real L≥13. +Exact rational interval checks for the remaining odd starting cases give: + +| L | favorable excess per local invocation at b=.002 | +|---|---:| +|3| >13.5540428589069553897 | +|5| >3.8049595866973275552 | +|7| >.8340592145604612887 | +|9| >.8384204496318681522 | +|11| >1.4470054318573842990 | +|13| >2.1235527765277093862 | + +These signs and monotonicity prove failure for every odd L≥3 in the stated +source coverage/chronology model. Each fixed-L complete bill is increasing in +b, so every b≥.002 also fails. No halving guard was used. + +At fixed L=9, the ideal rank42 remainder root, with the inherited fallback, +lies strictly between `.001954220766879` and `.001954220766880`. This is a +lower-bound invoice's root, not an attained BIT exponent. Actual integral +owners, windows, extra children, precision and native execution can reduce +feasibility further. + +## Remaining boundary and reproduction + +This result leaves changed public chronology, legal fusion across old idle +intervals with a new paid operator, new useful partial-progress auxiliary +contracts, changed coverage/unpaid directions, changed local H, reduced COPY +work and complete caller redesign outside its scope. An adapter that changes +one of those premises must be constructed and fully charged. It cannot be +silently assigned the old source's stock or chronology. + +Dynamic precision128/256, or a different valid precision charge, does not by +itself invalidate this obstruction. Precision-cap failure is not used here. +The scalar word remains independently useful as a finite arbitrary-input +restored operator regardless of this failed joint-target screen. + +``` +python3 -B check_windows.py +python3 -O -B check_windows.py +``` + +`WINDOW-RESULT.json` binds source hashes, the complete nine-stage source +schedule, exact interval signs and the polynomial coefficients. Its arithmetic +engine is `check_moment.py`; the independent reviewer separately uses rational +nth-root bisection. These are written proofs and finite exact checks, not +formal-kernel certification or a full multiplication theorem. + +Apache-2.0; substantial OpenAI Codex assistance. No new κ. diff --git a/research/bit-five-rank4-terminals/moment/WINDOW-RESULT.json b/research/bit-five-rank4-terminals/moment/WINDOW-RESULT.json new file mode 100644 index 0000000000..8f8576781e --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/WINDOW-RESULT.json @@ -0,0 +1,361 @@ +{ + "all_L_proof": "WINDOW-PROOF.md: source formula, dedicated-stock minimization, concavity and positive shifted polynomial", + "b": "1/500", + "cases": [ + { + "L": 3, + "excess_per_call": { + "decimal_lower": "13.5540428589069553897486536", + "decimal_upper": "13.5540428589069553897486536", + "lower": "1355404285890695538974865362168956199469933442454473840276388748129/100000000000000000000000000000000000000000000000000000000000000000", + "upper": "135540428589069553897486536216895619946993344245447384027638905929/10000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 0 + }, + { + "L": 5, + "excess_per_call": { + "decimal_lower": "3.80495958669732755520652890", + "decimal_upper": "3.80495958669732755520652890", + "lower": "190247979334866377760326445171440502573625930368439431206363883349/50000000000000000000000000000000000000000000000000000000000000000", + "upper": "380495958669732755520652890342881005147251860736878862412728077859/100000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 14 + }, + { + "L": 7, + "excess_per_call": { + "decimal_lower": "0.834059214560461288736158167", + "decimal_upper": "0.834059214560461288736158167", + "lower": "116768290038464580423062143366102335181706534071326579090066056707/140000000000000000000000000000000000000000000000000000000000000000", + "upper": "291920725096161451057655358415255837954266335178316447725166230831/350000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 28 + }, + { + "L": 9, + "excess_per_call": { + "decimal_lower": "0.838420449631868152277021036", + "decimal_upper": "0.838420449631868152277021036", + "lower": "10061045395582417827324252436231255941224141393051876628112685227/12000000000000000000000000000000000000000000000000000000000000000", + "upper": "62881533722390111420776577726445349632650883706574228925704569933/75000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 42 + }, + { + "L": 11, + "excess_per_call": { + "decimal_lower": "1.44700543185738429905999465", + "decimal_upper": "1.44700543185738429905999465", + "lower": "198963246880390341120749263998996741411267539845640285552013970809/137500000000000000000000000000000000000000000000000000000000000000", + "upper": "318341195008624545793198822398394786258028063753024456883223404483/220000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 56 + }, + { + "L": 13, + "excess_per_call": { + "decimal_lower": "2.12355277652770938628364660", + "decimal_upper": "2.12355277652770938628364660", + "lower": "1380309304743011101084370286988970873665052719437970647328278333109/650000000000000000000000000000000000000000000000000000000000000000", + "upper": "2760618609486022202168740573977941747330105438875941294656564116739/1300000000000000000000000000000000000000000000000000000000000000000" + }, + "max_unsplit_public_idle_rank": 70 + } + ], + "checked_at_utc": "2026-10-19T08:35:17.136115+00:00", + "controller_path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "controller_sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "derivative_polynomial_at_L13": [ + "928483/500", + "269941/250", + "35707/500", + "0" + ], + "extra_stock_relaxation": "public idle=T-C+q>=0, dedicated idle=mX-q>=0; grant dedicated rankm; excess base+q(u-1); minimize q=max(0,C-T)", + "finite_source_transcription_controls": [ + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 35, + 37, + 39, + 41, + 43, + 45, + 47, + 49, + 51, + 53, + 55, + 57, + 59, + 61, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 77, + 79, + 81, + 83, + 85, + 87, + 89, + 91, + 93, + 95, + 97, + 99, + 101 + ], + "fixed_nine_stage_optimistic_roots": { + "inherited_fallback_lower_bound": { + "decimal_lower": "0.001954220766879", + "decimal_upper": "0.00195422076688", + "lower": "1954220766879/1000000000000000", + "lower_excess": { + "decimal_lower": "-1.55545843654284219243149246E-11", + "decimal_upper": "-1.55545843654284219243149246E-11", + "lower": "-830704426254264476548801212228980207445722527812332190442919804433/53405761718750000000000000000000000000000000000000000000000000000000000000000", + "upper": "-4984226557525586859292807273373881244674335166872765817370646057259/320434570312500000000000000000000000000000000000000000000000000000000000000000" + }, + "upper": "12213879793/6250000000000", + "upper_excess": { + "decimal_lower": "2.75839094521460309949840838E-12", + "decimal_upper": "2.75839094521460309949840838E-12", + "lower": "883883817283732072288003173414447790756456309767943651962768452731/320434570312500000000000000000000000000000000000000000000000000000000000000000", + "upper": "29462793909457735742933439113814926358548543658972365908321374069/10681152343750000000000000000000000000000000000000000000000000000000000000000" + } + }, + "native_no_fallback": { + "decimal_lower": "0.001954220769002", + "decimal_upper": "0.001954220769003", + "lower": "977110384501/500000000000000", + "lower_excess": { + "decimal_lower": "-5.85355073700600898500310841E-13", + "decimal_upper": "-5.85355073700600898500310841E-13", + "lower": "-87803261055090134775046626098385487554749714210434129/150000000000000000000000000000000000000000000000000000000000000000", + "upper": "-175606522110180269550093252196770975109499428419719201/300000000000000000000000000000000000000000000000000000000000000000" + }, + "upper": "1954220769003/1000000000000000", + "upper_excess": { + "decimal_lower": "1.77276202369155639837865848E-11", + "decimal_upper": "1.77276202369155639837865848E-11", + "lower": "5318286071074669195135975444981041087181411161144815929/300000000000000000000000000000000000000000000000000000000000000000", + "upper": "2659143035537334597567987722490520543590705580572982493/150000000000000000000000000000000000000000000000000000000000000000" + } + } + }, + "inputs": { + "inputs/FIVE-TERMINALS.json": "75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58", + "inputs/R438-CERTIFICATE.json": "6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c", + "inputs/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "maximum_unsplit_public_idle_rank": "7(L-3)=m-22", + "nine_stage_events": [ + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 0 + }, + { + "kind": "local", + "pair": 0, + "reverse": true, + "stage": 1 + }, + { + "kind": "idle", + "pair": 1, + "rank": 14, + "source_level": -1, + "target_level": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 0, + "reverse": false, + "stage": 2 + }, + { + "kind": "idle", + "pair": 1, + "rank": 7, + "source_level": 1, + "target_level": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "kind": "local", + "pair": 1, + "reverse": true, + "stage": 3 + }, + { + "kind": "idle", + "pair": 2, + "rank": 28, + "source_level": -1, + "target_level": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 1, + "reverse": false, + "stage": 4 + }, + { + "kind": "idle", + "pair": 2, + "rank": 7, + "source_level": 3, + "target_level": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "kind": "local", + "pair": 2, + "reverse": true, + "stage": 5 + }, + { + "kind": "idle", + "pair": 3, + "rank": 42, + "source_level": -1, + "target_level": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 2, + "reverse": false, + "stage": 6 + }, + { + "kind": "idle", + "pair": 3, + "rank": 7, + "source_level": 5, + "target_level": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "kind": "local", + "pair": 3, + "reverse": true, + "stage": 7 + }, + { + "kind": "local", + "pair": 3, + "reverse": false, + "stage": 8 + }, + { + "kind": "idle", + "pair": 0, + "rank": 42, + "source_level": 2, + "target_level": 8 + }, + { + "kind": "idle", + "pair": 1, + "rank": 28, + "source_level": 4, + "target_level": 8 + }, + { + "kind": "idle", + "pair": 2, + "rank": 14, + "source_level": 6, + "target_level": 8 + }, + { + "kind": "idle", + "pair": 3, + "rank": 0, + "source_level": 8, + "target_level": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "exchange" + } + ], + "no_new_kappa": true, + "rank_formula": "two copies of14j for j=1..K-1; K-1 copies of7; L=2K+1", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_domain": "CLI guard is odd L>=5, but NAMES limits named emitted layouts to5,7,9,11,13; all-odd scope is the written recipe proof; formal L=3 is an auxiliary case", + "status": "PASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION", + "supersedes": "depth11/rank60 is a favorable arithmetic screen requiring changed chronology; it is unavailable in the pinned public windows" +} diff --git a/research/bit-five-rank4-terminals/moment/check_moment.py b/research/bit-five-rank4-terminals/moment/check_moment.py new file mode 100644 index 0000000000..3e518cbf11 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/check_moment.py @@ -0,0 +1,295 @@ +#!/usr/bin/env python3 +"""Exact necessary screens for the frozen five-terminal BIT word. + +No floats decide signs. No producer/checker modules are imported. Frozen inputs +are authenticated and read only. This is not an operator or native admission. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from collections import Counter +from datetime import datetime, timezone +from decimal import Decimal, localcontext +from fractions import Fraction as Q +from functools import lru_cache +from math import isqrt +from pathlib import Path +import gzip +import hashlib +import json +import subprocess +import sys + +HERE = Path(__file__).resolve().parent +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +SCALE = 10**65 +H = {1:1322, 2:1342, 3:79, 4:39, 5:102, 6:11, 7:18} +C = 5101 +PINS = {} + +def need(ok, msg): + if not ok: + raise ValueError(msg) + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + +def read(path, expected=None): + raw = Path(path).read_bytes() + got = digest(raw) + need(expected is None or got == expected, 'input digest: '+str(path)) + PINS[str(Path(path).relative_to(HERE))] = got + return raw + +def pinned(path): + known = { + 'research/r438-native-rehost/CERTIFICATE.json': + ('R438-CERTIFICATE.json','6da8c593257c8440f0fe35488d941715d953d715e2e464ffdfffff7ed31eee9c'), + 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py': + ('global_k.py','6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8'), + } + need(path in known,'declared portable source') + name,expected=known[path] + return read(HERE/'inputs'/name,expected) + +def authenticate(): + candidate=json.loads(read(HERE/'inputs/FIVE-TERMINALS.json', + '75e029f9bb6ca42540fa633b51bf2d8d62125c57a0ee184fbf3c94e08a8c7d58')) + local=candidate['literal_roundtrip_profile'] + need({int(r):n for r,n in local['H'].items()}==H,'candidate histogram') + need((local['mass'],local['ADDs'],local['COPYs'],local['private_fields']) + ==(5101,36005,9,1),'complete local inventory') + old=json.loads(pinned('research/r438-native-rehost/CERTIFICATE.json')) + need(old['local']['candidate']['profile']=={str(r):n+(5 if r==4 else 0) for r,n in H.items()},'predecessor profile') + invoice=old['pipeline']['candidate']['hosted']['invoice'] + need(invoice['bit']['live']==28416 and invoice['replicas']==32 and invoice['stages']==9,'predecessor stock') + need(invoice['bit']['rank_mass']==1808352,'predecessor global mass') + need(sum(r*n for r,n in H.items())==C==111*14+433*8+5*4+63,'local mass identity') + return {'source_mode':'portable pinned profile, R438 certificate and controller', + 'operator_validation':'separate finite-word producer and independent audit; not executed here', + 'word_decompressed_sha256_provenance':'3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a'} + +def emit_result(name,out): + import argparse + parser=argparse.ArgumentParser(description='Check shipped exact mathematical evidence; --write regenerates it.') + parser.add_argument('--write',action='store_true') + args=parser.parse_args() + path=HERE/name + if args.write: + path.write_text(json.dumps(out,indent=2,sort_keys=True)+'\n') + return + saved=json.loads(path.read_bytes()) + def mathematical(value): + value=json.loads(json.dumps(value)) + # Runtime provenance varies across environments; every source digest, + # arithmetic endpoint, scope field and control remains compared. + value.pop('checked_at_utc',None) + value.pop('python',None) + return value + need(mathematical(saved)==mathematical(out),'shipped mathematical result differs: '+name) + +def down(q): + return Q((q*SCALE).__floor__(),SCALE) + +def up(q): + return Q((q*SCALE).__ceil__(),SCALE) + +def plus(a,b): + return a[0]+b[0],a[1]+b[1] + +def minus(a,b): + return a[0]-b[1],a[1]-b[0] + +def times(a,c): + return (a[0]*c,a[1]*c) if c>=0 else (a[1]*c,a[0]*c) + +def decimal(q): + with localcontext() as ctx: + ctx.prec=27 + return str(Decimal(q.numerator)/Decimal(q.denominator)) + +def interval(a): + return {'lower':str(a[0]),'upper':str(a[1]),'decimal_lower':decimal(a[0]),'decimal_upper':decimal(a[1])} + +@lru_cache(None) +def log_interval(x): + need(x>=1, 'log domain') + k=0 + while x>2: + x/=2 + k+=1 + def unit(y): + z=(y-1)/(y+1) + z2=z*z + power=z + total=Q(0) + for j in range(110): + total+=2*power/(2*j+1) + power*=z2 + # The omitted positive series starts at exponent221. + tail=2*power/(221*(1-z2)) + return down(total),up(total+tail) + return plus(unit(x),times(unit(Q(2)),k)) + +def exp_point(x): + need(0<=x=0 and 01: + mid=(lo+hi)//2 + v=fun(Q(mid,den)) + if v[1]<0: + lo=mid + elif v[0]>0: + hi=mid + else: + raise ValueError('insufficient endpoint separation') + return {'lower':str(Q(lo,den)),'upper':str(Q(hi,den)), + 'decimal_lower':decimal(Q(lo,den)),'decimal_upper':decimal(Q(hi,den)), + 'lower_excess':interval(fun(Q(lo,den))),'upper_excess':interval(fun(Q(hi,den)))} + +def poly_after_shift(b,depth,start): + # E'(L) >= 7bC/(7L+1) + 518b/depth - 111/L^2, + # since A>=C and log(2)>2/3. Coefficients of its positive denominator + # numerator after L=start+x are returned in ascending x order. + a=Q(0) if depth is None else 518*b/depth + p=[Q(-111),Q(-777),a+7*b*C,7*a] + from math import comb + return [sum(p[j]*comb(j,k)*start**(j-k) for j in range(k,4)) for k in range(4)] + +def independent_power_check(x,b): + # Independent exact integer/rational-power calibration for requested + # rational target exponents, no log/exp identities are used here. + need(b.denominator<=1000, 'calibration denominator') + lo,hi=power(x,b) + target=Q(x)**b.numerator + need(lo**b.denominator<=target<=hi**b.denominator,'exact rational power calibration') + +def negative_controls(): + controls=[] + def rejects(name,fn): + try: + fn() + except ValueError: + controls.append(name) + else: + raise ValueError('negative control accepted: '+name) + rejects('retirement_without_returned_idle',lambda:need(C+1158==6279,'missing20 idle ranks')) + rejects('old_width8_stock_for_five_width4_terminals',lambda:need(C==111*14+438*8+63,'inflated stock')) + rejects('rank46_under_two_level_guard',lambda:need(64**2>2*46**2,'halving guard')) + rejects('rank64_as_actual_recursive_child',lambda:need(0<64<64,'proper rank')) + rejects('corrupted_frozen_word_digest',lambda:need(digest(b'corrupt')=='3bca74a2a8427eb18e86566baa19de597f10d0bc40c30b7443febd499ee2189a','source corruption')) + return controls + +def main(): + auth=authenticate() + targets=[Q('0.002'),Q('0.003'),Q('0.005')] + rows=[] + old=Counter(H) + old[4]+=5 + for b in targets: + v=fixed_excess(b) + need(v[0]>0,'favorable fixed model must fail requested target') + nofallback=fixed_excess(b,surcharge=False) + saving=minus(fixed_excess(b,hist=old),v) + # Exact independent target-power verification for every used base. + for x in [Q(64,r) for r in H]+[Q(64,45),Q(64),Q(2)]: + independent_power_check(x,b) + rows.append({'b':str(b),'complete_optimistic_excess_per_call':interval(v), + 'without_fallback_excess_per_call':interval(nofallback), + 'max_retirement_gain_per_call_vs_old_ideal':interval(saving)}) + roots={'native_no_fallback':root_bracket(lambda b:fixed_excess(b,surcharge=False)), + 'conservative_fallback':root_bracket(fixed_excess)} + allarity=[] + for depth,start,cutoff in [(2,9,Q('0.002')),(10,11,Q('0.002')), + (None,13,Q('0.002019323862'))]: + checked=[] + for L in range(3,start+1,2): + v=relaxed_excess(L,cutoff,depth) + need(v[0]>0,'all-arity finite starting cases') + checked.append({'L':L,'excess_per_call':interval(v)}) + poly=poly_after_shift(cutoff,depth,start) + need(all(x>=0 for x in poly) and poly[0]>0,'all-arity derivative polynomial') + allarity.append({'depth':depth,'b':str(cutoff),'monotone_for_real_L_at_least':start, + 'positive_derivative_numerator_coefficients_in_L_minus_start':list(map(str,poly)), + 'finite_cases':checked}) + # An explicitly unbuilt alternative illustrates the coverage boundary. + need(64**11>2*60**11 and 64**10<=2*60**10,'depth11 threshold for rank60') + deeper=fixed_excess(Q('0.002'),cap=60) + need(deeper[1]<0,'depth11 fractional packing allowance') + capfree11=root_bracket(lambda b:relaxed_excess(11,b,None)) + out={'status':'PASS_FIVE_TERMINAL_FULL_MOMENT_NECESSARY_SCREENS', + 'checked_at_utc':datetime.now(timezone.utc).isoformat(),'python':sys.version, + 'scientific_pin':PIN,'authentication':auth,'inputs':PINS, + 'word':{'H':H,'mass':C,'helpers8':433,'helpers4':5,'adds':36005,'copies7':9,'private_fields':1}, + 'fixed_model':{'m':64,'stock_per_call':'296/3','total_mass_per_call':6279, + 'idle_mass_per_call':1178,'native_halving_rank_cap':45, + 'deficit_per_call':'107/3','local_child_count':sum(H.values()), + 'optimistic_fallback_call_count':str(sum(H.values())+Q(1178,45)), + 'extra_adapters':0,'meaning':'lower bound on actual bill; no owner realization'}, + 'targets':rows,'optimistic_roots':roots,'all_odd_arity_obstructions':allarity, + 'cap_free_L11_root':capfree11, + 'unbuilt_depth11_rank60_target_002_excess_per_call':interval(deeper), + 'negative_controls':negative_controls(), + 'scope':'All-parameter written proof plus exact rational endpoint checks; no native, precision, chronological owner or outer admission. Fixed H and unchanged one-unpaid-coordinate coverage. No new kappa.', + 'no_new_kappa':True} + emit_result('RESULT.json',out) + print(out['status']+' no_new_kappa') + print('native optimistic root:',roots['native_no_fallback']['decimal_lower'],roots['native_no_fallback']['decimal_upper']) + print('fallback optimistic root:',roots['conservative_fallback']['decimal_lower'],roots['conservative_fallback']['decimal_upper']) + for row in rows: + print('b='+row['b'],'raw excess/call='+row['complete_optimistic_excess_per_call']['decimal_lower']) + print('all odd L>=3: b=.002 impossible at depth<=10; b=.002019323862 impossible even with idle rank m') + print('depth11/rank60 unbuilt budget:',deeper and decimal(-deeper[1])) + +if __name__=='__main__': + main() diff --git a/research/bit-five-rank4-terminals/moment/check_windows.py b/research/bit-five-rank4-terminals/moment/check_windows.py new file mode 100644 index 0000000000..ef308bd1d7 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/check_windows.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +"""Source-bound idle-window cap and all-depth necessary moment screen. +Apache-2.0; substantial OpenAI Codex assistance. +""" +import ast +from collections import Counter +from datetime import datetime, timezone +from fractions import Fraction as Q +import json +from pathlib import Path +import check_moment as M + +SOURCE='research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py' +SHA='6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8' + +class ActiveAsserts(ast.NodeTransformer): + def visit_Assert(self,node): + return ast.copy_location(ast.Expr(value=ast.Call(func=ast.Name(id='need',ctx=ast.Load()), + args=[node.test,node.msg or ast.Constant('source assertion')],keywords=[])),node) + +def extracted_controller(raw): + tree=ast.parse(raw) + recipe=[n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='recipe'] + rules=[n for n in ast.walk(tree) if isinstance(n,ast.If) and ast.unparse(n.test)=='s % 2 == 1 and s <= 2 * K - 3'] + M.need(len(recipe)==len(rules)==1,'unique source recipe and idle rule') + def code(nodes): + body=ActiveAsserts().visit(ast.Module(body=nodes,type_ignores=[])) + return compile(ast.fix_missing_locations(body),SOURCE,'exec') + ns={'need':M.need} + exec(code(recipe),ns) + return ns['recipe'],code(rules) + +def schedule(L,recipe,rule): + M.need(L>=3 and L%2==1,'odd recipe domain') + K=(L-1)//2 + levels=[-1]*K + events=[] + for e in recipe(K): + if e['kind']=='local': + s,p=e['stage'],e['pair'] + M.need(levels[p]==s-1,'source stage levels') + levels[p]=s + events.append(dict(e)) + exec(rule,{'s':s,'K':K,'levels':levels,'schedule':events,'need':M.need}) + elif e['kind']=='bridge': + M.need(levels[e['dst']]==levels[e['src']],'source bridge levels') + events.append(dict(e)) + else: + M.need(e['kind']=='exchange' and levels==[2*K]*K,'source exchange levels') + events.append(dict(e)) + ranks=Counter(e['rank'] for e in events if e['kind']=='idle' and e['rank']) + expected=Counter({7:K-1}) + for j in range(1,K): + expected[14*j]+=2 + expected=+expected + M.need(ranks==expected,'closed-form public idle multiset') + M.need(sum(r*n for r,n in ranks.items())*Q(222,L)==777*(L-3),'public idle rank stock') + M.need(max(ranks,default=0)==7*(L-3),'public maximum window') + return events + +def window_excess(L,b): + m,w,extra,idle=M.geometry(L) + q=max(Q(0),M.C-(777*L-714)) + if not idle: + # Grant every required dedicated idle rank cost one per rank. + return M.minus(M.local_bill(m,b),(m*w+q,)*2) + unit=M.power(Q(m,m-22),b) + return M.minus(M.plus(M.local_bill(m,b),M.times(unit,idle)),(m*w,)*2) + +def main(): + M.authenticate() + raw=M.pinned(SOURCE) + M.need(M.digest(raw)==SHA,'controller pin') + recipe,rule=extracted_controller(raw) + controls={L:schedule(L,recipe,rule) for L in range(3,102,2)} + cases=[] + b=Q('0.002') + for L in (3,5,7,9,11,13): + v=window_excess(L,b) + M.need(v[0]>0,'all-depth starting inequality') + cases.append({'L':L,'max_unsplit_public_idle_rank':7*(L-3),'excess_per_call':M.interval(v)}) + poly=M.poly_after_shift(b,None,13) + M.need(all(x>=0 for x in poly) and poly[0]>0,'all-L monotone local pressure') + roots={'native_no_fallback':M.root_bracket(lambda a:M.fixed_excess(a,cap=42,surcharge=False)), + 'inherited_fallback_lower_bound':M.root_bracket(lambda a:M.fixed_excess(a,cap=42))} + M.need(60>max(e['rank'] for e in controls[9] if e['kind']=='idle'),'rank60 impossible in source windows') + out={'status':'PASS_FIXED_CONTROLLER_ALL_DEPTH_BIT_TARGET_OBSTRUCTION','checked_at_utc':datetime.now(timezone.utc).isoformat(), + 'scientific_pin':M.PIN,'controller_path':SOURCE,'controller_sha256':SHA, + 'source_domain':'CLI guard is odd L>=5, but NAMES limits named emitted layouts to5,7,9,11,13; all-odd scope is the written recipe proof; formal L=3 is an auxiliary case', + 'nine_stage_events':controls[9],'rank_formula':'two copies of14j for j=1..K-1; K-1 copies of7; L=2K+1', + 'maximum_unsplit_public_idle_rank':'7(L-3)=m-22', + 'finite_source_transcription_controls':list(controls), + 'all_L_proof':'WINDOW-PROOF.md: source formula, dedicated-stock minimization, concavity and positive shifted polynomial', + 'b':str(b),'cases':cases,'derivative_polynomial_at_L13':list(map(str,poly)), + 'fixed_nine_stage_optimistic_roots':roots, + 'extra_stock_relaxation':'public idle=T-C+q>=0, dedicated idle=mX-q>=0; grant dedicated rankm; excess base+q(u-1); minimize q=max(0,C-T)', + 'supersedes':'depth11/rank60 is a favorable arithmetic screen requiring changed chronology; it is unavailable in the pinned public windows', + 'inputs':M.PINS,'no_new_kappa':True} + here=Path(__file__).resolve().parent + M.emit_result('WINDOW-RESULT.json',out) + print(out['status']+' no_new_kappa') + print('source nine-stage public idle ranks:14,7,28,7,42,7,42,28,14,0') + print('all inherited odd arities, all depths, any full-progress extra stock: b>=.002 rejected') + print('rank42 inherited fallback root:',roots['inherited_fallback_lower_bound']['decimal_lower'],roots['inherited_fallback_lower_bound']['decimal_upper']) + print('b=.002 nine-stage excess:',cases[3]['excess_per_call']['decimal_lower']) + +if __name__=='__main__': + main() diff --git a/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-RESULT.json b/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-RESULT.json new file mode 100644 index 0000000000..885bde2716 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-RESULT.json @@ -0,0 +1,173 @@ +{ + "H": { + "1": 1322, + "2": 1342, + "3": 79, + "4": 39, + "5": 102, + "6": 11, + "7": 18 + }, + "all_parameter_argument": "WINDOW-REVIEW.md: q minimization, concavity, polynomial derivative and monotonicity in b", + "arithmetic": "exact integer-power root bisection and Fraction; no floating decisions", + "b": "1/500", + "derivative_coefficients_L_minus_13": [ + "928483/500", + "269941/250", + "35707/500" + ], + "endpoint_cases": [ + { + "L": 3, + "excess": [ + "13554042858906953361/1000000000000000000", + "6777021429453479231/500000000000000000" + ], + "m": 22, + "max_public_idle_rank": 0, + "qmin": "3484", + "remaining_public_idle_mass": "0" + }, + { + "L": 5, + "excess": [ + "1902479793348662177/500000000000000000", + "760991917339465891/200000000000000000" + ], + "m": 36, + "max_public_idle_rank": 14, + "qmin": "1930", + "remaining_public_idle_mass": "0" + }, + { + "L": 7, + "excess": [ + "1459603625480805551/1750000000000000000", + "5838414501923257911/7000000000000000000" + ], + "m": 50, + "max_public_idle_rank": 28, + "qmin": "376", + "remaining_public_idle_mass": "0" + }, + { + "L": 9, + "excess": [ + "251526134889559363/300000000000000000", + "2515261348895612467/3000000000000000000" + ], + "m": 64, + "max_public_idle_rank": 42, + "qmin": "0", + "remaining_public_idle_mass": "1178" + }, + { + "L": 11, + "excess": [ + "15917059750431176261/11000000000000000000", + "1989632468803907803/1375000000000000000" + ], + "m": 78, + "max_public_idle_rank": 56, + "qmin": "0", + "remaining_public_idle_mass": "2732" + }, + { + "L": 13, + "excess": [ + "27606186094860150603/13000000000000000000", + "13803093047430136317/6500000000000000000" + ], + "m": 92, + "max_public_idle_rank": 70, + "qmin": "0", + "remaining_public_idle_mass": "4286" + } + ], + "finite_transcription_cases": [ + 3, + 5, + 7, + 9, + 11, + 13, + 15, + 17, + 19, + 21, + 23, + 25, + 27, + 29, + 31, + 33, + 35, + 37, + 39, + 41, + 43, + 45, + 47, + 49, + 51, + 53, + 55, + 57, + 59, + 61, + 63, + 65, + 67, + 69, + 71, + 73, + 75, + 77, + 79, + 81, + 83, + 85, + 87, + 89, + 91, + 93, + 95, + 97, + 99, + 101 + ], + "input_context": { + "all_odd_L_domain": "written mathematical recipe extension; not a claim that the old CLI emits every L", + "named_layouts": [ + 5, + 7, + 9, + 11, + 13 + ], + "repository_path": "research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "sha256": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "source_execution": false + }, + "local_mass": 5101, + "nine_stage_fallback_excess": [ + "1343294544872862137956079535053/1602172851562500000000000000000", + "179105939316382959733255274367/213623046875000000000000000000" + ], + "nine_stage_idle_multiset": { + "7": 3, + "14": 2, + "28": 2, + "42": 2 + }, + "nine_stage_native_excess": [ + "251526134889559363/300000000000000000", + "2515261348895612467/3000000000000000000" + ], + "no_formal_kernel_proof": true, + "no_new_kappa": true, + "rank60_public_window_rejected": true, + "scope": "fixed stage/idle chronology, unchanged H and one-unpaid-coordinate coverage, any independent full-progress extra stock; no native admission", + "status": "PASS_INDEPENDENT_FIXED_WINDOW_ALL_DEPTH_REVIEW" +} diff --git a/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-VALIDATION.json b/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-VALIDATION.json new file mode 100644 index 0000000000..36ce356b29 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/WINDOW-INDEPENDENT-VALIDATION.json @@ -0,0 +1,17 @@ +{ + "absolute_run_or_git_runtime_dependency": false, + "checker_evidence": "finite exact rational identity/sign checks; all-parameter proof in WINDOW-REVIEW.md", + "corrupt_source_rejected_both_modes": true, + "explicit_failure_rejected_both_modes": true, + "inputs": { + "WINDOW-INDEPENDENT-RESULT.json": "39ec4d42d20e3008b7564dcfac675aeff39f5dd6bcd9ae14a288bd1b6a3bc7bd", + "check_window_independent.py": "f1284452ea9dc83424a11a86639a1ec7b9e83d765e8eea737b0c1f284343601a", + "global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8" + }, + "normal_optimized_identical": true, + "original_receipt_preserved": true, + "persistent_writes": false, + "relocated_two_file_check_passed": true, + "source_execution": false, + "status": "PASS_PORTABLE_INDEPENDENT_WINDOW_REVIEW" +} diff --git a/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW-CERTIFICATE.json b/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW-CERTIFICATE.json new file mode 100644 index 0000000000..9a98ebd5d4 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW-CERTIFICATE.json @@ -0,0 +1,45 @@ +{ + "all_parameter_argument": "source three-case idle formula; public/dedicated stock split with q minimization; concavity at b=1/500; positive derivative for all real L>=13; monotonicity in b", + "artifacts": { + "WINDOW-INDEPENDENT-RESULT.json": "39ec4d42d20e3008b7564dcfac675aeff39f5dd6bcd9ae14a288bd1b6a3bc7bd", + "WINDOW-INDEPENDENT-VALIDATION.json": "20fce6cb4c1ee3e5f6f37b9857351aac16e3b99f71f1877cf402528688478552", + "WINDOW-REVIEW.md": "3089127abc9f7e28d2cb3e0aa2d13438a9d29986a80bf5bd5c23238ecffd8e94", + "check_window_independent.py": "f1284452ea9dc83424a11a86639a1ec7b9e83d765e8eea737b0c1f284343601a", + "source-context/global_k.py": "6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8", + "validate_window_independent.py": "e7ff5629085d608ca5b464eafedfaf93ce8800a06f3c3ebe81efb31b7857fc9e" + }, + "claim": "At every odd integer L>=3, fixed H and public idle chronology with R=7(L-3), arbitrary independent full-progress added stock: the relaxed complete moment fails every b>=1/500, independently of halving depth.", + "finite_computation": "exact 500th-root integer-power bisection, six endpoint signs, exact derivative coefficients and 50 finite event-family checks", + "formal_kernel_proof": false, + "independent_endpoint_enclosures_contain_all_six_producer_intervals": true, + "limitations": [ + "No independent native admission or candidate operator reproof", + "No unchanged-coverage proof for a new chronology", + "No useful partial-progress auxiliary endpoint", + "Fine producer root bracket not independently recomputed digit by digit", + "No general BIT impossibility or new kappa" + ], + "material_mathematical_gaps_found": [], + "no_new_kappa": true, + "portable_files": [ + "check_window_independent.py", + "source-context/global_k.py" + ], + "portable_verification_files": [ + "validate_window_independent.py", + "WINDOW-INDEPENDENT-RESULT.json" + ], + "read_only_checker_default": "stdout only; no absolute run directory, mutable Git, imported or executed producer module, or persistent output write", + "reviewed_at_utc": "2026-10-19T08:37:50.635784+00:00", + "reviewed_producer_sources": { + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/PROOF.md": "b5f16406b0ee9305a51843f43f8bd7c625358e1365c072762a4a6ddbf6e223d0", + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/RESULT.json": "bd4e5f4dc22a6a938775ddc77e17dbd9959e766747d38fb86a92ed8320b82a3d", + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/WINDOW-PROOF.md": "4bac2a8826350061d8bd9eade8465f9a01989422d4027b5d2830506662fa016d", + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/WINDOW-RESULT.json": "0124fc8acea3483fb4aad6a24ea89520c6fba002b78d40cb05061052f5ad6df4", + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/check_moment.py": "0c6464f1009208d9d2c5b709fe4acd1d7a693595d33f9988b1a89957c354363b", + "/Users/ross/git/math/.research-automation/runs/bit-five-helper-owned-20261019T0813Z/moment/check_windows.py": "cdb18d83752364de321d82b65291472e68789f2f61b6bf1faa0b8fbabe2b6989" + }, + "source_scope_correction": "Original producer names only L=5,7,9,11,13 despite odd>=5 CLI guard; all-odd statement comes from written recipe extension. Corrected in reviewed producer proof.", + "status": "ACCEPTED_INDEPENDENT_WRITTEN_FIXED_WINDOW_ALL_DEPTH_PROOF", + "written_proof": "WINDOW-REVIEW.md" +} diff --git a/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW.md b/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW.md new file mode 100644 index 0000000000..0c1164d128 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/WINDOW-REVIEW.md @@ -0,0 +1,203 @@ +# Independent fixed-window all-depth moment review + +**Conclusion: the all-depth .002 obstruction is valid under the fixed +public-window model below. No material gap remains in the reviewed +`moment/WINDOW-PROOF.md`.** The earlier fractional rank60 screen requires a +changed public chronology or another changed premise. It is unavailable +in the pinned nine-stage public windows. + +This independent review credits the moment worker's `WINDOW-PROOF.md` and +`check_windows.py` for the proposed obstruction. It independently checks +the source rule, stock relaxation, concavity proof and decisive numerical +signs. The controller source is retained byte for byte, including its +authors, license and AI disclosures, in `source-context/global_k.py`. +That source credits DreamingOfClouds's odd-stage generalization, the +PR436/PR386 work of Zhihao Chen and eumemic, and chafreaky's integration and +routes, with their disclosed Claude/OpenAI assistance. The pending-axis +interpretation is inherited from the cited PR589 hosting contract. This +review is AI-assisted local mathematical work, with no publication or +upstream acceptance claim. + +## Portable inputs and read-only checker + +The independent checker needs only these two files, with their relative +layout preserved: + + check_window_independent.py + source-context/global_k.py + +Run `python3 -B check_window_independent.py`, or add `-O` for optimized +Python. It uses the Python standard library, writes its result to stdout, +and does not import or execute old producer modules, read an absolute run +directory, access Git, or overwrite any result file. Its historical source +identity is + + Git pin: 20ecf2891d80b5acf18d980b2164fb44ea7faa90 + path: research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/ + e8-r715-eleven-stage-whole/code/global_k.py + SHA256: 6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8 + +`WINDOW-INDEPENDENT-RESULT.json` preserves the original successful output. +`validate_window_independent.py` checks normal and optimized runs against +that receipt, explicit failures, and a relocated two-file copy. It writes +only stdout plus temporary files inside its own directory; the temporary +files are removed, and the preserved receipt is not updated. + +## Assumptions that carry the theorem + +Keep the exact five-terminal local histogram + + H={1:1322,2:1342,3:79,4:39,5:102,6:11,7:18}, C=5101, + +the one-unpaid-coordinate public coverage law, and the pinned ordering of +public touches, scalar bridges and idle intervals. For odd L>=3 set + + m=7L+1, w=111(L-1)/L, T=(m-1)w+63=777L-714. + +The local mass is 1554 public progress, 3484 helper progress, and63 COPY +mass. Public remainder children must lie within the original idle +intervals, including when helper hosting subdivides those intervals. +Additional independent stock is allowed but must perform full progress m +per field. No additional unpaid direction or useful partial-progress +auxiliary endpoint is granted. All omitted costs are nonnegative. + +The precise finite scalar word, its integer restoration, changed native +interface and physical admission are not re-proved here. The result is a +necessary moment bound conditional on this unchanged coverage/chronology +contract, not a universal theorem about all implementations of the word. + +## The source gives a depth-independent public rank cap + +Write L=2K+1. Inspection of all three branches of the pinned idle rule gives: + +1. Odd stages s=1,3,...,2K-3 advance an untouched pair from level -1 to s. + Their ranks are 7(s+1)=14,28,...,14(K-1). +2. Even stages s=2,4,...,2K-2 advance one level, producing K-1 ranks of7. +3. At final stage2K, pair j has level2j+2. Its terminal gap has rank + 7(2K-2j-2)=14(K-j-1), for j=0,...,K-1. + +The last terminal rank is zero. Thus each positive14j, 1<=j<=K-1, occurs +twice, and rank7 occurs K-1 times. Their maximum is + + R(L)=14(K-1)=m-22. + +The public idle mass per invocation is + + (222/L)[2 sum_(j=1)^(K-1)14j+7(K-1)]=777(L-3). + +Adding the local public and COPY progress gives T as above. For L=9, the +idle multiset is {7:3,14:2,28:2,42:2}; no original public interval has +rank60. A subspace left over after hosting in one interval cannot exceed +the dimension of that interval. A change in recursive depth does not +alter this dimensional fact. + +The source CLI asserts odd L>=5, but its NAMES table has only +{5,7,9,11,13}. The review reported this distinction, and the moment worker +corrected the source-scope statement. The mathematical three-case recipe +argument supplies the all-K extension. The formal L=3 recipe is included +as an additional favorable case, not a claimed named source emission. + +## Dedicated stock is relaxed separately and correctly + +Let q>=0 be helper progress moved out of public hosts into additional +full-progress stock X. Public leftover mass is T-C+q, and dedicated idle +mass is mX-q. Thus + + q>=qmin=max(0,C-T), mX>=q. + +It would be incorrect to impose the public cap R(L) on new dedicated +banks without a separate proof. Instead grant all dedicated idle work +price1 per rank, as if invalid rank-m recursive children were available. +This is a favorable lower bound at every depth. For L>=5 write +u=(m/(m-22))^b>1. The relaxed excess is + + A_m(b)+(T-C+q)u+(mX-q)-m(w+X) + =A_m(b)+(T-C)u-mw+q(u-1), + +where A_m(b)=sum H[r]r(m/r)^b. The variable X cancels only because its +idle work was assigned the favorable unit price. The positive q +coefficient makes qmin optimal. At L=5,7, qmin removes all public idle +mass and gives A_m-C-(w-63). At L=3, R=0 and every3484 helper-progress +rank must leave the public stock; the same expression follows directly, +without division by zero. At L>=9, qmin=0. All these qmin values lie in +the actual available helper-progress interval [0,3484]; relaxing that +upper bound would not improve the optimum anyway. + +This proves the extra-stock minimization uniformly for all X satisfying +the model, even before integral ownership or chronological restrictions +on dedicated banks are imposed. + +## All-odd-stage proof + +For L>=9 put I=T-C=111m-5926 and + + E(L,b)=A_m(b)-C-(w-63)+J(m,b), + J(m,b)=I[(m/(m-22))^b-1]. + +At fixed 0=0. The constants2442 and3484 are essential: this is the exact +rewriting of I, not a generic claim about arbitrary coverage models. + +At b0=1/500, A_m(b0)>=C and therefore + + E'(L,b0)>=7b0 C/(7L+1)-111/L^2. + +Multiplying by L^2(7L+1)>0 and writing L=13+y yields + + [928483+539882 y+35707 y^2]/500. + +Every coefficient is positive, so E increases for every real L>=13. +Exact positive endpoints at odd L=3,5,7,9,11,13 then cover all odd L>=3. +The concavity step is only needed at b0. For every fixed L the minimized +bill increases in b, because every nonzero priced rank has m/r>1; the +same qmin works for all b>0. Thus all b>=.002 fail, including .003 and +.005, without extending the concavity claim to b>=1. + +No halving-depth guard appears in this proof. It consequently covers all +depths within the fixed public chronology and full-progress-stock model. + +## Independent finite checks and exact domain + +`check_window_independent.py` checks the three source branches and the +actual NAMES dictionary under the exact source hash. It independently +enumerates the three event families for odd L=3,...,101 and verifies the +closed-form multiset, maximum and total mass. This is a finite +transcription check. The written three-branch argument, not those50 +instances, proves the formula for every K>=1. + +The independent numerical engine computes each needed x^(1/500) between +consecutive rationals with denominator10^18. Every branch is decided by +an exact integer500th-power comparison. No log, exp, floating point or +producer interval routine is used. It verifies all six positive base +cases and the derivative coefficients. Its nine-stage native lower bound +is greater than .8384204496318645 raw units per invocation. The slightly +wider independent enclosure contains the producer's finer result. The +checker also confirms a positive rank42 invoice with the stipulated +fallback, while detecting that rank60 exceeds every pinned public window. + +This review accepts the producer's precise root bracket as its own exact +interval result; it does not independently reproduce every root digit. +The decisive .002 signs and all-parameter inequalities are independently +checked here. There is no formal-kernel proof and no exhaustive +construction search. + +## Remaining boundaries + +This result does not cover changed public touch chronology, a constructed +and paid fusion across old intervals, additional unpaid dimensions, +partial-progress auxiliary contracts, changed local H or COPY bill, or +different public endpoints. It does not infer native execution or +precision from the scalar word. Replacing an invalid fixed precision cap +by a correct charged precision theorem does not alone change this +moment obstruction. + +The joint-kappa consequence is conditional on the separate outer transfer +requiring a common supplier exponent b strictly above the desired kappa. +That outer theorem is not re-proved here. No new kappa or general BIT +impossibility follows. diff --git a/research/bit-five-rank4-terminals/moment/independent/check_window_independent.py b/research/bit-five-rank4-terminals/moment/independent/check_window_independent.py new file mode 100644 index 0000000000..835d2c2e3c --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/check_window_independent.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +"""Portable independent check of fixed public-window moment obstruction. + +Only input fixture: source-context/global_k.py, exact historical source. +No producer module is imported or executed. Rational nth-root enclosures +use integer powers; no logarithms, exponentials or floating-point decisions. +The all-parameter proof is WINDOW-REVIEW.md, not this finite computation. +Apache-2.0; substantial OpenAI Codex assistance. +""" +import ast +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +import hashlib +import json +from math import comb +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +SOURCE_SHA = '6368196a393ac25bb2918880e4c4bd31ed733b762c27b6873ab391cbc0c5c3c8' +PIN = '20ecf2891d80b5acf18d980b2164fb44ea7faa90' +SOURCE_PATH = 'research/e8-bit-p111-tuned/vendor/pr510/e8-r480-nine-stage/vendor/e8-r715-eleven-stage-whole/code/global_k.py' +H = {1:1322, 2:1342, 3:79, 4:39, 5:102, 6:11, 7:18} +C = sum(r*n for r, n in H.items()) +SCALE = 10**18 + + +def need(ok, message): + if not ok: + raise RuntimeError(message) + + +@lru_cache(None) +def root500(x): + x = Q(x) + need(x >= 1, 'positive root domain') + target = x.numerator*pow(SCALE, 500) + lo, hi = SCALE, 2*SCALE + while pow(hi, 500)*x.denominator <= target: + hi *= 2 + while hi-lo > 1: + mid = (lo+hi)//2 + if pow(mid, 500)*x.denominator <= target: + lo = mid + else: + hi = mid + need(pow(lo, 500)*x.denominator <= target < pow(hi, 500)*x.denominator, + 'exact rational 500th root enclosure') + return Q(lo, SCALE), Q(hi, SCALE) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def scale(a, c): + return (a[0]*c, a[1]*c) if c >= 0 else (a[1]*c, a[0]*c) + + +def local(m): + out = Q(0), Q(0) + for r, n in H.items(): + out = add(out, scale(root500(Q(m, r)), r*n)) + return out + + +def encoded(x): + return list(map(str, x)) + + +def source_context(): + raw = (HERE/'source-context/global_k.py').read_bytes() + need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA, 'frozen source SHA256') + tree = ast.parse(raw) + names = next(n for n in tree.body if isinstance(n, ast.Assign) and + any(isinstance(t, ast.Name) and t.id == 'NAMES' for t in n.targets)) + named_layouts = sorted(ast.literal_eval(names.value)) + need(named_layouts == [5, 7, 9, 11, 13], 'actual named producer layouts') + # No source execution. These checks bind the three branches reviewed in + # the all-K written argument to the pinned file, including elif tails. + rules = [n for n in ast.walk(tree) if isinstance(n, ast.If) and + ast.unparse(n.test) == 's % 2 == 1 and s <= 2 * K - 3'] + need(len(rules) == 1, 'unique public idle rule') + first = rules[0] + second = first.orelse[0] + third = second.orelse[0] + need(isinstance(second, ast.If) and + ast.unparse(second.test) == 's % 2 == 0 and 2 <= s <= 2 * K - 2', 'middle idle rule') + need(isinstance(third, ast.If) and ast.unparse(third.test) == 's == 2 * K', 'terminal idle rule') + return {'scientific_pin': PIN, 'repository_path': SOURCE_PATH, + 'sha256': SOURCE_SHA, 'named_layouts': named_layouts, + 'source_execution': False, + 'all_odd_L_domain': 'written mathematical recipe extension; not a claim that the old CLI emits every L'} + + +def windows(L): + K = (L-1)//2 + # Explicit enumeration of the three disjoint event families in the + # source rule: early gaps, one-step gaps, terminal completions. + early = [7*(s+1) for s in range(1, 2*K-2, 2)] + middle = [7 for s in range(2, 2*K-1, 2)] + terminal = [7*(2*K-(2*j+2)) for j in range(K)] + actual = Counter(r for r in early+middle+terminal if r) + expected = Counter({7: K-1}) + for j in range(1, K): + expected[14*j] += 2 + need(+actual == +expected, 'all event families match closed formula') + need(max(actual, default=0) == 7*(L-3), 'largest public idle rank') + need(sum(r*n for r, n in actual.items()) == 7*(K-1)*L, 'total source idle rank') + return dict(sorted(actual.items())) + + +def endpoint(L): + m = 7*L+1 + w = Q(111*(L-1), L) + t = 777*L-714 + qmin = max(Q(0), C-t) + idle = t-C+qmin + need(0 <= qmin <= 3484, 'required moved helper progress') + need(t == 1554+63+777*(L-3), 'coverage from public local, COPY and idle progress') + if idle == 0: + # Includes L=3: no public idle window exists, so never divide by R=0. + out = add(local(m), (-m*w-qmin,)*2) + else: + need(m > 22, 'positive public idle capacity') + out = add(local(m), scale(root500(Q(m, m-22)), idle)) + out = add(out, (-m*w,)*2) + need(out[0] > 0, 'fixed-window target failure') + return {'L':L, 'm':m, 'qmin':str(qmin), 'remaining_public_idle_mass':str(idle), + 'max_public_idle_rank':m-22, 'excess':encoded(out)} + + +def main(): + if '--force-failure' in sys.argv: + need(False, 'forced explicit window failure') + need(C == 5101 and C == 1554+3484+63, 'local progress accounting') + context = source_context() + controls = {L:windows(L) for L in range(3, 102, 2)} + cases = [endpoint(L) for L in (3,5,7,9,11,13)] + b = Q(1,500) + p = [-Q(111), -Q(777), 7*b*C] + shifted = [sum(p[j]*comb(j,k)*13**(j-k) for j in range(k,3)) for k in range(3)] + need(all(c > 0 for c in shifted), 'positive derivative for every real L>=13') + need(shifted == [Q(928483,500), Q(269941,250), Q(35707,500)], 'independent polynomial values') + native42 = add(local(64), scale(root500(Q(64,42)),1178)) + native42 = add(native42,(-Q(18944,3),)*2) + calls = sum(H.values())+Q(1178,42) + total42 = add(native42,scale(root500(Q(64)),Q(32*64**2,10**16)*calls)) + need(total42[0] > native42[0] > 0, 'rank42 native and fallback lower bounds') + need(60 > max(map(int, controls[9])), 'rank60 lies outside every old nine-stage public window') + out = {'status':'PASS_INDEPENDENT_FIXED_WINDOW_ALL_DEPTH_REVIEW', + 'input_context':context, 'b':'1/500', 'H':H, 'local_mass':C, + 'finite_transcription_cases':list(controls), 'nine_stage_idle_multiset':controls[9], + 'endpoint_cases':cases, 'derivative_coefficients_L_minus_13':list(map(str, shifted)), + 'nine_stage_native_excess':encoded(native42), + 'nine_stage_fallback_excess':encoded(total42), + 'rank60_public_window_rejected':True, + 'all_parameter_argument':'WINDOW-REVIEW.md: q minimization, concavity, polynomial derivative and monotonicity in b', + 'scope':'fixed stage/idle chronology, unchanged H and one-unpaid-coordinate coverage, any independent full-progress extra stock; no native admission', + 'arithmetic':'exact integer-power root bisection and Fraction; no floating decisions', + 'no_formal_kernel_proof':True, 'no_new_kappa':True} + print(json.dumps(out, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/bit-five-rank4-terminals/moment/independent/source-context/global_k.py b/research/bit-five-rank4-terminals/moment/independent/source-context/global_k.py new file mode 100644 index 0000000000..3df12bd632 --- /dev/null +++ b/research/bit-five-rank4-terminals/moment/independent/source-context/global_k.py @@ -0,0 +1,264 @@ +# Generalised from PR #443's global_kernel.py to an arbitrary odd stage count S = 2K+1 (compressed window m = 1+7S) +# by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. At the defaults (S = 9, 32 replicas) the emitted +# GLOBAL-TEMPLATE.json.gz and GLOBAL.json equal PR #443's (GLOBAL.json except wall-clock seconds). +# Kernel integration of PR436/PR386 by chafreaky, with OpenAI Codex assistance. +# Original copyright and attribution retained below. This variant uses explicit +# residual isometries and mixed-width banks; the original all-zero-start +# requirement is replaced by the verified kernel entrance contract. +"""Source-bound compressed S-stage (S = 2K+1 odd, default 9) bit template with independent replicas. +PR386 global identity and PR436 generalization by Zhihao Chen and eumemic, +with their disclosed OpenAI Codex and Anthropic Claude assistance, Apache-2.0. +PR439 explicit residual routes and this replication extension by chafreaky, +with OpenAI Codex assistance. All owner assignments and emitted calls are checked. +Historical PR386 regression is performed by the unchanged parent wrapper. +""" +import argparse, gzip, hashlib, json, struct, time +from collections import Counter +from pathlib import Path +import os, sys +sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../e8-r740-replica32/code')) +from bank_routes_k import placement, validate_isometries +from config import REPLICAS + +H,L,K,T,M=8,9,4,REPLICAS,64 # overwritten in main() from --stages / --replicas +NAMES={5:'FIVE',7:'SEVEN',9:'NINE',11:'ELEVEN',13:'THIRTEEN'} +def sha(p): return hashlib.sha256(p.read_bytes()).hexdigest() +def write(p,x): p.write_text(json.dumps(x,indent=2)+'\n') + +def recipe(K): + out=[dict(kind='local',stage=0,pair=0,reverse=False)]; stage=1 + for j in range(K): + out.append(dict(kind='local',stage=stage,pair=j,reverse=True)); stage+=1 + if j=5 and a.stages%2==1; L=a.stages; K=(L-1)//2; T=a.replicas; M=1+7*L; NOBANK=a.no_banks + if L!=9: assert NOBANK, 'bank tiling is only emitted for the nine-stage layout; use --no-banks and host every residual' + DEFICIT=T*(2*K*120-9*H*L) + wp=a.word; w=json.loads(gzip.decompress(wp.read_bytes()) if wp.suffix=='.gz' else wp.read_bytes()) + V,R=w['v'],w['R']; LOCAL=2*V+R; DATA=2*K*V*T; LIVE=DATA+L*R + assert (w['h'],V,w['form'])==(8,120,'/2') + geo=json.loads((out/'GEOMETRY.json').read_text()) + assert geo['status']=='PASS_COMPRESSED_%s_BIT_GEOMETRY_AND_BANK_BLOCKS'%NAMES[L] and geo['stages']==L and geo['m']==M + # the port routes depend only on the labels: same 120 label vectors, in the same order + assert len(geo['ports'])==V and all(p['port']==t and p['q']==w['lines'][t] for t,p in enumerate(geo['ports'])) + rp=a.local_check/'records/249-records.bin'; raw=rp.read_bytes(); rec=list(struct.iter_unpack('<6i',raw)) + state=json.loads((a.local_check/'records/249-states.json').read_text()) + fs=json.loads((a.local_check/'records/frames.json').read_text())['frames'] + dims={int(f):z['dim'] for f,z in fs.items()} + lg=json.loads((a.local_check/'cout/legality.json').read_text()) + cc=json.loads((a.local_check/'cout/columns.json').read_text()) + assert lg['status'].startswith('PASS') and cc['status'].startswith('PASS') + assert (state['v'],state['n'])==(V,LOCAL) and lg['copies']==lg['erasures']==9 + ADDS=lg['common_frame_ADDs'] + assert cc['formal_columns_checked']==4*V+R and cc['local_scalar_additions']==ADDS + initial=[state['initial'][str(i)] for i in range(LOCAL)] + final=[state['final'][str(i)] for i in range(LOCAL)] + assert all(dims[final[i]]==H for i in range(2*V,LOCAL)) + widths=[H-dims[initial[i]] for i in range(2*V,LOCAL)] + ENT=sum(H-z for z in widths) + if NOBANK: place,NB=None,None; LIVE=DATA + else: + place,NB=placement(widths,T,M) + assert T%8==0 and T*(H*R-ENT)%M==0 and NB==T*(H*R-ENT)//M + LIVE=DATA+L*NB + isometries=json.loads(a.isometries.read_text()) + assert validate_isometries(isometries,w['frames'],w['lines'],dims)==set(initial[2*V:]) + streams={}; checks={}; localH=None + for reverse in (False,True): + cur=(final if reverse else initial)[:]+[-1]; val=[1<=0 + cur[x]=newf + if f: hist[f]+=1 + events.append([0,x,oldf,newf,f,int(reverse)]) + elif op==1: + assert cur[x]==cur[y]==f and x!=y and x