diff --git a/research/interleaved-basis-residual-audit/.gitattributes b/research/interleaved-basis-residual-audit/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/interleaved-basis-residual-audit/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/interleaved-basis-residual-audit/CERTIFICATE.json.gz b/research/interleaved-basis-residual-audit/CERTIFICATE.json.gz new file mode 100644 index 0000000000..cf779b3f47 Binary files /dev/null and b/research/interleaved-basis-residual-audit/CERTIFICATE.json.gz differ diff --git a/research/interleaved-basis-residual-audit/CREDITS.md b/research/interleaved-basis-residual-audit/CREDITS.md new file mode 100644 index 0000000000..543a0dee12 --- /dev/null +++ b/research/interleaved-basis-residual-audit/CREDITS.md @@ -0,0 +1,41 @@ +# Credit and exact source scope + +Ali Romman, with substantial OpenAI Codex assistance, supplied the interleaved +construction, rational journal and original witness/price checks in +[PR #7726](https://github.com/CrocSwap/integer-mult-bounds/pull/7726). +This package retains its 55 scientific files without change from +3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3. Read the source +[proof](https://github.com/aliromman/integer-mult-bounds/blob/3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3/research/p104-interleaved-helper-bases/PROOF.md), +[witness checker](https://github.com/aliromman/integer-mult-bounds/blob/3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3/research/p104-interleaved-helper-bases/witness.py) +and [credit](https://github.com/aliromman/integer-mult-bounds/blob/3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3/research/p104-interleaved-helper-bases/CREDITS.md). +The original source methods and counterexamples are not claimed as new here. + +The parent restrictions come from +[PR #7713](https://github.com/CrocSwap/integer-mult-bounds/pull/7713), with the +deposited stable-label graph from +[PR #7716](https://github.com/CrocSwap/integer-mult-bounds/pull/7716). The +physical comparator is [PR #7717](https://github.com/CrocSwap/integer-mult-bounds/pull/7717). +Clear1nsight supplied the causal split and banked relay; DreamingOfClouds +supplied the literal helper splits and signed-curvature correction; SYLforge +supplied the word and signed caller; Rohan Arun supplied caller lineage. +Jerry Chen / CubeJerry, Douglas Colkitt and the retained contributors supplied +the framework and verification engines. The source credit and notices give +their exact predecessor links and assistance records. + +[PR #7727](https://github.com/CrocSwap/integer-mult-bounds/pull/7727) supplies +DreamingOfClouds' banked-circuit toolkit and checks earlier constructions. +It was read for overlap. Its code and constants are not used here. Direct +linear residual certificates, acyclic linear systems, binary row reduction +and rational log/exponential bounds are standard methods. + +This contribution adds the explicit residual certificates, separate direct +checker, critical helper identity checks, complete event/histogram count and +rational price implementation. The source constructor remains shared. No +new author identity or independent human review is inferred from a separate +implementation or chat. + +Prepared by Ali Romman with substantial OpenAI Codex assistance in research, +implementation, verification and writing. Apache-2.0. Original source license, +NOTICE, CREDITS.md, manifests and all credits/ files remain unchanged under +retained/source. SOURCE-PINS.json binds their bytes. The copied original +VERIFY.json is source evidence; its full suite is not registered or run here. diff --git a/research/interleaved-basis-residual-audit/PROOF.md b/research/interleaved-basis-residual-audit/PROOF.md new file mode 100644 index 0000000000..6abcea9df3 --- /dev/null +++ b/research/interleaved-basis-residual-audit/PROOF.md @@ -0,0 +1,177 @@ +# Residual certificates for the three interleaved helper bases + +This audit reproduces the three requested restriction/split comparisons in +PR #7726. The chosen equations pass. The three alternate equations fail at +the stated coordinates. A separate count and rational price enclosure agree +with the complete invoice and the reported raw crossing bracket. No new +kappa is claimed. The selected frontier is unchanged. + +The source constructor is retained. The new checker does not use the source +witness evaluator, graph propagation routine or price engine to accept these +equations or prices. It checks explicit formal residual identities and full +response solutions. This is a separate implementation of one mathematical +check, with a shared constructor. It is not a blind review, an independently +implemented construction, independent human acceptance or a full admission. + +## Sources and exact scope + +The scientific source is commit 3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3. +Its deposited PR7713 graph has SHA-256 +`16e99893a2c669467ce74f214e8eb5150402f0267aaa8d67aad5d870aa4d5c18`. +The source restores stable labels, then applies its rational edit journal. +All 55 package files are retained without change and have exact byte pins. +The copied source manifest describes the original package. Its full replay +also requires external main-branch inputs; that full suite is not run here. +The constructor used here needs only the retained files. + +The restriction indices are zero-based 169, 137 and 91 for roles 1400, 1401 +and 1409. The associated split indices are 252, 253 and 254. Each test starts +at the exact prefix, with the chosen restriction or its deposited alternate. +No test substitutes a later graph or treats a retired helper as zero scratch. +The split prefixes have 1510, 1511 and 1512 independent formal input symbols. +These stable namespaces include the source's isolated retired identity roles. +They are not the compact final public-owner count. + +The local source/receiver equations are checked in their own orientations. +The first split is forward at chart 288. The other splits are transposed at +charts 288 and 306. The new checker forms the transposed scalar equations +directly and checks all source, receiver, pulse and output charts. A separate +heap-based topological sort checks every prefix for locality and cycles. + +## Formal coefficient certificates + +For each internal or terminal bank k, write its defining equation as +`E_k=z_k-sum_j a_kj*z_j`. Negative bank labels name independent entrance +symbols. All coefficients are exact rationals. A linear observation o has +entrance expansion s if the following formal identity holds: + +`sum_k lambda_k*E_k = o-sum_i s_i*x_i`. + +The certificate stores every nonzero multiplier lambda and every nonzero +entrance coefficient. The checker directly adds the defining equation rows +with these multipliers. It compares every resulting formal coefficient with +the right side. It does not propagate o backwards to decide acceptance. +Since every defining equation is zero during execution, the identity proves +the observation for all independent inputs. A missing nonzero coefficient +cannot be hidden by testing only selected inputs. + +The generator uses reverse substitution to propose multipliers. It is not +trusted for acceptance. The checker uses the direct residual identity above. +It applies this check to the source-minus-receiver restriction, the readout, +the calibration-minus-return-decoder relation, and the two helper output rows. +There are 30 such identities with 10484 nonzero multipliers in total. + +For a pulse b and entrance direction w, a response certificate gives a value +v for every nonzero bank. The checker substitutes it in every equation: +`v_k=b_k+sum_internal a_kj*v_j+sum_input a_ki*w_i`. +It does this in arbitrary bank-key order. The independently checked acyclic +graph makes the solution unique. The pulse check uses w=0. The steering check +uses b=0. Each is compared with the complete specified terminal direction, +including every zero terminal. The local readout and calibration must both +have zero pulse response for the chosen split. + +The audit also proves that each restricted and split helper is an isolated +identity summand at its actual prefix. Its output row equals its own input. +Its unit input produces one at that output and zero at every other output. +These row and column facts are required for surrendering that helper in the +source's restriction and split proofs. They are checked here rather than +inferred from the final compact graph. + +There are 24 response solutions, checked against 176320 defining equations. +The direct identity and response checks perform 4303065 exact coefficient +products. This count describes the finite check, not a tape or runtime bill. + +## Reproduced comparisons + +Both the chosen and alternate restriction equations are valid at their own +restriction prefixes. The alternate is not rejected merely because its +equation differs from the chosen certificate. The difference appears in the +later fixed split contract after the full intervening prefix is rebuilt. + +| Restriction | Split and orientation | Alternate failure | First coordinate | Actual minus required | +| --- | --- | --- | ---: | ---: | +| 1400 | 294, forward, chart 288 | 16 readout coefficients | input 10 | 1 | +| 1401 | 288, transpose, chart 288 | 16 response coefficients | output 11 | -2 | +| 1409 | 302, transpose, chart 306 | 27 response coefficients | output 25 | 1 | + +The required coefficient at each displayed coordinate is zero. Every other +coefficient is also compared. These failures match the deposited source +witness. They are counterexamples to these three alternate-prefix/fixed-split +combinations. They do not prove that the chosen relations are unique, optimal, +or necessary for every possible split. + +The chosen splits have nonzero triples `(s*w,y*t,t_r)` equal to +`(2,1/2,3)`, `(-4,1,1)` and `(-2,1/2,1/2)`. Their readouts and calibrations +have zero pulse feedback. The full steering response equals the full pulse +response in each chosen case. Thus the local algebraic hypotheses checked +here support the source's stated split formula. The unchanged main operator +and the correctness of all other edits remain source premises. + +## Complete invoice and independent price enclosure + +The retained constructor rebuilds the complete graph with SHA-256 +`ba59d5db17c40185c8608a734ced10135d8c041e432c3840e9034868781c31a2`. +The new count derives the 400 main roles from the deposited stable-label +map. The compact graph has 1260 public roles, hence 860 independent helpers. +It checks the binary chart bases and strict nesting of every paid route and +productive helper route, then counts their actual dimension differences. +It does not use the source's histogram function. + +The native has 5810 paid transfers and 860 productive helpers. The literal +caller has 16 ordered native invocations. Direct event counting adds every +QUERY and signed or unit idle child at its port multiplicity. Direct counting +of all root diagonal declarations adds the root targets. This yields 96512 +paid jobs, 17296 productive jobs and productive rank mass minus paid rank +mass 1328. All rank bins match the source receipt. This is a complete invoice +for the stated caller contract; its scalar endpoint and physical execution +remain inherited, rather than re-proved by counting declarations. + +The independent price code uses only rational arithmetic. To bound log r, +write `r=2^k*y` with `1<=y<2`. For x=(y-1)/(y+1), use +`log(y)=2*sum_(j>=0) x^(2j+1)/(2j+1)`. The same series bounds log 2 with +x=1/3. After n=80 terms, the omitted tail is between zero and +`2*x^(2n+1)/((2n+1)*(1-x*x))`. All arguments lie in [0,1/3]. The code rounds +the resulting interval outwards to a rational grid of denominator 10^60. + +For `a<=kappa*log(r)<=b<1`, the 17th-degree alternating partial sum for +exp(-b) is a lower bound; the 16th-degree sum for exp(-a) is an upper bound. +The terms decrease in magnitude. Multiply by r to enclose `r^(1-kappa)` and +round outwards to denominator 10^40. Add productive bounds and subtract paid +bounds with the correct interval endpoints. The final receipt rounds outwards +again to denominator 10^25. No floating-point result decides a sign. + +The productive-minus-paid margin is strictly positive at .00378751509478 +and .00378751509486, and strictly negative at .00378751509487. At the claimed +point it is about 3.0960942589e-8. RESULT.json contains the exact rational +enclosures. These signs confirm the source's claim-point margin and raw +bracket signs. The source's uniqueness, physical and compiler arguments are +not replaced by this finite price calculation. No extra root digits or new +construction are claimed. + +## Controls and limits + +Six changed certificates fail: a changed multiplier, a changed entrance +coefficient, a changed pulse value, a changed steering value, a changed helper +identity column, and omission of the role549 half-input term from the exact +role1409 source relation. The latter check concerns this relation at this +prefix; it is not a universal necessity claim about role549. + +The price checker encloses the exact square-root control `4^(1-1/2)=2` and +returns exactly 1328 at kappa zero. Omitting all fixed root targets makes the +claim-point margin negative. Omitting fixed caller charges makes the upper +bracket margin positive. These controls show why neither side of the complete +caller bill can be omitted. They are changed invoices, not alternative valid +constructions. + +All 55 source files, the certificate and the receipt are bound by exact +checks. Normal and optimized Python use explicit exceptions. No source file +is changed by replay. The generator is optional; it writes only the proposed +certificate and is not called by registered verification. + +The source constructor, original parent graph, other journal edits, exact +caller operator, native Gaussian phases, all-column physical implementation, +stock/reset and compiler/analytic interfaces remain shared dependencies. +The complete original five-command source suite, selected cold replay, Lean +and Docker were not run. The selected .00363005817 and all five framework +assumptions remain unchanged. This contribution adds separately checkable +algebraic and price evidence. It does not promote the open source proposal. diff --git a/research/interleaved-basis-residual-audit/README.md b/research/interleaved-basis-residual-audit/README.md new file mode 100644 index 0000000000..62ad9e1cb2 --- /dev/null +++ b/research/interleaved-basis-residual-audit/README.md @@ -0,0 +1,38 @@ +# Interleaved helper-basis residual audit + +This package reproduces the three requested PR7726 restriction/split +comparisons with 54 explicit rational certificates. A separate checker tests +formal coefficient identities and every response equation. It confirms the +three chosen contracts and the three published alternate-equation failures. +The complete invoice and rational price signs also match. No new kappa is +claimed. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[CERTIFICATE.json.gz](CERTIFICATE.json.gz), [SOURCE-PINS.json](SOURCE-PINS.json) +and [CREDITS.md](CREDITS.md). The exact source constructor is retained; its +witness evaluator and pricing engine are not used by the new checker. +This is source-aware checking with a shared constructor, not blind or +independent human acceptance. + +Run with CPython 3.12 and its standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/interleaved-basis-residual-audit +``` + +Both registered commands end with: + +```text +PASS_INTERLEAVED_BASIS_RESIDUAL_AUDIT {'dual_identities': 30, 'primal_solutions': 24, 'primal_equations': 176320, 'nonzero_multipliers': 10484} 96512 paid 17296 productive +``` + +The optional generate.py script proposes the deposited certificate. It is +separate from acceptance and is not run by the registered checker. + +## Open next questions + +Can a separate constructor reproduce all journal edits and the full physical +application? First compare its graph with the exact published digest, then +check a changed edit that must fail. Can the 2^30 scalar allowance or path +grid be reduced for this graph? That requires an explicit physical audit; +the older graph's scale does not transfer. Neither task is claimed here. diff --git a/research/interleaved-basis-residual-audit/RESULT.json b/research/interleaved-basis-residual-audit/RESULT.json new file mode 100644 index 0000000000..0f0f459fe1 --- /dev/null +++ b/research/interleaved-basis-residual-audit/RESULT.json @@ -0,0 +1,272 @@ +{ + "cases": [ + { + "restriction": 1400, + "variant": "chosen", + "split": 294, + "direction": "forward", + "input_symbols": 1510, + "restriction_symbols": 1502, + "graph_equations": 7320, + "products": 687045, + "failures": {}, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "2", + "1/2", + "3" + ] + }, + { + "restriction": 1400, + "variant": "alternate", + "split": 294, + "direction": "forward", + "input_symbols": 1510, + "restriction_symbols": 1502, + "graph_equations": 7320, + "products": 686841, + "failures": { + "readout": { + "coordinates": 16, + "first_coordinate": 10, + "difference": "1" + } + }, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "2", + "1/2", + "3" + ] + }, + { + "restriction": 1401, + "variant": "chosen", + "split": 288, + "direction": "transpose", + "input_symbols": 1511, + "restriction_symbols": 1502, + "graph_equations": 7321, + "products": 734554, + "failures": {}, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "-4", + "1", + "1" + ] + }, + { + "restriction": 1401, + "variant": "alternate", + "split": 288, + "direction": "transpose", + "input_symbols": 1511, + "restriction_symbols": 1502, + "graph_equations": 7321, + "products": 734369, + "failures": { + "response": { + "coordinates": 16, + "first_coordinate": 11, + "difference": "-2" + } + }, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "-4", + "1", + "1" + ] + }, + { + "restriction": 1409, + "variant": "chosen", + "split": 302, + "direction": "transpose", + "input_symbols": 1512, + "restriction_symbols": 1502, + "graph_equations": 7322, + "products": 730019, + "failures": {}, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "-2", + "1/2", + "1/2" + ] + }, + { + "restriction": 1409, + "variant": "alternate", + "split": 302, + "direction": "transpose", + "input_symbols": 1512, + "restriction_symbols": 1502, + "graph_equations": 7322, + "products": 730237, + "failures": { + "response": { + "coordinates": 27, + "first_coordinate": 25, + "difference": "1" + } + }, + "feedback": [ + "0", + "0" + ], + "normalizations": [ + "-2", + "1/2", + "1/2" + ] + } + ], + "invoice": { + "paid": { + "1": 62896, + "2": 13136, + "3": 7776, + "4": 3536, + "5": 4800, + "6": 1152, + "7": 32, + "8": 656, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416 + }, + "targets": { + "1": 16, + "2": 32, + "4": 3568, + "5": 128, + "7": 96, + "8": 416, + "9": 9920, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "129": 208 + } + }, + "counts": { + "graph_sha256": "ba59d5db17c40185c8608a734ced10135d8c041e432c3840e9034868781c31a2", + "paid": 96512, + "productive": 17296, + "surplus": 1328, + "stages": 16, + "native_paid": { + "1": 3907, + "2": 821, + "4": 221, + "5": 300, + "3": 486, + "6": 72, + "7": 2, + "8": 1 + }, + "native_targets": { + "9": 594, + "2": 2, + "4": 223, + "8": 26, + "5": 8, + "1": 1, + "7": 6 + }, + "fixed_paid": { + "8": 640, + "9": 32, + "56": 416, + "48": 416, + "40": 416, + "32": 416, + "24": 416, + "16": 416, + "1": 384 + }, + "fixed_targets": { + "129": 208, + "65": 416, + "57": 416, + "49": 416, + "41": 416, + "33": 416, + "25": 416, + "17": 416, + "9": 416 + }, + "independent_helpers": 860 + }, + "prices": [ + { + "kappa": "0.00378751509478", + "productive_minus_paid": [ + "154804712945796407/5000000000000000000000000", + "61921885178318563/2000000000000000000000000" + ] + }, + { + "kappa": "0.00378751509486", + "productive_minus_paid": [ + "15644121979440231/5000000000000000000000000", + "31288243958880463/10000000000000000000000000" + ] + }, + { + "kappa": "0.00378751509487", + "productive_minus_paid": [ + "-3501903782702143/10000000000000000000000000", + "-1750951891351071/5000000000000000000000000" + ] + } + ], + "controls": { + "rejected_certificates": 6, + "price": { + "closed_form_rank4_half": true, + "zero_saving_surplus": 1328, + "missing_roots_at_claim": [ + "-1477445212094987614033394452171/10000000000000000000000000", + "-147744521209498761403339445217/1000000000000000000000000" + ], + "missing_fixed_paid_at_upper": [ + "58980544386102099042731626067/625000000000000000000000", + "943688710177633584683706017073/10000000000000000000000000" + ] + } + }, + "certificate_sha256": "1a9f5bf202b4ba1a09a6ad8134dfd0bd8b9d1b15417f78dd44833248b4a8674b", + "certificate_counts": { + "dual_identities": 30, + "primal_solutions": 24, + "primal_equations": 176320, + "nonzero_multipliers": 10484 + } +} diff --git a/research/interleaved-basis-residual-audit/SOURCE-PINS.json b/research/interleaved-basis-residual-audit/SOURCE-PINS.json new file mode 100644 index 0000000000..06d0fc2f65 --- /dev/null +++ b/research/interleaved-basis-residual-audit/SOURCE-PINS.json @@ -0,0 +1,387 @@ +[ + { + "path": "retained/source/.gitattributes", + "source_path": "research/p104-interleaved-helper-bases/.gitattributes", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "85aa032067a2a84ca2240611025b49839b2d2e99", + "sha256": "8809106a77c5111b765961c96ce0faff15f4ee5dd6b89ffb4db18d8c19f5e6b8" + }, + { + "path": "retained/source/CREDITS.md", + "source_path": "research/p104-interleaved-helper-bases/CREDITS.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "503ab0d3e88085f599263a5718fb786ab0dcc9b4", + "sha256": "4f58fb0bc8d4e66868ceeac55328ef55d85a26085e2109e1123026fcc40bc9e1" + }, + { + "path": "retained/source/EDITS.json", + "source_path": "research/p104-interleaved-helper-bases/EDITS.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "8a2d26f8eee2e82aad4f7bd5a6fc310d814b758e", + "sha256": "e5ea96e36d20c038d7c346fe98ec7277b663c51f3a6f4470f4626f373adf0d0a" + }, + { + "path": "retained/source/LICENSE", + "source_path": "research/p104-interleaved-helper-bases/LICENSE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "retained/source/NOTICE", + "source_path": "research/p104-interleaved-helper-bases/NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "051d4cba2d47c65d5b2591aec77a17e7c44ed69c", + "sha256": "4e79158050dcf11ae2aa3867f15d66f4e5586e774a7167c61c2cb24bda9879b9" + }, + { + "path": "retained/source/PRICE.json", + "source_path": "research/p104-interleaved-helper-bases/PRICE.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "fc35a134bbffb82e71540c0dce07ae2925a1a759", + "sha256": "73942f3d1e599b29eecbe9d5cd13c514e2276686e04798982f0521fc756a2d6c" + }, + { + "path": "retained/source/PROOF.md", + "source_path": "research/p104-interleaved-helper-bases/PROOF.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "b8076440f4ed4a1e3b0c1ff6348049524cf8f127", + "sha256": "a68027d225e41dc8e4ccddb3cd8fd42e05a3a98334ca52573771a0ba4ea3722c" + }, + { + "path": "retained/source/README.md", + "source_path": "research/p104-interleaved-helper-bases/README.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "d55beb869064a91928b4770818639ea7e12abde3", + "sha256": "8b1e6bd220cae0e84bfd8ae1cc99f27de2a018645a7235a7bc4b9d9888b268b7" + }, + { + "path": "retained/source/SOURCE-PINS.json", + "source_path": "research/p104-interleaved-helper-bases/SOURCE-PINS.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "4fd73f18931491b3454d5ba88c6ccf885953a974", + "sha256": "ffef7b62153be3677d7b54540bcca31162099425a1a89e9e42207fb47c34d046" + }, + { + "path": "retained/source/SOURCES.json", + "source_path": "research/p104-interleaved-helper-bases/SOURCES.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "f51fc62b8a70baee2bb8a04be73795efadc4b451", + "sha256": "76818b74ee05a1a562813b1385b3609dea2bb548c260ebda1b3f8a7aeab236c9" + }, + { + "path": "retained/source/TASK.json", + "source_path": "research/p104-interleaved-helper-bases/TASK.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "539432c59b46a49ebc1b13242d7a7a2306214a21", + "sha256": "bb4d070e562d2ab1cd415535b335bfefd6524b48f8d32b38fbd457539e30d65f" + }, + { + "path": "retained/source/VERIFY.json", + "source_path": "research/p104-interleaved-helper-bases/VERIFY.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "8d8fe08785d21cd61cbb43cf3288141cf26989fb", + "sha256": "514c07fa002b4989efb6d4bd0a38185d67e49350f22657c5799ab07fe736720a" + }, + { + "path": "retained/source/application.py", + "source_path": "research/p104-interleaved-helper-bases/application.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "282e388c36f0477e07feac99a94a8ae37239a6da", + "sha256": "07c08cca07e020d80331773fe11a5c113ebcaa0de655e106de9d72964dbdad64" + }, + { + "path": "retained/source/catalogue.py", + "source_path": "research/p104-interleaved-helper-bases/catalogue.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "980987646e2e66d5a10ee1c7262f2de26019278f", + "sha256": "2a2c288caef17b3b7f5a0802028f965613c5fa463b2b12f36a757353fdc1756f" + }, + { + "path": "retained/source/common.py", + "source_path": "research/p104-interleaved-helper-bases/common.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "60de844858d682d6d1144f23b5c9a20652c6d2b5", + "sha256": "8638ebe074926f5afa9ccd7edc4c9fda827261fb3c1a1b75ed703ff7089df258" + }, + { + "path": "retained/source/construction.py", + "source_path": "research/p104-interleaved-helper-bases/construction.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "694b11b1980f4fd1f7396aa6ea59b04e69de7fa2", + "sha256": "dc3eb3a58a6c54fdf89c17171e5c270659bdc2cbbbb13ef703b29d03ba1750b4" + }, + { + "path": "retained/source/credits/7658-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/7658-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "2baa2a719ea3a9ec94c2e7aec72702ec8c92b346", + "sha256": "2732575164931c53cc4bc57145c31d87741489e3048afee6899e856c0ea503b5" + }, + { + "path": "retained/source/credits/7700-CITATION.cff", + "source_path": "research/p104-interleaved-helper-bases/credits/7700-CITATION.cff", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "d80f6b8660d6caaa82cb194fc22d0817d642d043", + "sha256": "50399ea15e9ce49baafbd00d6da16e662ac46c566e3c04af3993e23cf0b62ff4" + }, + { + "path": "retained/source/credits/7700-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/7700-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "path": "retained/source/credits/OUTER-GATE-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/OUTER-GATE-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "1bc9b4da2b8398954cd7a49356eb9d397785d0a6", + "sha256": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8" + }, + { + "path": "retained/source/credits/PR7663-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7663-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "6ce1bc49a3612c9e906df02de81bcba84be8e803", + "sha256": "5fd4367578d2339fbdcd7dc116b6c12cb4fa72e92d2e3d67be537a36c8bd9d40" + }, + { + "path": "retained/source/credits/PR7669-PROVENANCE.md", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7669-PROVENANCE.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "bbee2437f012c3268eb5cd920adfa37394c1de72", + "sha256": "706c6c852e87e371ddf1828244b2f0c2b00279728818023aa911c8947d69ab83" + }, + { + "path": "retained/source/credits/PR7674-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7674-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "951f081717e0769f3bcc0f442f133965c064d2ce", + "sha256": "382537634a3d9fa0a8089d6121a506a399382f9310088b1f29586dcc93eec92d" + }, + { + "path": "retained/source/credits/PR7682-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7682-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "4654631de087fe5034d30abc17e9d57582e5ed9c", + "sha256": "7590f71de481c424d2315e9ea4884bea1557481676fa5f930f7a0bed637a56a1" + }, + { + "path": "retained/source/credits/PR7704-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7704-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "7d2dfec60a3a8c30bbc639104905d5ce1c0926e4", + "sha256": "49657dd50c9431642a9527b0d625197cb34d1838dcf00fe4d92040f9605c8ce0" + }, + { + "path": "retained/source/credits/PR7705-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7705-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "2a92a9df69de4335966a1b12f79355244a7710f4", + "sha256": "43510816b93ea09e0d716ccc6261c84ce081821c0d5dea7d6e748863d55f8f40" + }, + { + "path": "retained/source/credits/PR7708-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7708-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "4a24e9bcb74d349b7f245f2b43edb6faba716429", + "sha256": "c3762acca6fa198c621e0aacf8aa06526aa7716c20c761141c07393fdba6bc46" + }, + { + "path": "retained/source/credits/PR7713-NOTICE", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7713-NOTICE", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "8fa17b3fd69ddd3be7caeaaff72848e0ac8d517a", + "sha256": "8852b94801cd022eb5d42dc57b7592ab22f87b441566a1ce62c8697733c82da6" + }, + { + "path": "retained/source/credits/PR7716-CREDITS.md", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7716-CREDITS.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "baa9d2f16c76c21437a61916a06f4be4d38ad54a", + "sha256": "dad56f9bca6dd9b902cf77dfbae0da49bbc091e63857313f5e6add52021085b2" + }, + { + "path": "retained/source/credits/PR7717-CREDITS.md", + "source_path": "research/p104-interleaved-helper-bases/credits/PR7717-CREDITS.md", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "538263114c08217081d3f05bd2383c50a7ae74b8", + "sha256": "515a2d475a2580bbe1c213d10526ce5eef7eaa9a11924e5d72e30221676f7aa4" + }, + { + "path": "retained/source/data/BASE-GRAPH.json.gz", + "source_path": "research/p104-interleaved-helper-bases/data/BASE-GRAPH.json.gz", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "9b797d51003786c8c7d205d0aa32d7897317cd27", + "sha256": "9f3923af2a1d4f97a28653c6b20cc3126d5404ff43ca07ea9bdc7fdda20dee1e" + }, + { + "path": "retained/source/data/BASE-INTERFACE.json", + "source_path": "research/p104-interleaved-helper-bases/data/BASE-INTERFACE.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "aae538bb9d6fb34e99eefc7ee374b25c7a39abeb", + "sha256": "8d2f95361baa7f20cb907f89a4fdbc87fc1266b8442175d0ee1e603f77b8a6d0" + }, + { + "path": "retained/source/data/CALLER-PHASE-BASES.json", + "source_path": "research/p104-interleaved-helper-bases/data/CALLER-PHASE-BASES.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "3e4aa383a5e3343c4688bff62bd39587b90c31b4", + "sha256": "325a1eb4aa7fe5f918b1d8344b88ad132ef4606268bccec20f223ace5feda18b" + }, + { + "path": "retained/source/data/CALLER.json.gz", + "source_path": "research/p104-interleaved-helper-bases/data/CALLER.json.gz", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "26a75a1ae32cb4944a65281cfb08775967cb39a0", + "sha256": "d889996a337f648087208ab51c98eaf052705d4fca88b5d01b6e9257a829897a" + }, + { + "path": "retained/source/data/COMPARATOR-APPLICATION.json", + "source_path": "research/p104-interleaved-helper-bases/data/COMPARATOR-APPLICATION.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "197c3a8a09ac99492bc88288aa662db4b95a49d6", + "sha256": "ed547c404492ee7672f17bbe793f049bc0484cf55170c776ee3a69ee4e3914c5" + }, + { + "path": "retained/source/data/QUOTIENT-APPLICATION.json", + "source_path": "research/p104-interleaved-helper-bases/data/QUOTIENT-APPLICATION.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "9a304f165eb74425db79115bd79e6f7dcedffeff", + "sha256": "f8d2499823054e44441c8f4dbbe1b8d430abe02eeeed09b0f55b08ab78b6f71d" + }, + { + "path": "retained/source/data/RESTRICTION-CONTROLS.json", + "source_path": "research/p104-interleaved-helper-bases/data/RESTRICTION-CONTROLS.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "cf49556bef648313754f59c27da9e993d7525ea0", + "sha256": "3cb73682c8b5238aba39bf8b559b53d7853044bda12f4282c80238dcdae46d63" + }, + { + "path": "retained/source/results/application.json", + "source_path": "research/p104-interleaved-helper-bases/results/application.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "59ffda86219174f449ca0d4838ed58f1926d8335", + "sha256": "9f3524a90b2965e5de9b39078018125a33fec8d3883b2127bb03ab8de1de0842" + }, + { + "path": "retained/source/results/catalogue-0.json", + "source_path": "research/p104-interleaved-helper-bases/results/catalogue-0.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "316666c59ca7b6f0091d670e46269d0ad040ddc3", + "sha256": "51e9031fba2debc31805c7ca3c7228655f99f8298464e58af1336518d253370f" + }, + { + "path": "retained/source/results/catalogue-1.json", + "source_path": "research/p104-interleaved-helper-bases/results/catalogue-1.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "efdc2b0150c13900a3e0360a6dcfdc8c96f39509", + "sha256": "e2b85783dd7c2302ddc209a1bdbe7f3e804023cce69a2f8a84bd2ee5d72ec6a8" + }, + { + "path": "retained/source/results/catalogue-2.json", + "source_path": "research/p104-interleaved-helper-bases/results/catalogue-2.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "7cd2928eea610969f73e33cd81834cbbcc4caf64", + "sha256": "c836253e2694de7407e7a490c4a0d7a5398bffb06687e800e11c3cc339289798" + }, + { + "path": "retained/source/results/witness.json", + "source_path": "research/p104-interleaved-helper-bases/results/witness.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "d9bd3e90dd9e7f37fa53d38d066ca97d9d94641b", + "sha256": "514c022ebd8886a2bf41dfa1586426e01c05a47a45ef7de7863b552710d301d1" + }, + { + "path": "retained/source/split.py", + "source_path": "research/p104-interleaved-helper-bases/split.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "98a5033490cc921532bd8cc77ff530a2ec8eefb0", + "sha256": "5513b6fae226fb37347d19e7854daf51295c3b070bc0b4f362b6ead5948b8dad" + }, + { + "path": "retained/source/vendor/binding16.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/binding16.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "d07341b81719d96e336a47907d48c73772ec1ccb", + "sha256": "589058311e44f2d8909495c005bee6d54828ebe561d4673b599193d269006170" + }, + { + "path": "retained/source/vendor/caller16.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/caller16.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "2865530b7878dec54286a67e82b83093911ec43c", + "sha256": "ced48867f07ca0143604aa98cfd74fa7453696b9d3221f7c230d73e9ab9ba81f" + }, + { + "path": "retained/source/vendor/construct.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/construct.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "25115bba74690dd19dfbd987a1eb47d471f14f2d", + "sha256": "f45dab80a16b2293488dd6a37048b965a46c572619b191062bc1511c5c0ce4ff" + }, + { + "path": "retained/source/vendor/interval_gate_signed.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/interval_gate_signed.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "2d8b9255d5422a51b8105695caff72f4a388a2a0", + "sha256": "e111ccdfcca3381a6a276e5ee012f156de613a7af98b14b037a21924250641cf" + }, + { + "path": "retained/source/vendor/network.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/network.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "0ebc1925c40cc6c11af59e405221ea51801a6e92", + "sha256": "a9169fd6ad0a13c69cf39bd32649d53256f6d6fa2ed2ceda854f848b64f4c546" + }, + { + "path": "retained/source/vendor/physical.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/physical.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "e7c4e5798bd37df287f431069ab0cffe73dbe3a3", + "sha256": "24c9cf906596c9ef1533c1d25f61403db3ff6389478f64359d9d12c5fef87b69" + }, + { + "path": "retained/source/vendor/recoding.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/recoding.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "c96d8b844d0e8028dc1616cf86a5130ed248de7e", + "sha256": "a56f02dd59430af46acbd4d5de240c377746fb74da46568195de68d5cb83b287" + }, + { + "path": "retained/source/vendor/selected-bit-ambient.json", + "source_path": "research/p104-interleaved-helper-bases/vendor/selected-bit-ambient.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "cd19f356a5549f6b70557095e7745cdddde0485c", + "sha256": "437ad2f9e7956e7f2b477b546f53a6c8cfa0567e207024300e9a7e58d3c0202c" + }, + { + "path": "retained/source/vendor/selected-claim.json", + "source_path": "research/p104-interleaved-helper-bases/vendor/selected-claim.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "c9b816f8445be9dc19b2259e03e9d8709d18c87a", + "sha256": "3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2" + }, + { + "path": "retained/source/vendor/selected-validation.json", + "source_path": "research/p104-interleaved-helper-bases/vendor/selected-validation.json", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "7291ce5ab9c59f07ead921fbad9966b4a54e3292", + "sha256": "e1374a98b240d7f9f2cca2a1e74b93f240b1bfc94b8cc4b94a385a50281d494e" + }, + { + "path": "retained/source/vendor/upstream_application.py", + "source_path": "research/p104-interleaved-helper-bases/vendor/upstream_application.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "1a6d358cbec88e70615e5314cdfca9e123124f83", + "sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184" + }, + { + "path": "retained/source/witness.py", + "source_path": "research/p104-interleaved-helper-bases/witness.py", + "source_commit": "3ba9094c54b61f424d2f98cd2c6ca64c01baf9d3", + "git_blob": "832f78a7327209a15d61f2f9d9935048627b3b0c", + "sha256": "7afd83b4785cf1f9291407e4986283bf731c0a68958e52f5ceabe42520c0b503" + } +] diff --git a/research/interleaved-basis-residual-audit/SOURCES.json b/research/interleaved-basis-residual-audit/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/interleaved-basis-residual-audit/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/interleaved-basis-residual-audit/TASK.json b/research/interleaved-basis-residual-audit/TASK.json new file mode 100644 index 0000000000..c53f5de124 --- /dev/null +++ b/research/interleaved-basis-residual-audit/TASK.json @@ -0,0 +1,91 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Three exact PR7726 restriction/split prefix comparisons, isolated helper identities, separate formal residual certificates and complete caller invoice/price signs.", + "scope_change_reason": "The released PR7726 handoff requests a separate reproduction of the three critical equations and complete price. The original constructor remains an explicit dependency.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "budget_minutes": 60, + "stop_rule": "Finish the six chosen/alternate prefix cases and complete bill; do not infer complete physical or compiler admission, or start a wider search.", + "outcome": "completed", + "evidence": "PROOF.md; RESULT.json; CERTIFICATE.json.gz; SOURCE-PINS.json", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing.", + "open_questions": [ + { + "question": "Can a separate constructor reproduce all edits and the full physical application?", + "why_it_matters": "This audit shares the source graph constructor and inherits the full physical/compiler premises.", + "first_step": "Rebuild the exact final graph independently and compare its digest, then exercise a changed-edit control.", + "blocked_by": "A complete separate implementation and a bounded full-application review." + } + ] +} diff --git a/research/interleaved-basis-residual-audit/VERIFY.json b/research/interleaved-basis-residual-audit/VERIFY.json new file mode 100644 index 0000000000..b11946d2dd --- /dev/null +++ b/research/interleaved-basis-residual-audit/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Reconstruct six exact prefixes, check 54 rational certificates and critical helper identities, reproduce alternate failures, independently count and price the complete caller, and reject six changed certificates." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "-O", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Reconstruct six exact prefixes, check 54 rational certificates and critical helper identities, reproduce alternate failures, independently count and price the complete caller, and reject six changed certificates." + } + ] +} diff --git a/research/interleaved-basis-residual-audit/audit.py b/research/interleaved-basis-residual-audit/audit.py new file mode 100644 index 0000000000..35f4c6432f --- /dev/null +++ b/research/interleaved-basis-residual-audit/audit.py @@ -0,0 +1,221 @@ +"""Check rational residual certificates for the three released split cases. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +The retained constructor supplies graphs. Its witness evaluator is not used. +""" + +from fractions import Fraction as F +from heapq import heappop, heappush +from pathlib import Path +import hashlib +import json +import sys + +ROOT = Path(__file__).resolve().parent +SOURCE = ROOT / 'retained/source' +sys.path.insert(0, str(SOURCE)) +import construction + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(name): + return json.loads((SOURCE / name).read_text()) + + +def row(entries): + result = {key: F(value) for key, value in entries} + require(len(result) == len(entries) and all(result.values()), 'invalid sparse row') + return result + + +def packed(values): + return [[key, str(value)] for key, value in sorted(values.items()) if value] + + +def add(target, key, value): + value += target.get(key, 0) + if value: + target[key] = value + else: + target.pop(key, None) + + +def difference(left, right): + result = dict(left) + for key, value in right.items(): + add(result, key, -value) + return result + + +def graph(net, direction): + first, size = net.first_output, len(net.initial) + forms, moves = net.forms, net.moves + initial, final = net.initial, net.final + if direction == 'transpose': + def reverse(key): + return first + ~key if key < 0 else ~(key - first) if key >= first else key + forms = {key: {} for key in net.forms} + for target, terms in net.forms.items(): + for donor, coefficient in terms.items(): + forms[reverse(donor)][reverse(target)] = coefficient + moves = {key: (b, a) for key, (a, b) in net.moves.items()} + initial, final = final, initial + else: + require(direction == 'forward', 'unknown orientation') + return dict(first=first, size=size, forms=forms, moves=moves, initial=initial, final=final) + + +def signature(g): + data = dict(first=g['first'], initial=g['initial'], final=g['final'], + moves=[[k, *v] for k, v in sorted(g['moves'].items())], + forms=[[k, packed(v)] for k, v in sorted(g['forms'].items())]) + return hashlib.sha256(json.dumps(data, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def bank_chart(g, key): + if key < 0: + require(~key < g['size'], 'unknown entrance') + return g['initial'][~key] + require(key in g['moves'], 'unknown received bank') + return g['moves'][key][1] + + +def schedule(g): + forms, moves, first, size = (g[k] for k in ('forms', 'moves', 'first', 'size')) + require(set(forms) == set(moves) | set(range(first, first + size)), 'graph inventory') + incoming, readers = {}, {key: [] for key in forms} + ready = [] + for key, terms in forms.items(): + chart = moves[key][0] if key < first else g['final'][key - first] + require(all(bank_chart(g, donor) == chart for donor in terms), 'nonlocal coefficient') + incoming[key] = sum(donor >= 0 for donor in terms) + for donor in terms: + if donor >= 0: + readers[donor].append(key) + if not incoming[key]: + heappush(ready, key) + order = [] + while ready: + key = heappop(ready) + order.append(key) + for target in readers[key]: + incoming[target] -= 1 + if not incoming[target]: + heappush(ready, target) + require(len(order) == len(forms), 'cyclic graph') + return order + + +def check_functional(g, observation, certificate): + """Multiply the formal residual rows; do not propagate an observation.""" + multipliers, expansion = row(certificate['multipliers']), row(certificate['expansion']) + require(multipliers.keys() <= g['forms'].keys(), 'unknown equation multiplier') + require(all(key < 0 and ~key < g['size'] for key in expansion), 'invalid entrance expansion') + residual = dict(multipliers) + products = 0 + for key, factor in multipliers.items(): + for donor, coefficient in g['forms'][key].items(): + add(residual, donor, -factor * coefficient) + products += 1 + require(residual == difference(observation, expansion), 'formal coefficient residual differs') + return expansion, products + + +def check_response(g, pulse, entrance, certificate): + """Substitute a proposed value into every equation, in arbitrary key order.""" + values = row(certificate) + require(values.keys() <= g['forms'].keys(), 'unknown response bank') + products = 0 + for key, terms in g['forms'].items(): + expected = pulse.get(key, 0) + for donor, coefficient in terms.items(): + expected += coefficient * (entrance.get(~donor, 0) if donor < 0 else values.get(donor, 0)) + products += 1 + require(values.get(key, 0) == expected, 'response equation differs') + terminal = {key - g['first']: value for key, value in values.items() if key >= g['first']} + return values, terminal, products + + +def check_identity(g, role, certificate): + expansion, products = check_functional(g, {g['first'] + role: F(1)}, certificate['row']) + require(expansion == {~role: F(1)}, 'helper terminal is not its input') + _, terminal, count = check_response(g, {}, {role: F(1)}, certificate['column']) + require(terminal == {role: F(1)}, 'helper input affects another terminal') + return products + count + + +def cases(): + journal, controls = read('EDITS.json'), read('data/RESTRICTION-CONTROLS.json') + require([c['alternative']['role'] for c in controls] == [1400, 1401, 1409], 'three requested roles') + for control in controls: + role = control['alternative']['role'] + index, = [i for i, e in enumerate(journal) if e.get('role') == role] + last, = [i for i, e in enumerate(journal) if e['event'] == 'split' + and (e['role'], e['split_chart'], e['direction']) + == (control['split_role'], control['split_chart'], control['direction'])] + for variant, restriction in (('chosen', journal[index]), ('alternate', control['alternative'])): + before, _ = construction.apply_edits(journal[:index]) + edits = list(journal[:last]) + edits[index] = restriction + prefix, _ = construction.apply_edits(edits) + yield role, variant, restriction, journal[last], graph(before, restriction['direction']), graph(prefix, journal[last]['direction']) + + +def observations(restriction): + source = row(restriction['source']) + require(all(key < 0 for key in source) and source.get(~restriction['role']), 'source pivot') + bank, = restriction['banks'] + relation = row(bank['relation']) + require(relation.get(bank['remove']), 'receiver pivot') + return difference(relation, source) + + +def dot(left, right): + return sum(value * right.get(key, 0) for key, value in left.items()) + + +def check_case(g0, g, restriction, split, item): + require(item['restriction_graph'] == signature(g0) and item['split_graph'] == signature(g), 'prefix graph differs') + schedule(g0) + schedule(g) + bank, = restriction['banks'] + require(g0['moves'][bank['remove']][1] == bank['chart'], 'restriction receiver chart') + require(all(bank_chart(g0, k) == g0['initial'][restriction['role']] for k, _ in restriction['source']), 'restriction source chart') + require(all(bank_chart(g0, k) == bank['chart'] for k, _ in bank['relation']), 'restriction bank chart') + expansion, products = check_functional(g0, observations(restriction), item['restriction']) + require(not expansion, 'receiver and source restriction differ') + products += check_identity(g0, restriction['role'], item['restriction_identity']) + products += check_identity(g, split['role'], item['split_identity']) + readout, calibration, pulse = (row(split[k]) for k in ('readout', 'calibration', 'pulse')) + s, w, y, t = (row(split[k]) for k in ('source_covector', 'source_direction', 'return_covector', 'return_direction')) + require(all(bank_chart(g, k) == split['split_chart'] for k in readout.keys() | calibration.keys()), 'split bank chart') + require(all((g['moves'][k][0] if k < g['first'] else g['final'][k - g['first']]) == split['split_chart'] for k in pulse), 'pulse source chart') + require(all(g['initial'][i] == split['source_chart'] for i in s.keys() | w.keys()), 'source direction chart') + require(all(g['final'][i] == split['return_chart'] for i in y.keys() | t.keys()), 'return direction chart') + actual, n = check_functional(g, readout, item['readout']) + products += n + decoded = {g['first'] + key: value for key, value in y.items()} + calibration_error, n = check_functional(g, difference(calibration, decoded), item['calibration']) + products += n + values, response, n = check_response(g, pulse, {}, item['pulse']) + products += n + _, steered, n = check_response(g, {}, w, item['steering']) + products += n + errors = {'readout': {~k: v for k, v in difference(actual, {~k: v for k, v in s.items()}).items()}, + 'calibration': {~k: v for k, v in calibration_error.items()}, + 'response': difference(response, t), 'steering': difference(steered, t)} + feedback = [dot(readout, values), dot(calibration, values)] + factors = [dot(s, w), dot(y, t), t.get(split['role'], 0)] + require(all(factors), 'zero split normalization') + if item['variant'] == 'chosen': + require(not any(errors.values()) and feedback == [0, 0], 'chosen split equation fails') + failures = {name: dict(coordinates=len(error), first_coordinate=min(error), + difference=str(error[min(error)])) for name, error in errors.items() if error} + return dict(restriction=restriction['role'], variant=item['variant'], split=split['role'], + direction=split['direction'], input_symbols=g['size'], restriction_symbols=g0['size'], + graph_equations=len(g['forms']), products=products, failures=failures, + feedback=list(map(str, feedback)), normalizations=list(map(str, factors))) diff --git a/research/interleaved-basis-residual-audit/generate.py b/research/interleaved-basis-residual-audit/generate.py new file mode 100644 index 0000000000..82b7c69dd4 --- /dev/null +++ b/research/interleaved-basis-residual-audit/generate.py @@ -0,0 +1,64 @@ +"""Produce candidate multipliers and response values for the direct checker. + +This producer is not an acceptance check. Ali Romman with OpenAI Codex +assistance. Apache-2.0. +""" + +from pathlib import Path +import gzip +import json +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import audit + + +def functional(g, observation, order): + remaining = dict(observation) + multipliers = {} + for key in reversed(order): + factor = remaining.pop(key, 0) + if factor: + multipliers[key] = factor + for donor, coefficient in g['forms'][key].items(): + audit.add(remaining, donor, factor * coefficient) + return dict(multipliers=audit.packed(multipliers), expansion=audit.packed(remaining)) + + +def response(g, pulse, entrance, order): + values = {} + for key in order: + value = pulse.get(key, 0) + for donor, coefficient in g['forms'][key].items(): + value += coefficient * (entrance.get(~donor, 0) if donor < 0 else values.get(donor, 0)) + if value: + values[key] = value + return audit.packed(values) + + +def identity(g, role, order): + return dict(row=functional(g, {g['first'] + role: 1}, order), + column=response(g, {}, {role: 1}, order)) + + +def main(): + result = [] + for role, variant, restriction, split, g0, g in audit.cases(): + order0, order = audit.schedule(g0), audit.schedule(g) + decoded = {g['first'] + key: value for key, value in audit.row(split['return_covector']).items()} + item = dict(role=role, variant=variant, restriction_graph=audit.signature(g0), split_graph=audit.signature(g), + restriction=functional(g0, audit.observations(restriction), order0), + restriction_identity=identity(g0, restriction['role'], order0), + split_identity=identity(g, split['role'], order), + readout=functional(g, audit.row(split['readout']), order), + calibration=functional(g, audit.difference(audit.row(split['calibration']), decoded), order), + pulse=response(g, audit.row(split['pulse']), {}, order), + steering=response(g, {}, audit.row(split['source_direction']), order)) + result.append(item) + print('GENERATED', role, variant, flush=True) + raw = json.dumps(result, sort_keys=True, separators=(',', ':')).encode() + (audit.ROOT / 'CERTIFICATE.json.gz').write_bytes(gzip.compress(raw, mtime=0)) + + +if __name__ == '__main__': + main() diff --git a/research/interleaved-basis-residual-audit/price.py b/research/interleaved-basis-residual-audit/price.py new file mode 100644 index 0000000000..597fe9f9eb --- /dev/null +++ b/research/interleaved-basis-residual-audit/price.py @@ -0,0 +1,147 @@ +"""Count the complete invoice and enclose its prices with rational series. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +No retained pricing engine is used. +""" + +from collections import Counter +from fractions import Fraction as F +from functools import cache +from math import factorial +import gzip +import json + +import audit + + +def basis(vectors): + pivots = {} + for value in vectors: + while value: + bit = value.bit_length() - 1 + if bit not in pivots: + pivots[bit] = value + break + value ^= pivots[bit] + audit.require(len(pivots) == len(vectors), 'dependent chart basis') + return pivots + + +def included(left, right): + for value in left.values(): + for bit in sorted(right, reverse=True): + if value >> bit & 1: + value ^= right[bit] + if value: + return False + return True + + +def invoice(): + graph, layout, net = audit.construction.build() + expected = audit.read('results/application.json') + audit.require(audit.construction.digest(graph) == expected['graph_sha256'], 'complete graph pin') + interface = audit.read('data/BASE-INTERFACE.json') + stable_main = {interface['keep'][i] for i in interface['main_roles']} + mains = {i for i, stable in enumerate(layout['source_labels']) if stable in stable_main} + audit.require(len(mains) == len(stable_main) == 400 and len(net.initial) == 1260, 'main and helper inventory') + frames = list(map(basis, graph['frames'])) + def rank(a, b, productive=False): + forward, reverse = included(frames[a], frames[b]), included(frames[b], frames[a]) + audit.require(forward != reverse, 'non-strict or non-nested transfer') + audit.require(not productive or forward, 'productive orientation') + return abs(len(frames[a]) - len(frames[b])) + native_paid = Counter(rank(a, b) for a, b in net.moves.values()) + native_targets = Counter(rank(a, b, True) for i, (a, b) in enumerate(zip(net.initial, net.final, strict=True)) if i not in mains) + caller = json.loads(gzip.decompress((audit.SOURCE / 'data/CALLER.json.gz').read_bytes())) + paid, targets, stages = Counter(), Counter(), [] + for event in caller['events']: + kind = event[0] + if kind == 'J': + stages.append(event[1]) + audit.require(len(set(event[2])) == 4 and event[3][0] != event[3][1], 'joint owner alias') + continue + replicas = len(caller['types'][kind]['ports']) + op = event[1] + if op == 'QUERY': + audit.require(event[2] != event[3] and event[4] in (-1, 1), 'query contract') + paid[1] += replicas + elif op in ('IDLE_ONE', 'IDLE_ODD'): + block = event[3] + audit.require(block and len(block) == len(set(block)) and all(1 <= i <= 16 for i in block), 'idle support') + odd = op == 'IDLE_ODD' + audit.require(not odd or len(block) == 1 and event[4] == -1, 'odd idle contract') + paid[8 * len(block) + odd] += replicas + else: + audit.require(op in ('ADD', 'SCALE', 'SWAP', 'LAMBDA'), 'unpriced caller operation') + audit.require(stages == list(range(1, 17)) and caller['ambient_rank'] == 137, 'complete caller stages') + for spec in caller['types'].values(): + audit.require(len(spec['diagonal']) == spec['roles'], 'complete root target inventory') + for phase, coefficient_phase, *powers in spec['diagonal']: + audit.require(phase in (-1, 0, 1) and coefficient_phase == 0 and len(powers) == 16 + and set(powers) <= {0, 1} and any(powers), 'root target contract') + targets[8 * sum(powers) + phase % 2] += len(spec['ports']) + fixed_paid, fixed_targets = dict(paid), dict(targets) + paid.update({r: 16 * n for r, n in native_paid.items()}) + targets.update({r: 16 * n for r, n in native_targets.items()}) + result = {name: {str(r): n for r, n in sorted(hist.items())} for name, hist in (('paid', paid), ('targets', targets))} + for side in ('paid', 'targets'): + audit.require(result[side] == expected['invoice'][side], 'complete invoice differs') + surplus = sum(r * n for r, n in targets.items()) - sum(r * n for r, n in paid.items()) + audit.require(surplus == 1328 and sum(paid.values()) == 96512 and sum(targets.values()) == 17296, 'complete caller counts') + return result, dict(graph_sha256=expected['graph_sha256'], paid=sum(paid.values()), productive=sum(targets.values()), + surplus=surplus, stages=16, native_paid=dict(native_paid), native_targets=dict(native_targets), + fixed_paid=fixed_paid, fixed_targets=fixed_targets, independent_helpers=len(net.initial) - len(mains)) + + +def round_out(low, high, digits): + scale = 10 ** digits + a, b = low * scale, high * scale + return F(a.numerator // a.denominator, scale), F(-(-b.numerator // b.denominator), scale) + + +@cache +def log_interval(number): + exponent = number.bit_length() - 1 + residual = F(number, 1 << exponent) + def series(value): + x = (value - 1) / (value + 1) + audit.require(0 <= x <= F(1, 3), 'log reduction') + n = 80 + low = 2 * sum(x ** (2 * j + 1) / (2 * j + 1) for j in range(n)) + high = low + 2 * x ** (2 * n + 1) / ((2 * n + 1) * (1 - x * x)) + return low, high + a, b = series(F(2)) + c, d = series(residual) + return round_out(exponent * a + c, exponent * b + d, 60) + + +def rank_price(rank, kappa): + low, high = log_interval(rank) + a, b = kappa * low, kappa * high + audit.require(0 <= a <= b < 1, 'alternating exponential range') + lower = sum((-b) ** j / factorial(j) for j in range(18)) + upper = sum((-a) ** j / factorial(j) for j in range(17)) + lower, upper = round_out(rank * lower, rank * upper, 40) + return lower, upper + + +def margin(invoice, point): + kappa = F(point) + low = high = F(0) + for side, sign in (('targets', 1), ('paid', -1)): + for rank, count in invoice[side].items(): + a, b = rank_price(int(rank), kappa) + low += count * (a if sign == 1 else -b) + high += count * (b if sign == 1 else -a) + return tuple(map(str, round_out(low, high, 25))) + + +def verify_prices(invoice): + price = audit.read('PRICE.json') + rows = [] + for point, sign in [(price['claim'], 1), (price['bracket'][0], 1), (price['bracket'][1], -1)]: + low, high = margin(invoice, point) + audit.require(F(low) > 0 if sign == 1 else F(high) < 0, 'complete margin sign differs') + rows.append(dict(kappa=point, productive_minus_paid=[low, high])) + return rows diff --git a/research/interleaved-basis-residual-audit/retained/source/.gitattributes b/research/interleaved-basis-residual-audit/retained/source/.gitattributes new file mode 100644 index 0000000000..85aa032067 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/.gitattributes @@ -0,0 +1 @@ +credits/PR7669-PROVENANCE.md -text whitespace=cr-at-eol diff --git a/research/interleaved-basis-residual-audit/retained/source/CREDITS.md b/research/interleaved-basis-residual-audit/retained/source/CREDITS.md new file mode 100644 index 0000000000..503ab0d3e8 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/CREDITS.md @@ -0,0 +1,11 @@ +# Credit and sources + +Ali Romman prepared the interleaved construction, edit journal, equation checks, reverse propagation and complete comparison with substantial OpenAI Codex assistance in research, implementation, verification and writing. The new material uses Apache-2.0. The replay is author verification with retained comparison engines. Independent scientific review remains open. + +Ali Romman's helper restrictions and physical application supply the parent, scientific commit `06b75fde21f4231a2bd0725542c3ba60a908d83b`. The compact graph and its stable-label map come from the source export in the subsequent composition at `1636b3c9b922d23b222b60dd52e005e60c592491`. The comparator and the base versions of the application, ownership and catalogue checks come from `586f4f81a8bd09a65a8e6d0bfff57a0fec8925e8`. The package records the compiler and the paid and productive sides of this comparator. [Parent restrictions](https://github.com/CrocSwap/integer-mult-bounds/pull/7713) · [Source export](https://github.com/CrocSwap/integer-mult-bounds/pull/7716) · [Physical comparator](https://github.com/CrocSwap/integer-mult-bounds/pull/7717) + +Clear1nsight supplied the causal split method, the banked role-1256 relay and its physical execution engine. DreamingOfClouds supplied the literal helper splits with Claude Opus 5.5 assistance. SYLforge supplied the word and signed caller. Ali Romman supplied prior scalar recodings. Rohan Arun supplied the caller lineage. [Causal split](https://github.com/CrocSwap/integer-mult-bounds/pull/7697) · [Banked relay](https://github.com/CrocSwap/integer-mult-bounds/pull/7704) · [Literal splits](https://github.com/CrocSwap/integer-mult-bounds/pull/7712) · [Signed word](https://github.com/CrocSwap/integer-mult-bounds/pull/7700) · [Earlier recoding](https://github.com/CrocSwap/integer-mult-bounds/pull/7708) + +DreamingOfClouds, with Claude Opus 5.5 assistance, supplied the signed-curvature correction to the interval gate at `5c7b96af66acc625e0f8497d6faf060c84770cdf`. It permits the previously admitted ordinary BIT pin 0.00385248. This application uses its source unchanged. Jerry Chen / CubeJerry supplied the selected complex and BIT application. Douglas Colkitt and the credited contributors supplied the framework, compiler and comparison tools. The source notices also credit mightyOil for concave comparison, unpaidmoon for the phase convention and icekylinx for prior odd-grid work. The shared-wire notice credits DreamingOfClouds, Ali Romman and Jerry Chen / CubeJerry for the operator engines. [Signed-curvature proof and checker](https://github.com/CrocSwap/integer-mult-bounds/pull/7618) · [Shared-wire notice](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/shared-wire-split-composition/NOTICE) + +The source inventory gives the original commit, path, Git blob and SHA-256 for every retained file. The external manifest identifies the four inputs from canonical main. Retained source notices and the Apache license are included. [File inventory](SOURCE-PINS.json) · [Base manifest](SOURCES.json) · [Retained notices](credits) · [License](LICENSE) diff --git a/research/interleaved-basis-residual-audit/retained/source/EDITS.json b/research/interleaved-basis-residual-audit/retained/source/EDITS.json new file mode 100644 index 0000000000..8a2d26f8ee --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/EDITS.json @@ -0,0 +1,257 @@ +[ + {"event":"restrict","direction":"forward","role":1218,"source":[[-1473,"2"],[-1472,"32"],[-1471,"12"],[-1470,"16"],[-1450,"16"],[-1341,"-8"],[-1329,"16"],[-1320,"-4"],[-1318,"-8"],[-1310,"-4"],[-1296,"-1"],[-1288,"4"],[-1285,"-8"],[-1280,"-8"],[-1273,"16"],[-1266,"-2"],[-1265,"-8"],[-1260,"16"],[-1257,"16"],[-1256,"-8"],[-1251,"4"],[-1241,"4"],[-1239,"-4"],[-1236,"8"],[-1230,"-4"],[-1223,"8"],[-1219,"32"],[-1215,"-16"],[-1209,"-16"],[-1208,"16"],[-1202,"-16"],[-1197,"-8"],[-1191,"4"],[-1185,"-4"],[-1182,"-8"],[-1179,"8"],[-1178,"8"],[-1174,"16"],[-1173,"16"],[-1172,"-64"],[-1171,"16"],[-1129,"-4"],[-1128,"-4"],[-1127,"16"],[-1123,"16"],[-1114,"8"],[-1106,"8"],[-1085,"4"],[-1080,"-4"],[-1075,"4"],[-1069,"-16"],[-1067,"-16"],[-1066,"16"],[-1061,"32"],[-1047,"-8"],[-1044,"16"],[-1043,"8"],[-1038,"-8"],[-1036,"16"],[-1035,"4"],[-1033,"16"],[-1020,"-16"],[-1018,"16"],[-1014,"-16"],[-1010,"32"],[-1000,"-8"],[-995,"-4"],[-989,"-4"],[-986,"-16"],[-985,"-16"],[-980,"-16"],[-934,"-16"],[-928,"-16"],[-927,"-16"],[-925,"8"],[-914,"-4"],[-895,"-16"],[-811,"32"],[-794,"-16"],[-790,"-8"],[-776,"8"],[-761,"16"],[-757,"-16"],[-753,"8"],[-734,"-64"],[-705,"4"],[-698,"4"],[-689,"-4"],[-680,"-4"],[-642,"-4"],[-641,"2"],[-625,"4"],[-618,"-4"],[-609,"2"],[-600,"8"],[-593,"-4"],[-590,"32"],[-588,"4"],[-584,"-4"],[-579,"4"],[-573,"64"],[-572,"8"],[-569,"8"],[-568,"8"],[-566,"4"],[-565,"8"],[-562,"4"],[-551,"1/2"],[-546,"32"],[-545,"24"],[-544,"32"],[-539,"4"],[-538,"-16"],[-537,"32"],[-531,"16"],[-529,"12"],[-528,"16"],[-526,"-8"],[-524,"-8"],[-520,"-16"],[-519,"16"],[-518,"16"],[-512,"16"],[-509,"-16"],[-497,"-16"],[-492,"16"],[-486,"-16"],[-480,"16"],[-470,"16"],[-465,"-4"],[-462,"-8"],[-449,"16"],[-443,"-8"],[-442,"16"],[-441,"-16"],[-440,"-20"],[-435,"-16"],[-430,"-64"],[-419,"-8"],[-418,"-32"],[-415,"16"],[-410,"4"],[-409,"2"],[-408,"-32"],[-400,"16"],[-389,"4"],[-384,"16"],[-337,"16"],[-320,"-16"],[-317,"12"],[-314,"16"],[-312,"16"],[-307,"4"],[-284,"16"],[-281,"16"],[-273,"40"],[-268,"2"],[-266,"1/4"],[-258,"-8"],[-253,"1/2"],[-239,"4"],[-237,"-24"],[-231,"-48"],[-151,"8"],[-127,"-2"],[-22,"-8"],[-4,"1"]],"banks":[{"chart":299,"remove":93174,"relation":[[93174,"32"],[94318,"32"]]}]}, + {"event":"split","direction":"forward","role":1026,"source_chart":3,"split_chart":2,"return_chart":127,"source_covector":[[3,"1/64"],[21,"-1/8"],[126,"-1/32"],[150,"1/8"],[229,"1/2"],[230,"-3/4"],[236,"-3/8"],[238,"1/16"],[252,"1/128"],[257,"-1/8"],[261,"-1"],[265,"1/256"],[267,"1/32"],[272,"5/8"],[280,"1/4"],[283,"1/4"],[306,"1/16"],[311,"1/4"],[312,"2"],[313,"1/4"],[315,"-1"],[316,"3/16"],[319,"-3/4"],[336,"1/4"],[383,"1/4"],[388,"1/16"],[399,"1/4"],[407,"1/2"],[408,"1/32"],[409,"1/16"],[414,"1/4"],[417,"-1/2"],[418,"-1/8"],[429,"-1"],[434,"1/4"],[439,"-5/16"],[440,"-1/4"],[441,"1/4"],[442,"-1/8"],[448,"1/4"],[461,"-1/8"],[464,"-1/16"],[469,"1/4"],[479,"1/4"],[485,"-1/4"],[491,"1/4"],[496,"-1/4"],[508,"-1/4"],[511,"1/4"],[517,"1/4"],[518,"1/4"],[519,"-1/4"],[523,"-1/8"],[525,"-1/8"],[527,"1/4"],[528,"3/16"],[530,"1/4"],[536,"1/2"],[537,"-1/4"],[538,"1/16"],[543,"1/2"],[544,"3/8"],[545,"1/2"],[550,"1/128"],[561,"1/16"],[564,"1/8"],[565,"1/16"],[567,"1/8"],[568,"1/8"],[571,"1/8"],[572,"1"],[578,"1/16"],[583,"-1/16"],[587,"1/16"],[589,"1/2"],[592,"-1/16"],[599,"1/8"],[608,"1/32"],[617,"-1/16"],[624,"1/16"],[640,"1/32"],[641,"-1/16"],[679,"-1/16"],[688,"-1/16"],[697,"1/16"],[704,"1/16"],[733,"-1"],[752,"1/8"],[756,"-1/4"],[760,"1/4"],[775,"1/8"],[789,"-1/8"],[793,"-1/4"],[810,"1/2"],[894,"-1/4"],[913,"-1/16"],[924,"1/8"],[926,"-1/4"],[927,"-1/4"],[933,"-1/4"],[979,"-1/4"],[984,"-1/4"],[985,"-1/4"],[988,"-1/16"],[994,"-1/16"],[999,"-1/8"],[1009,"1/2"],[1013,"-1/4"],[1017,"1/4"],[1019,"-1/4"],[1032,"1/4"],[1034,"1/16"],[1035,"1/4"],[1037,"-1/8"],[1042,"1/8"],[1043,"1/4"],[1046,"-1/8"],[1060,"1/2"],[1065,"1/4"],[1066,"-1/4"],[1068,"-1/4"],[1074,"1/16"],[1079,"-1/16"],[1084,"1/16"],[1105,"1/8"],[1113,"1/8"],[1122,"1/4"],[1126,"1/4"],[1127,"-1/16"],[1128,"-1/16"],[1170,"1/4"],[1171,"-1"],[1172,"1/4"],[1173,"1/4"],[1177,"1/8"],[1178,"1/8"],[1181,"-1/8"],[1184,"-1/16"],[1190,"1/16"],[1196,"-1/8"],[1201,"-1/4"],[1207,"1/4"],[1208,"-1/4"],[1214,"-1/4"],[1222,"1/8"],[1229,"-1/16"],[1235,"1/8"],[1238,"-1/16"],[1240,"1/16"],[1250,"1/16"],[1255,"-1/8"],[1256,"1/4"],[1259,"1/4"],[1264,"-1/8"],[1265,"-1/32"],[1272,"1/4"],[1279,"-1/8"],[1284,"-1/8"],[1287,"1/16"],[1295,"-1/64"],[1309,"-1/16"],[1317,"-1/8"],[1319,"-1/16"],[1328,"1/4"],[1340,"-1/8"],[1449,"1/4"],[1469,"1/4"],[1470,"3/16"],[1471,"1/2"],[1472,"1/32"]],"source_direction":[[319,"1"],[587,"-2"],[793,"1/2"],[1020,"-1/2"],[1026,"-1/2"],[1066,"-1/2"],[1112,"1/2"],[1128,"1/2"],[1173,"-1/8"],[1222,"-1"],[1472,"2"],[1477,"1/2"],[1479,"1/2"]],"readout":[[90048,"1"]],"return_direction":[[319,"1"],[587,"-2"],[793,"1/2"],[1020,"-1/2"],[1026,"-1/2"],[1066,"-1/2"],[1112,"1/2"],[1128,"1/2"],[1173,"-1/8"],[1222,"-1"],[1472,"2"],[1477,"1/2"],[1479,"1/2"]],"return_covector":[[39,"-2"],[229,"-4"],[248,"-2"],[267,"2"],[274,"2"],[312,"-16"],[315,"8"],[317,"2"],[319,"2"],[350,"-2"],[367,"-2"],[407,"-4"],[434,"-2"]],"calibration":[[90048,"-8"],[90072,"8"],[90553,"2"],[90555,"-2"],[94019,"1"]],"pulse":[[90081,"-1"],[90613,"1"],[94318,"-1"]]}, + {"event":"restrict","direction":"transpose","role":396,"source":[[-1474,"2/3"],[-1450,"-2"],[-1344,"-4"],[-1318,"1"],[-1307,"-1/4"],[-1274,"2"],[-1264,"-2"],[-1246,"6"],[-1244,"-1/4"],[-1235,"-1"],[-1217,"1/8"],[-1182,"-1"],[-1177,"1"],[-1176,"1"],[-1096,"2"],[-1040,"2"],[-1008,"1"],[-681,"2"],[-680,"2"],[-673,"-2"],[-582,"-1/2"],[-581,"-1/2"],[-579,"2"],[-480,"2"],[-443,"2"],[-431,"2"],[-420,"-1/2"],[-418,"-1/2"],[-398,"1"],[-397,"1"]],"banks":[{"chart":595,"remove":98350,"relation":[[97179,"1"],[97183,"1"],[97323,"-2"],[97356,"-8"],[98350,"10/3"],[98351,"2"],[99108,"1"],[99113,"1"],[103719,"-2/3"]]},{"chart":3,"remove":88440,"relation":[[88440,"10/3"],[90538,"-2"],[94105,"1"],[94107,"1"],[94120,"-2"],[95058,"1"],[95059,"1"],[95062,"2/3"],[96227,"2"]]}]}, + {"event":"restrict","direction":"transpose","role":503,"source":[[-504,"1"]],"banks":[{"chart":3,"remove":93307,"relation":[[93307,"1"],[93308,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1440,"source":[[-1441,"1"]],"banks":[{"chart":1049,"remove":101183,"relation":[[99889,"-2/3"],[101183,"4/3"],[101187,"2/3"]]}]}, + {"event":"restrict","direction":"transpose","role":1028,"source":[[-1029,"1"]],"banks":[{"chart":3,"remove":94064,"relation":[[90034,"-1/2"],[94064,"2"],[94072,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":675,"source":[[-676,"1"]],"banks":[{"chart":3,"remove":93572,"relation":[[93572,"-4"],[93573,"4"],[93575,"-4"],[93577,"-8"],[93579,"4"]]}]}, + {"event":"restrict","direction":"transpose","role":1443,"source":[[-1444,"1"]],"banks":[{"chart":246,"remove":103484,"relation":[[103484,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":735,"source":[[-736,"1"]],"banks":[{"chart":516,"remove":103935,"relation":[[103935,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1422,"source":[[-1423,"1"]],"banks":[{"chart":822,"remove":104454,"relation":[[104454,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1459,"source":[[-1460,"1"]],"banks":[{"chart":189,"remove":103416,"relation":[[103416,"4/3"]]}]}, + {"event":"restrict","direction":"transpose","role":1345,"source":[[-1346,"1"]],"banks":[{"chart":3,"remove":90667,"relation":[[90667,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":743,"source":[[-744,"1"]],"banks":[{"chart":243,"remove":103670,"relation":[[103670,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":738,"source":[[-739,"1"]],"banks":[{"chart":252,"remove":104028,"relation":[[104028,"-1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1500,"source":[[-1501,"1"]],"banks":[{"chart":245,"remove":104479,"relation":[[104479,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":885,"source":[[-886,"1"]],"banks":[{"chart":3,"remove":98226,"relation":[[98226,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":710,"source":[[-711,"1"]],"banks":[{"chart":117,"remove":101932,"relation":[[95917,"1"],[99605,"2"],[101872,"2"],[101874,"2"],[101892,"-4"],[101900,"1"],[101932,"-2"]]}]}, + {"event":"restrict","direction":"transpose","role":699,"source":[[-700,"1"]],"banks":[{"chart":3,"remove":90340,"relation":[[90340,"1/4"],[93652,"-1/2"],[93656,"1/2"],[93658,"-1/2"],[93670,"-1/4"],[93674,"-1/4"],[93677,"1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1418,"source":[[-1419,"1"]],"banks":[{"chart":817,"remove":104360,"relation":[[104360,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1478,"source":[[-1479,"1"]],"banks":[{"chart":660,"remove":103428,"relation":[[103428,"-1"],[103473,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1421,"source":[[-1422,"1"]],"banks":[{"chart":821,"remove":104470,"relation":[[104470,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":750,"source":[[-751,"1"]],"banks":[{"chart":477,"remove":104288,"relation":[[104288,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":384,"source":[[-385,"1"]],"banks":[{"chart":3,"remove":100738,"relation":[[100738,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1484,"source":[[-1485,"1"]],"banks":[{"chart":734,"remove":96759,"relation":[[96759,"-2/3"],[97475,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1495,"source":[[-1496,"1"]],"banks":[{"chart":595,"remove":103719,"relation":[[97179,"1/10"],[97183,"1/10"],[97323,"-1/5"],[97356,"-4/5"],[98351,"1/5"],[99108,"1/10"],[99113,"1/10"],[103719,"3/5"]]}]}, + {"event":"restrict","direction":"transpose","role":766,"source":[[-767,"1"]],"banks":[{"chart":3,"remove":94088,"relation":[[94088,"-1/4"],[94090,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1419,"source":[[-1420,"1"]],"banks":[{"chart":818,"remove":104302,"relation":[[104302,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":318,"source":[[-319,"1"]],"banks":[{"chart":3,"remove":93224,"relation":[[93224,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":657,"source":[[-658,"1"]],"banks":[{"chart":3,"remove":93810,"relation":[[93810,"1/4"],[93812,"1/4"],[93816,"-1/2"],[93824,"1/4"],[93832,"1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":639,"source":[[-640,"1"]],"banks":[{"chart":3,"remove":93755,"relation":[[93755,"-3/8"],[93757,"-3/8"],[93759,"1/8"],[93761,"-1/16"],[93763,"-1/16"],[93769,"-3/8"],[95730,"1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1389,"source":[[-1390,"1"]],"banks":[{"chart":243,"remove":104182,"relation":[[104182,"4"]]}]}, + {"event":"restrict","direction":"transpose","role":633,"source":[[-634,"1"]],"banks":[{"chart":3,"remove":93713,"relation":[[93713,"1/4"],[93716,"1/4"],[93721,"-1/2"],[93724,"1/4"],[93726,"3/4"],[93728,"-5/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1393,"source":[[-1394,"1"]],"banks":[{"chart":260,"remove":104331,"relation":[[103338,"-1/4"],[104331,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":422,"source":[[-423,"1"]],"banks":[{"chart":3,"remove":91339,"relation":[[91339,"2/5"],[99083,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":649,"source":[[-650,"1"]],"banks":[{"chart":3,"remove":97601,"relation":[[97601,"-1"],[97602,"1"],[97667,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":616,"source":[[-617,"1"]],"banks":[{"chart":3,"remove":93920,"relation":[[93920,"5/8"],[93922,"1/4"],[93924,"-1/8"],[93926,"5/4"],[93930,"1/8"],[93932,"-1/8"]]}]}, + {"event":"restrict","direction":"transpose","role":1332,"source":[[-1333,"1"]],"banks":[{"chart":3,"remove":93652,"relation":[[93652,"-1"],[93656,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1416,"source":[[-1417,"1"]],"banks":[{"chart":557,"remove":104469,"relation":[[104469,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1239,"source":[[-1240,"1"]],"banks":[{"chart":3,"remove":93303,"relation":[[93303,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":755,"source":[[-756,"1"]],"banks":[{"chart":3,"remove":103080,"relation":[[103080,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":749,"source":[[-750,"1"]],"banks":[{"chart":3,"remove":90418,"relation":[[90418,"1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":937,"source":[[-938,"1"]],"banks":[{"chart":3,"remove":97411,"relation":[[97411,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1482,"source":[[-1483,"1"]],"banks":[{"chart":117,"remove":104239,"relation":[[104239,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1406,"source":[[-1407,"1"]],"banks":[{"chart":298,"remove":96516,"relation":[[96516,"-1/2"],[96518,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":455,"source":[[-456,"1"]],"banks":[{"chart":3,"remove":104489,"relation":[[104489,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1494,"source":[[-1495,"1"]],"banks":[{"chart":529,"remove":103649,"relation":[[103649,"1/4"],[103806,"-1/2"],[103982,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":1460,"source":[[-1461,"1"]],"banks":[{"chart":904,"remove":103248,"relation":[[103248,"-2/3"],[103249,"4/3"]]}]}, + {"event":"restrict","direction":"transpose","role":1417,"source":[[-1418,"1"]],"banks":[{"chart":816,"remove":104361,"relation":[[104361,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1320,"source":[[-1321,"1"]],"banks":[{"chart":3,"remove":93573,"relation":[[93573,"-1/4"],[93577,"1/4"],[93579,"-1/4"],[93586,"-1"],[93590,"-3/4"],[93615,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":731,"source":[[-732,"1"]],"banks":[{"chart":3,"remove":100731,"relation":[[88601,"3/2"],[88975,"3/2"],[96063,"-1/2"],[96095,"3/2"],[96097,"-1/2"],[99141,"-4"],[100066,"-1/2"],[100727,"-1"],[100731,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":593,"source":[[-594,"1"]],"banks":[{"chart":3,"remove":94081,"relation":[[94081,"1/2"],[94082,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":534,"source":[[-535,"1"]],"banks":[{"chart":3,"remove":95388,"relation":[[95388,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1487,"source":[[-1488,"1"]],"banks":[{"chart":246,"remove":103245,"relation":[[103245,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1411,"source":[[-1412,"1"]],"banks":[{"chart":382,"remove":98614,"relation":[[98614,"-1/2"],[98616,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1357,"source":[[-1358,"1"]],"banks":[{"chart":1090,"remove":104286,"relation":[[104286,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1278,"source":[[-1279,"1"]],"banks":[{"chart":3,"remove":92055,"relation":[[92055,"-1/4"],[92057,"1/2"],[92059,"1/4"],[92061,"-1/4"],[92063,"-1/2"],[92073,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":345,"source":[[-346,"1"]],"banks":[{"chart":3,"remove":95585,"relation":[[94008,"-1/4"],[95585,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1209,"source":[[-1210,"1"]],"banks":[{"chart":3,"remove":91970,"relation":[[88900,"-1/4"],[88913,"-1/4"],[91970,"1/2"],[91973,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1352,"source":[[-1353,"1"]],"banks":[{"chart":3,"remove":94092,"relation":[[94092,"-1/2"],[94094,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1451,"source":[[-1452,"1"]],"banks":[{"chart":595,"remove":97358,"relation":[[97358,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1308,"source":[[-1309,"1"]],"banks":[{"chart":3,"remove":93808,"relation":[[93808,"-1/2"],[93812,"-1"],[93816,"3/2"],[93824,"-3/4"],[93832,"-3/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1408,"source":[[-1409,"1"]],"banks":[{"chart":300,"remove":91126,"relation":[[91126,"-1/2"],[91128,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1423,"source":[[-1424,"1"]],"banks":[{"chart":823,"remove":104453,"relation":[[104453,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":515,"source":[[-516,"1"]],"banks":[{"chart":3,"remove":93220,"relation":[[93220,"1"],[93221,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1237,"source":[[-1238,"1"]],"banks":[{"chart":3,"remove":93311,"relation":[[93311,"1"],[93312,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1355,"source":[[-1356,"1"]],"banks":[{"chart":391,"remove":104110,"relation":[[98646,"-1"],[104110,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":463,"source":[[-464,"1"]],"banks":[{"chart":3,"remove":93191,"relation":[[88878,"-1/2"],[88880,"1/2"],[93191,"1"],[93193,"2"]]}]}, + {"event":"restrict","direction":"transpose","role":1373,"source":[[-1374,"1"]],"banks":[{"chart":1090,"remove":103661,"relation":[[103661,"1/16"],[103697,"1/16"],[104049,"-3/8"],[104066,"3/4"],[104136,"-1/2"],[104180,"1/32"],[104328,"1/16"],[104383,"-1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":1296,"source":[[-1297,"1"]],"banks":[{"chart":3,"remove":93716,"relation":[[93716,"5/384"],[93721,"1/384"],[93724,"5/96"],[93728,"1/96"],[96694,"-1/32"]]}]}, + {"event":"restrict","direction":"transpose","role":1413,"source":[[-1414,"1"]],"banks":[{"chart":554,"remove":104375,"relation":[[104375,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1444,"source":[[-1445,"1"]],"banks":[{"chart":529,"remove":103278,"relation":[[103278,"-1"],[103562,"1"],[103982,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":1499,"source":[[-1500,"1"]],"banks":[{"chart":1091,"remove":103380,"relation":[[103380,"8"],[103382,"8"],[103384,"1"],[103669,"3/2"],[103956,"1"],[104096,"5/4"],[104477,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":747,"source":[[-748,"1"]],"banks":[{"chart":3,"remove":93674,"relation":[[93674,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":481,"source":[[-482,"1"]],"banks":[{"chart":3,"remove":94342,"relation":[[89958,"-1/5"],[90132,"1/5"],[94342,"1"],[94344,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":1254,"source":[[-1255,"1"]],"banks":[{"chart":3,"remove":91870,"relation":[[91870,"2"],[91873,"1"],[91875,"1/2"],[91877,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":759,"source":[[-760,"1"]],"banks":[{"chart":3,"remove":97427,"relation":[[97427,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":601,"source":[[-602,"1"]],"banks":[{"chart":3,"remove":92142,"relation":[[92142,"-1/8"],[92144,"-1/4"],[92146,"9/8"],[92148,"1/4"],[92150,"-9/8"],[92152,"-1"],[92156,"-1"],[92165,"1/8"]]}]}, + {"event":"restrict","direction":"transpose","role":1348,"source":[[-1349,"1"]],"banks":[{"chart":3,"remove":92858,"relation":[[92858,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1468,"source":[[-1469,"1"]],"banks":[{"chart":3,"remove":96643,"relation":[[96643,"1"],[96648,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1431,"source":[[-1432,"1"]],"banks":[{"chart":837,"remove":104386,"relation":[[104386,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":556,"source":[[-557,"1"]],"banks":[{"chart":3,"remove":104490,"relation":[[104490,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":656,"source":[[-657,"1"]],"banks":[{"chart":3,"remove":93824,"relation":[[93824,"1/2"],[93832,"1/2"],[93833,"-1"],[93835,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1225,"source":[[-1226,"1"]],"banks":[{"chart":3,"remove":94109,"relation":[[90011,"1/5"],[90013,"-1/5"],[90015,"1/5"],[94109,"4/5"],[94112,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":615,"source":[[-616,"1"]],"banks":[{"chart":3,"remove":93922,"relation":[[93922,"4/5"],[93924,"-2/5"],[93930,"-8/5"],[93932,"8/5"]]}]}, + {"event":"restrict","direction":"transpose","role":1486,"source":[[-1487,"1"]],"banks":[{"chart":246,"remove":103483,"relation":[[103483,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":718,"source":[[-719,"1"]],"banks":[{"chart":3,"remove":104492,"relation":[[104492,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":509,"source":[[-510,"1"]],"banks":[{"chart":3,"remove":95323,"relation":[[95323,"-2/3"],[96717,"-2/3"]]}]}, + {"event":"restrict","direction":"transpose","role":746,"source":[[-747,"1"]],"banks":[{"chart":3,"remove":94120,"relation":[[94120,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1432,"source":[[-1433,"1"]],"banks":[{"chart":323,"remove":98401,"relation":[[98401,"-1/5"],[98403,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":514,"source":[[-515,"1"]],"banks":[{"chart":3,"remove":93155,"relation":[[88457,"-1/2"],[88572,"1/2"],[93155,"1"],[93157,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":742,"source":[[-743,"1"]],"banks":[{"chart":1091,"remove":103669,"relation":[[103320,"1/2"],[103669,"-1/2"],[103956,"-1/2"],[103977,"1"],[104096,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1409,"source":[[-1474,"1/3"],[-1473,"-5"],[-1471,"1"],[-1450,"-1"],[-1410,"2"],[-1344,"-2"],[-1332,"1"],[-1330,"-1/2"],[-1320,"-1"],[-1319,"-1/2"],[-1318,"-7/2"],[-1310,"1"],[-1308,"1/2"],[-1307,"7/4"],[-1303,"1/2"],[-1301,"1/2"],[-1296,"2"],[-1294,"1/4"],[-1287,"-1/4"],[-1280,"-1/4"],[-1278,"-1/2"],[-1274,"-1"],[-1273,"-7/16"],[-1261,"-2"],[-1260,"1"],[-1259,"16"],[-1258,"1"],[-1257,"-1/2"],[-1251,"-65/4"],[-1249,"8"],[-1246,"6"],[-1242,"1"],[-1237,"1/2"],[-1229,"1/4"],[-1228,"1/4"],[-1223,"3"],[-1222,"7/16"],[-1217,"-31/16"],[-1208,"-11/2"],[-1207,"1/16"],[-1204,"-1/2"],[-1182,"1/2"],[-1181,"1/4"],[-1176,"-1/4"],[-1172,"1"],[-1171,"-3/4"],[-1163,"-2"],[-1158,"1"],[-1156,"1/2"],[-1153,"1"],[-1145,"1"],[-1142,"1"],[-1129,"-4"],[-1128,"12"],[-1127,"-2"],[-1123,"-2"],[-1122,"-1"],[-1121,"8"],[-1119,"1/2"],[-1117,"-2"],[-1115,"2"],[-1112,"1/2"],[-1111,"1/2"],[-1110,"-5"],[-1105,"4"],[-1103,"-1/4"],[-1096,"-1/2"],[-1095,"2"],[-1094,"-2"],[-1090,"-2"],[-1078,"2"],[-1075,"-1/2"],[-1074,"-3/2"],[-1064,"1/2"],[-1063,"-1/2"],[-1061,"7/2"],[-1060,"1"],[-1059,"1/4"],[-1056,"-1/4"],[-1048,"4"],[-1045,"-3"],[-1044,"1/4"],[-1043,"-1"],[-1040,"2"],[-1032,"1/3"],[-1031,"-1/2"],[-1030,"-1/4"],[-1028,"1/6"],[-1022,"-8"],[-1018,"-2"],[-1016,"-1/8"],[-1008,"-1"],[-1004,"-2"],[-995,"-1"],[-925,"16"],[-798,"-2"],[-794,"1/8"],[-776,"1"],[-768,"-2"],[-759,"1"],[-734,"1/4"],[-733,"-1/2"],[-727,"-2"],[-708,"-1/2"],[-705,"1/4"],[-696,"-1/2"],[-690,"1"],[-680,"-2"],[-672,"1/4"],[-666,"-3/4"],[-665,"-1/2"],[-660,"-1/2"],[-641,"1"],[-636,"1"],[-625,"1/2"],[-620,"1/2"],[-610,"-1"],[-609,"1"],[-600,"-1/2"],[-593,"7/4"],[-592,"9/4"],[-591,"-2"],[-590,"-5/2"],[-588,"6"],[-587,"1"],[-582,"-1/4"],[-581,"-1/4"],[-579,"3"],[-577,"-1/4"],[-574,"-1/4"],[-573,"-1/4"],[-572,"-17"],[-571,"3"],[-570,"-1"],[-568,"1"],[-566,"2"],[-563,"-1"],[-562,"2"],[-552,"2"],[-550,"1/2"],[-549,"1/2"],[-548,"-1/2"],[-546,"1/2"],[-545,"1/4"],[-544,"1/4"],[-541,"3/2"],[-538,"-1"],[-532,"1/4"],[-529,"1/2"],[-528,"1/2"],[-527,"-1"],[-526,"-1/2"],[-524,"-3/4"],[-523,"2"],[-520,"-1"],[-519,"2"],[-513,"1/2"],[-512,"-1/2"],[-509,"1"],[-503,"1"],[-500,"-1/2"],[-498,"-1"],[-497,"-2"],[-495,"1"],[-491,"-2"],[-490,"-1/2"],[-486,"-1"],[-485,"3"],[-483,"2"],[-480,"1"],[-479,"1"],[-474,"1"],[-473,"-1"],[-472,"-2"],[-471,"-1"],[-470,"1"],[-468,"-1/2"],[-467,"-1"],[-466,"1/2"],[-465,"-1/2"],[-462,"2"],[-459,"-2"],[-457,"2"],[-450,"-1"],[-449,"1"],[-447,"1"],[-446,"-2"],[-440,"1/2"],[-439,"1/2"],[-437,"1"],[-435,"-1"],[-430,"-1"],[-425,"2"],[-405,"-3/4"],[-389,"-1/2"],[-384,"2"],[-373,"-1/4"],[-365,"-1"],[-364,"-1"],[-361,"-1/4"],[-360,"1"],[-359,"-1"],[-357,"-2"],[-353,"1/2"],[-352,"-1/4"],[-350,"1/4"],[-348,"1"],[-337,"1/4"],[-335,"1"],[-333,"1"],[-321,"1"],[-320,"1"],[-314,"1"],[-307,"-1/2"],[-305,"2"],[-304,"-2"],[-303,"2"],[-293,"2"],[-284,"-1/2"],[-282,"-1"],[-277,"-1/3"],[-273,"-1/4"],[-266,"2"],[-256,"-1/2"],[-253,"1"],[-252,"1/4"],[-248,"1/4"],[-237,"1/2"],[-231,"-1/4"],[-230,"2"],[-229,"-1/2"],[-206,"2"],[-174,"1/4"],[-40,"-2"],[-4,"1"]],"banks":[{"chart":301,"remove":96030,"relation":[[94336,"2"],[96030,"-2"]]}]}, + {"event":"restrict","direction":"transpose","role":1220,"source":[[-1221,"1"]],"banks":[{"chart":3,"remove":93161,"relation":[[90032,"-1/2"],[90034,"-1/4"],[93161,"1/2"],[93164,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":753,"source":[[-754,"1"]],"banks":[{"chart":117,"remove":104240,"relation":[[104240,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1330,"source":[[-1331,"1"]],"banks":[{"chart":3,"remove":93861,"relation":[[93861,"-1/2"],[93865,"1/2"],[93869,"-1/2"],[93874,"1/2"],[93876,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":721,"source":[[-722,"1"]],"banks":[{"chart":3,"remove":93392,"relation":[[93392,"1/4"],[93540,"4"]]}]}, + {"event":"restrict","direction":"transpose","role":739,"source":[[-740,"1"]],"banks":[{"chart":391,"remove":104170,"relation":[[104170,"-1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":741,"source":[[-742,"1"]],"banks":[{"chart":1090,"remove":104264,"relation":[[104264,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":459,"source":[[-460,"1"]],"banks":[{"chart":3,"remove":93213,"relation":[[88869,"-1/4"],[88896,"-1/4"],[93213,"1"],[93215,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":480,"source":[[-481,"1"]],"banks":[{"chart":3,"remove":94348,"relation":[[90003,"-1/5"],[90141,"1/5"],[94348,"1"],[94350,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":737,"source":[[-738,"1"]],"banks":[{"chart":462,"remove":104005,"relation":[[104005,"-1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":748,"source":[[-749,"1"]],"banks":[{"chart":517,"remove":104494,"relation":[[104494,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1336,"source":[[-1337,"1"]],"banks":[{"chart":3,"remove":93656,"relation":[[93656,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1492,"source":[[-1493,"1"]],"banks":[{"chart":237,"remove":103745,"relation":[[103745,"-2"]]}]}, + {"event":"restrict","direction":"transpose","role":493,"source":[[-494,"1"]],"banks":[{"chart":3,"remove":92920,"relation":[[88808,"-1/5"],[92920,"1"],[92922,"4/5"]]}]}, + {"event":"restrict","direction":"transpose","role":1252,"source":[[-1253,"1"]],"banks":[{"chart":3,"remove":93137,"relation":[[92321,"1"],[92328,"-1"],[93137,"1"],[93139,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1107,"source":[[-1108,"1"]],"banks":[{"chart":3,"remove":94680,"relation":[[94680,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":374,"source":[[-375,"1"]],"banks":[{"chart":3,"remove":93000,"relation":[[93000,"-1/2"],[93014,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":687,"source":[[-688,"1"]],"banks":[{"chart":3,"remove":93863,"relation":[[93863,"1/8"],[93865,"1/8"],[93867,"1/8"],[93869,"1/4"],[93874,"-1/8"],[93876,"-1/8"]]}]}, + {"event":"restrict","direction":"transpose","role":1369,"source":[[-1370,"1"]],"banks":[{"chart":240,"remove":104358,"relation":[[104358,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1392,"source":[[-1393,"1"]],"banks":[{"chart":1090,"remove":104049,"relation":[[104049,"1/16"],[104066,"-1/8"],[104180,"-1/64"],[104254,"1/4"],[104328,"-1/64"],[104383,"1/16"]]}]}, + {"event":"restrict","direction":"transpose","role":998,"source":[[-999,"1"]],"banks":[{"chart":3,"remove":103336,"relation":[[103336,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":1391,"source":[[-1392,"1"]],"banks":[{"chart":498,"remove":103535,"relation":[[95658,"2"],[103535,"-16"],[103536,"16"],[103595,"16"],[103711,"-8"],[103933,"-3"],[103937,"-8"],[104021,"1"],[104301,"3"],[104376,"-8"],[104384,"8"],[104418,"-8"]]}]}, + {"event":"restrict","direction":"transpose","role":722,"source":[[-723,"1"]],"banks":[{"chart":3,"remove":104493,"relation":[[104493,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":462,"source":[[-463,"1"]],"banks":[{"chart":3,"remove":93197,"relation":[[88900,"-1/2"],[88913,"1/2"],[93197,"1"],[93199,"2"]]}]}, + {"event":"restrict","direction":"transpose","role":1266,"source":[[-1267,"1"]],"banks":[{"chart":3,"remove":104501,"relation":[[104501,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1446,"source":[[-1447,"1"]],"banks":[{"chart":306,"remove":103554,"relation":[[103554,"4"],[104026,"-1/2"],[104267,"1"],[104467,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1485,"source":[[-1486,"1"]],"banks":[{"chart":246,"remove":103241,"relation":[[103241,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1211,"source":[[-1212,"1"]],"banks":[{"chart":3,"remove":90366,"relation":[[88874,"-1/4"],[88898,"-1/4"],[90366,"1/2"],[90369,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1297,"source":[[-1298,"1"]],"banks":[{"chart":3,"remove":93753,"relation":[[93753,"1/8"],[93757,"1/2"],[93759,"-1/2"],[93763,"-1/8"]]}]}, + {"event":"restrict","direction":"transpose","role":1246,"source":[[-1247,"1"]],"banks":[{"chart":3,"remove":93145,"relation":[[88551,"1/2"],[88553,"-1/2"],[93145,"1/2"],[93148,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1403,"source":[[-1404,"1"]],"banks":[{"chart":284,"remove":98380,"relation":[[98380,"-1/2"],[98382,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":786,"source":[[-787,"1"]],"banks":[{"chart":3,"remove":95600,"relation":[[95600,"-1"],[95622,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":751,"source":[[-752,"1"]],"banks":[{"chart":3,"remove":94934,"relation":[[94934,"-1"],[94935,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":740,"source":[[-741,"1"]],"banks":[{"chart":1098,"remove":103716,"relation":[[103716,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":727,"source":[[-728,"1"]],"banks":[{"chart":3,"remove":89784,"relation":[[89496,"4"],[89498,"2"],[89784,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1380,"source":[[-1381,"1"]],"banks":[{"chart":1090,"remove":104135,"relation":[[104135,"-10"],[104136,"2"],[104180,"1/8"],[104254,"-8"],[104328,"1/8"],[104383,"-1"],[104408,"-2"],[104410,"1"],[104422,"1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":451,"source":[[-452,"1"]],"banks":[{"chart":3,"remove":90538,"relation":[[90538,"-1/5"],[94105,"1/10"],[94107,"1/10"],[95058,"1/10"],[95059,"1/10"],[95062,"-3/5"],[96227,"1/5"]]}]}, + {"event":"restrict","direction":"transpose","role":1365,"source":[[-1366,"1"]],"banks":[{"chart":1090,"remove":104136,"relation":[[104136,"12/5"],[104180,"3/20"],[104254,"-28/5"],[104328,"3/20"],[104383,"-1/5"],[104408,"8/5"],[104410,"-4/5"],[104422,"3/5"]]}]}, + {"event":"restrict","direction":"transpose","role":706,"source":[[-707,"1"]],"banks":[{"chart":3,"remove":93668,"relation":[[93668,"3/4"],[93670,"-1/2"],[93677,"1/4"]]}]}, + {"event":"restrict","direction":"transpose","role":713,"source":[[-714,"1"]],"banks":[{"chart":76,"remove":96853,"relation":[[96853,"4"],[96948,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1285,"source":[[-1286,"1"]],"banks":[{"chart":3,"remove":94896,"relation":[[94896,"-1/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1353,"source":[[-1354,"1"]],"banks":[{"chart":462,"remove":104000,"relation":[[97461,"-1"],[104000,"-4"]]}]}, + {"event":"restrict","direction":"transpose","role":450,"source":[[-451,"1"]],"banks":[{"chart":3,"remove":96225,"relation":[[96225,"1"],[96227,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":1388,"source":[[-1389,"1"]],"banks":[{"chart":498,"remove":103536,"relation":[[95658,"-3/4"],[103536,"-4"],[103595,"-4"],[103711,"2"],[103933,"-1/4"],[103937,"5/2"],[104021,"1/2"],[104022,"1/8"],[104376,"3/2"],[104418,"5/2"]]}]}, + {"event":"restrict","direction":"transpose","role":1333,"source":[[-1334,"1"]],"banks":[{"chart":3,"remove":93672,"relation":[[93672,"1"],[93677,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":744,"source":[[-745,"1"]],"banks":[{"chart":529,"remove":103806,"relation":[[103806,"2"]]}]}, + {"event":"restrict","direction":"transpose","role":1401,"source":[[-1402,"-1"],[-1054,"-1"],[-1051,"-1"],[-1050,"1/2"],[-1049,"-1/4"],[-1007,"1/4"],[-1006,"-1/2"],[-1005,"-1/4"],[-991,"1/4"],[-930,"1/4"],[-902,"1/4"],[-862,"1"],[-833,"1"],[-831,"1/4"],[-432,"1"]],"banks":[{"chart":282,"remove":91108,"relation":[[91108,"1"],[94251,"-1"]]}]}, + {"event":"restrict","direction":"transpose","role":745,"source":[[-746,"1"]],"banks":[{"chart":541,"remove":103807,"relation":[[103807,"-2"]]}]}, + {"event":"restrict","direction":"transpose","role":1226,"source":[[-1227,"1"]],"banks":[{"chart":3,"remove":91748,"relation":[[91748,"1/5"],[91750,"1/5"]]}]}, + {"event":"restrict","direction":"transpose","role":322,"source":[[-323,"1"]],"banks":[{"chart":3,"remove":92533,"relation":[[92533,"-1"],[92908,"1"]]}]}, + {"event":"restrict","direction":"forward","role":754,"source":[[-755,"1"]],"banks":[{"chart":127,"remove":104495,"relation":[[104495,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1447,"source":[[-1448,"1"]],"banks":[{"chart":120,"remove":97602,"relation":[[97602,"1/2"],[97667,"1"],[97671,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1217,"source":[[-1218,"1"]],"banks":[{"chart":298,"remove":93184,"relation":[[93184,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1231,"source":[[-1232,"1"]],"banks":[{"chart":594,"remove":91700,"relation":[[91700,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1339,"source":[[-1340,"1"]],"banks":[{"chart":602,"remove":95073,"relation":[[95073,"4"],[95074,"-2"],[95077,"4"],[95079,"2"],[97148,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1480,"source":[[-1481,"1"]],"banks":[{"chart":127,"remove":104483,"relation":[[104483,"1"]]}]}, + {"event":"restrict","direction":"forward","role":648,"source":[[-649,"1"]],"banks":[{"chart":120,"remove":97667,"relation":[[97667,"-2"],[97671,"-2"]]}]}, + {"event":"restrict","direction":"forward","role":1301,"source":[[-1302,"1"]],"banks":[{"chart":597,"remove":104496,"relation":[[104496,"1"]]}]}, + {"event":"restrict","direction":"forward","role":623,"source":[[-624,"1"]],"banks":[{"chart":117,"remove":90912,"relation":[[90912,"1"]]}]}, + {"event":"restrict","direction":"forward","role":231,"source":[[-232,"1"]],"banks":[{"chart":259,"remove":91091,"relation":[[91091,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1425,"source":[[-1426,"1"]],"banks":[{"chart":127,"remove":104347,"relation":[[103756,"-1/2"],[103758,"-1"],[104347,"1"],[104409,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1213,"source":[[-1214,"1"]],"banks":[{"chart":284,"remove":93206,"relation":[[93206,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1359,"source":[[-1360,"1"]],"banks":[{"chart":127,"remove":104236,"relation":[[104236,"-2"]]}]}, + {"event":"restrict","direction":"forward","role":603,"source":[[-604,"1"]],"banks":[{"chart":114,"remove":92144,"relation":[[92144,"4"],[92146,"7"],[92150,"3"],[92152,"5"],[92156,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1219,"source":[[-1220,"1"]],"banks":[{"chart":300,"remove":90359,"relation":[[90359,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1424,"source":[[-1425,"1"]],"banks":[{"chart":127,"remove":103630,"relation":[[103559,"1/4"],[103618,"-1"],[103630,"1"],[103632,"2"]]}]}, + {"event":"restrict","direction":"forward","role":647,"source":[[-648,"1"]],"banks":[{"chart":597,"remove":104491,"relation":[[104491,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1414,"source":[[-1415,"1"]],"banks":[{"chart":127,"remove":103579,"relation":[[103579,"1"],[104120,"-1/2"],[104121,"1"],[104450,"2"]]}]}, + {"event":"restrict","direction":"forward","role":1223,"source":[[-1224,"1"]],"banks":[{"chart":714,"remove":94033,"relation":[[94033,"1"]]}]}, + {"event":"restrict","direction":"forward","role":390,"source":[[-391,"1"]],"banks":[{"chart":557,"remove":91234,"relation":[[91234,"-1"],[92973,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1358,"source":[[-1359,"1"]],"banks":[{"chart":127,"remove":103983,"relation":[[103983,"2"]]}]}, + {"event":"restrict","direction":"forward","role":1299,"source":[[-1300,"1"]],"banks":[{"chart":1027,"remove":93759,"relation":[[93759,"4/5"],[93761,"-162/5"],[93763,"-16/5"],[93769,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1442,"source":[[-1443,"1"]],"banks":[{"chart":127,"remove":103702,"relation":[[103702,"-1/2"],[103808,"1"],[104158,"-1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1498,"source":[[-1499,"1"]],"banks":[{"chart":127,"remove":104294,"relation":[[104294,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1397,"source":[[-1398,"1"]],"banks":[{"chart":127,"remove":103697,"relation":[[103568,"-1/16"],[103697,"1"],[103722,"3/16"],[104254,"-1/4"],[104328,"-2"],[104383,"1/2"],[104408,"-1/8"],[104410,"1/4"],[104422,"1/4"]]}]}, + {"event":"restrict","direction":"forward","role":1497,"source":[[-1498,"1"]],"banks":[{"chart":127,"remove":104112,"relation":[[104112,"2"],[104416,"-5/2"],[104446,"-2"]]}]}, + {"event":"restrict","direction":"forward","role":1489,"source":[[-1490,"1"]],"banks":[{"chart":127,"remove":91106,"relation":[[91106,"1"],[103235,"-1"],[103243,"4"]]}]}, + {"event":"restrict","direction":"forward","role":1412,"source":[[-1413,"1"]],"banks":[{"chart":127,"remove":95783,"relation":[[95783,"-1"],[104373,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1400,"source":[[-1401,"-1"],[-1058,"8"],[-1051,"-2"],[-1050,"1"],[-1049,"-3/2"],[-1007,"3/2"],[-1006,"1"],[-1005,"1/2"],[-991,"3/2"],[-930,"3/2"],[-902,"3/2"],[-862,"1"],[-861,"2"],[-831,"3/2"],[-807,"-1/2"],[-784,"2"],[-783,"1"],[-296,"1"]],"banks":[{"chart":280,"remove":98393,"relation":[[94261,"1"],[98393,"1"]]}]}, + {"event":"restrict","direction":"forward","role":846,"source":[[-847,"1"]],"banks":[{"chart":252,"remove":94130,"relation":[[94130,"-1"],[95086,"-1/4"]]}]}, + {"event":"restrict","direction":"forward","role":708,"source":[[-709,"1"]],"banks":[{"chart":602,"remove":97445,"relation":[[97445,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1390,"source":[[-1391,"1"]],"banks":[{"chart":127,"remove":103913,"relation":[[103913,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1420,"source":[[-1421,"1"]],"banks":[{"chart":127,"remove":103824,"relation":[[103732,"-1"],[103733,"-1/2"],[103824,"1"],[104471,"2"]]}]}, + {"event":"restrict","direction":"forward","role":765,"source":[[-766,"1"]],"banks":[{"chart":151,"remove":100826,"relation":[[100826,"1"],[101083,"2"]]}]}, + {"event":"restrict","direction":"forward","role":579,"source":[[-580,"1"]],"banks":[{"chart":871,"remove":91400,"relation":[[91400,"-1"],[91933,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1467,"source":[[-1468,"1"]],"banks":[{"chart":127,"remove":102320,"relation":[[102320,"1"],[102321,"1"],[103422,"-1/2"]]}]}, + {"event":"restrict","direction":"forward","role":736,"source":[[-737,"1"]],"banks":[{"chart":115,"remove":92057,"relation":[[92057,"1"],[92061,"1"],[92063,"1"]]}]}, + {"event":"restrict","direction":"forward","role":375,"source":[[-376,"1"]],"banks":[{"chart":818,"remove":92862,"relation":[[92862,"-1/2"],[96413,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1396,"source":[[-1397,"1"]],"banks":[{"chart":127,"remove":99933,"relation":[[99933,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1356,"source":[[-1357,"1"]],"banks":[{"chart":127,"remove":104177,"relation":[[104177,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1275,"source":[[-1276,"1"]],"banks":[{"chart":114,"remove":92146,"relation":[[92146,"-17/4"],[92148,"1"],[92150,"-5/4"],[92152,"-15/4"],[92156,"-3/4"]]}]}, + {"event":"restrict","direction":"forward","role":391,"source":[[-392,"1"]],"banks":[{"chart":820,"remove":91458,"relation":[[91458,"-1"],[92289,"1"]]}]}, + {"event":"restrict","direction":"forward","role":607,"source":[[-608,"1"]],"banks":[{"chart":115,"remove":92076,"relation":[[92076,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1430,"source":[[-1431,"1"]],"banks":[{"chart":127,"remove":103628,"relation":[[103628,"5/4"],[103629,"1"],[104125,"-1/8"],[104196,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1415,"source":[[-1416,"1"]],"banks":[{"chart":127,"remove":103696,"relation":[[103696,"1"],[103749,"-1/2"],[103750,"-1"],[104451,"2"]]}]}, + {"event":"restrict","direction":"forward","role":1394,"source":[[-1395,"1"]],"banks":[{"chart":127,"remove":98921,"relation":[[98921,"1"],[103526,"-1/2"],[103527,"-1"],[103597,"1"]]}]}, + {"event":"restrict","direction":"forward","role":771,"source":[[-772,"1"]],"banks":[{"chart":127,"remove":104269,"relation":[[104269,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":433,"source":[[-434,"1"]],"banks":[{"chart":127,"remove":98474,"relation":[[98474,"1"]]}]}, + {"event":"restrict","direction":"forward","role":673,"source":[[-674,"1"]],"banks":[{"chart":1048,"remove":93575,"relation":[[93575,"1"],[93579,"1"],[93586,"1"],[93590,"-1"]]}]}, + {"event":"restrict","direction":"forward","role":1351,"source":[[-1352,"1"]],"banks":[{"chart":127,"remove":104102,"relation":[[104102,"-1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1350,"source":[[-1351,"1"]],"banks":[{"chart":127,"remove":104261,"relation":[[104261,"1/2"]]}]}, + {"event":"restrict","direction":"forward","role":1282,"source":[[-1283,"1"]],"banks":[{"chart":116,"remove":93924,"relation":[[93924,"-1"],[93926,"-1/4"],[93930,"9/4"],[93932,"3/2"],[93939,"-13"]]}]}, + {"event":"restrict","direction":"forward","role":1437,"source":[[-1438,"1"]],"banks":[{"chart":127,"remove":104333,"relation":[[104333,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1490,"source":[[-1491,"1"]],"banks":[{"chart":127,"remove":101090,"relation":[[101090,"3/4"]]}]}, + {"event":"restrict","direction":"forward","role":1385,"source":[[-1386,"1"]],"banks":[{"chart":127,"remove":104180,"relation":[[104180,"1"]]}]}, + {"event":"restrict","direction":"forward","role":769,"source":[[-770,"1"]],"banks":[{"chart":127,"remove":104290,"relation":[[104290,"1"],[104291,"-1"]]}]}, + {"event":"restrict","direction":"forward","role":734,"source":[[-735,"1"]],"banks":[{"chart":127,"remove":104026,"relation":[[103514,"1/2"],[103578,"-1/2"],[103648,"-1/2"],[104026,"-2"],[104070,"-1/2"],[104262,"-1/2"],[104267,"2"],[104466,"1/2"],[104467,"1"]]}]}, + {"event":"restrict","direction":"forward","role":631,"source":[[-632,"1"]],"banks":[{"chart":118,"remove":93718,"relation":[[93718,"-17/2"],[93724,"1"],[93726,"1/2"],[93728,"3/2"],[96694,"3"]]}]}, + {"event":"restrict","direction":"forward","role":1354,"source":[[-1355,"1"]],"banks":[{"chart":127,"remove":104228,"relation":[[104228,"-1/4"]]}]}, + {"event":"restrict","direction":"forward","role":1448,"source":[[-1449,"1"]],"banks":[{"chart":127,"remove":103868,"relation":[[103868,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1496,"source":[[-1497,"1"]],"banks":[{"chart":127,"remove":103966,"relation":[[103966,"-4"]]}]}, + {"event":"restrict","direction":"forward","role":1276,"source":[[-1277,"1"]],"banks":[{"chart":115,"remove":94935,"relation":[[94935,"1"]]}]}, + {"event":"restrict","direction":"forward","role":535,"source":[[-536,"1"]],"banks":[{"chart":127,"remove":95365,"relation":[[95365,"1"]]}]}, + {"event":"pivot","direction":"forward","remove":93139,"pivot":99911,"source_chart":3,"combination":[[99911,"1"]],"sender":[[-1311,"1"],[-1244,"2"],[-1181,"1"],[-976,"1"],[-929,"1"],[-921,"-1"],[-899,"-1"],[-681,"1/4"],[-525,"-1"],[-467,"1/2"],[-353,"1/2"]],"receiver":[]}, + {"event":"pivot","direction":"forward","remove":94105,"pivot":99108,"source_chart":3,"combination":[[99108,"-12"]],"sender":[[-1246,"1"],[-1235,"6"],[-1216,"-24"],[-1176,"6"],[-1096,"3"],[-974,"-6"],[-973,"-6"],[-962,"12"],[-926,"12"],[-923,"-12"],[-905,"-12"],[-888,"6"],[-887,"6"],[-644,"3"],[-636,"3"],[-583,"6"],[-549,"-12"],[-443,"-3"],[-418,"12"]],"receiver":[[97179,"6"]]}, + {"event":"pivot","direction":"forward","remove":94107,"pivot":99113,"source_chart":3,"combination":[[99113,"-12"]],"sender":[[-1246,"1"],[-1234,"6"],[-1215,"-24"],[-1177,"6"],[-984,"-12"],[-975,"12"],[-946,"6"],[-945,"6"],[-942,"-6"],[-941,"-6"],[-915,"-12"],[-912,"12"],[-656,"3"],[-584,"6"],[-550,"-12"],[-431,"-3"],[-420,"12"]],"receiver":[[97183,"6"]]}, + {"event":"hub","kind":"group","direction":"forward","incoming":91933,"outgoing":104409,"hub":993,"innovation":[[91933,"1"],[91937,"-1"]],"group":[[91937,"1"]],"receiver":[]}, + {"event":"hub","kind":"group","direction":"forward","incoming":98958,"outgoing":98971,"hub":923,"innovation":[[98958,"1"],[98960,"1/3"]],"group":[[98958,"1/4"],[98960,"1"]],"receiver":[[101078,"1/2"]]}, + {"event":"pivot","direction":"transpose","remove":104409,"pivot":91933,"source_chart":127,"combination":[[91933,"-1"]],"sender":[[-1198,"1"],[-870,"-1/2"],[-823,"-1/2"],[-816,"1/2"],[-789,"1/2"]],"receiver":[]}, + {"event":"pivot","direction":"transpose","remove":97356,"pivot":95058,"source_chart":520,"combination":[[95058,"-1/2"],[95059,"-1/2"],[95062,"3"],[96227,"-1"]],"sender":[[97286,"1"],[97318,"-1"],[97369,"1"]],"receiver":[[89745,"1/2"],[90688,"1/2"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":97475,"outgoing":96717,"hub":46,"innovation":[[97475,"1"],[99922,"-3/4"]],"group":[[97475,"1/4"],[99922,"-1"]],"receiver":[[96754,"1"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":91120,"outgoing":90658,"hub":256,"innovation":[[91120,"1"]],"group":[[91118,"16"],[91120,"-1"]],"receiver":[[90735,"-16"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":95661,"outgoing":93304,"hub":354,"innovation":[[95661,"1"]],"group":[[95661,"1"],[99838,"-1"]],"receiver":[[90436,"1"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":95663,"outgoing":93229,"hub":352,"innovation":[[95663,"1"]],"group":[[95663,"1"],[99841,"-1"]],"receiver":[[90390,"1"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":100230,"outgoing":93308,"hub":347,"innovation":[[100230,"1"]],"group":[[100230,"1"],[100780,"-1"]],"receiver":[[90457,"1"]]}, + {"event":"hub","kind":"group","direction":"transpose","incoming":100625,"outgoing":93312,"hub":351,"innovation":[[100625,"1"]],"group":[[100625,"-1"],[100714,"1"]],"receiver":[[90445,"-1"]]}, + {"event":"pivot","direction":"forward","remove":96751,"pivot":97318,"source_chart":737,"combination":[[97318,"-1"]],"sender":[[94877,"-1"],[97323,"1"]],"receiver":[[97286,"-1"],[97365,"-1/4"]]}, + {"event":"restrict","direction":"transpose","role":1452,"source":[[-1453,"1"],[-180,"-1"],[103623,"-1"]],"banks":[{"chart":105,"remove":99301,"relation":[[98367,"1/3"],[99301,"2/3"]]},{"chart":758,"remove":99308,"relation":[[99308,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":146,"source":[[-147,"1"]],"banks":[{"chart":520,"remove":97286,"relation":[[97286,"1"],[97320,"-1/4"],[97369,"1"]]},{"chart":3,"remove":95058,"relation":[[95058,"1"],[95062,"2"],[96227,"-1"],[96764,"-1/2"],[96765,"-1/4"],[97353,"-1"]]}]}, + {"event":"pivot","direction":"forward","remove":97318,"pivot":103562,"source_chart":737,"combination":[[103562,"-1"]],"sender":[[94877,"-1"],[97323,"1"]],"receiver":[[103277,"-1"],[103982,"-1/4"]]}, + {"event":"hub","kind":"group","direction":"forward","incoming":99473,"outgoing":103418,"hub":189,"innovation":[[99473,"1"]],"group":[[99304,"1"],[99473,"1/12"]],"receiver":[[99476,"1/4"]]}, + {"event":"restrict","direction":"forward","role":1426,"source":[[-1427,"1"],[91881,"-1"],[98077,"4"]],"banks":[{"chart":713,"remove":99579,"relation":[[99579,"2"]]},{"chart":127,"remove":100035,"relation":[[100035,"-2"],[103599,"1"],[103709,"-2"],[104308,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1427,"source":[[-1428,"1"],[91585,"2"]],"banks":[{"chart":883,"remove":98456,"relation":[[98456,"1"]]},{"chart":127,"remove":104307,"relation":[[103507,"-1"],[103796,"1/2"],[104307,"-1"]]}]}, + {"event":"pivot","direction":"forward","remove":91703,"pivot":98460,"source_chart":3,"combination":[[98460,"-1"]],"sender":[[-1287,"1"],[-540,"1/2"],[-524,"-1"],[-511,"-1"],[-466,"-1/2"],[-465,"1/2"],[-256,"1/2"],[-174,"1"]],"receiver":[]}, + {"event":"pivot","direction":"forward","remove":91881,"pivot":99157,"source_chart":3,"combination":[[99157,"-4"]],"sender":[[-989,"1"],[-952,"-2"],[-909,"-2"],[-889,"-2"],[-600,"-2"],[-531,"-4"],[-523,"4"],[-438,"-4"],[-394,"4"],[-380,"-4"],[-317,"1"],[-256,"4"],[-237,"-2"],[-229,"8"],[-174,"-8"]],"receiver":[[95377,"4"]]}, + {"event":"pivot","direction":"forward","remove":99580,"pivot":99808,"source_chart":303,"combination":[[99808,"1"]],"sender":[[90117,"1"],[90118,"1"]],"receiver":[]}, + {"event":"split","direction":"transpose","role":523,"source_chart":127,"split_chart":726,"return_chart":3,"source_covector":[[19,"-8"],[342,"2"],[428,"2"],[539,"2"],[608,"-16"],[609,"16"],[611,"4"],[617,"-4"],[619,"-4"],[624,"4"],[812,"12"],[824,"-2"],[871,"-2"],[1073,"4"],[1074,"4"],[1079,"4"],[1169,"2"],[1199,"-2"],[1228,"-6"]],"source_direction":[[173,"1"],[255,"1/2"],[464,"1/2"],[465,"-1/2"],[510,"-1"],[523,"-1"],[539,"1/2"],[1286,"1"]],"readout":[[98779,"4"],[100809,"1"]],"return_direction":[[173,"1"],[255,"1/2"],[464,"1/2"],[465,"-1/2"],[510,"-1"],[523,"-1"],[539,"1/2"],[1286,"1"]],"return_covector":[[141,"-1"],[172,"-2"],[173,"1/2"],[185,"1"],[195,"1"],[255,"1"],[342,"-1"],[428,"-1"],[608,"-2"],[609,"2"],[617,"-1/2"],[624,"1"],[812,"3"],[1169,"-1"],[1199,"1"],[1228,"-1/2"],[1265,"1"]],"calibration":[[100809,"1"]],"pulse":[[98460,"1"]]}, + {"event":"split","direction":"transpose","role":408,"source_chart":127,"split_chart":498,"return_chart":3,"source_covector":[[16,"-1/2"],[43,"1/2"],[104,"-1/2"],[411,"1"],[815,"3/4"],[869,"-1/4"],[874,"1/2"]],"source_direction":[[126,"1/8"],[238,"3/4"],[267,"-3/8"],[388,"-1/4"],[408,"5/8"],[409,"-7/4"],[411,"2"],[416,"-6"],[418,"1/2"],[993,"2"],[994,"1/4"],[1150,"6"],[1154,"-4"],[1281,"1"],[1283,"-2"],[1295,"1/16"]],"readout":[[103937,"1"]],"return_direction":[[126,"1/8"],[238,"3/4"],[267,"-3/8"],[388,"-1/4"],[408,"5/8"],[409,"-7/4"],[411,"2"],[416,"-6"],[418,"1/2"],[993,"2"],[994,"1/4"],[1150,"6"],[1154,"-4"],[1281,"1"],[1283,"-2"],[1295,"1/16"]],"return_covector":[[126,"-16"],[238,"8"],[349,"1"],[409,"-8"],[411,"8"],[414,"4"],[416,"8"],[417,"1"],[442,"-4"],[471,"4"],[511,"-1"],[527,"-2"],[543,"-1"],[548,"2"],[570,"4"],[572,"-1"],[580,"1"],[608,"2"],[609,"-2"],[611,"-1"],[617,"1"],[624,"-1"],[635,"2"],[643,"1"],[812,"-2"],[924,"3"],[993,"-1"],[1007,"-5"],[1020,"1/2"],[1060,"3/4"],[1073,"-2"],[1095,"-2"],[1118,"-2"],[1148,"-5/2"],[1150,"2"],[1154,"-1/2"],[1157,"-2"],[1175,"-1"],[1228,"1/2"],[1234,"1/2"],[1265,"-2"],[1273,"-4"],[1281,"2"],[1283,"2"],[1300,"2"],[1306,"-3/4"]],"calibration":[[95658,"1"],[103595,"8"],[103933,"-1"],[103937,"-2"],[104022,"-1/2"],[104301,"1"],[104376,"-6"],[104384,"4"],[104418,"-2"]],"pulse":[[92453,"-1/2"],[92454,"-2"],[92458,"-1"],[92460,"-1"],[92462,"-3"],[92464,"-2"],[92471,"5/2"],[92674,"-2"],[92677,"-2"],[92684,"1"],[92689,"-3"],[92694,"-2"]]}, + {"event":"split","direction":"transpose","role":540,"source_chart":127,"split_chart":869,"return_chart":3,"source_covector":[[17,"-2"],[19,"-2"],[30,"-2"],[47,"-2"],[60,"2"],[342,"1"],[376,"1/2"],[428,"1"],[474,"-1"],[521,"-1/2"],[608,"2"],[609,"-2"],[617,"1"],[624,"-1"],[772,"1/2"],[774,"-1/2"],[779,"1/2"],[780,"-1"],[781,"1/2"],[782,"1/2"],[783,"1/2"],[784,"-1/2"],[788,"-1"],[790,"1/2"],[792,"-1"],[794,"1/2"],[795,"1/2"],[796,"1/2"],[797,"1"],[798,"1/2"],[800,"1/2"],[801,"1/2"],[803,"1"],[804,"1"],[805,"1"],[808,"-1/2"],[809,"-1/2"],[812,"-1"],[815,"-1/2"],[816,"1/2"],[818,"1/2"],[822,"1/2"],[828,"-1/2"],[829,"-1/2"],[834,"-1/2"],[835,"-1/2"],[836,"-1/2"],[837,"1/2"],[838,"1/2"],[839,"1/2"],[843,"1/2"],[844,"1/2"],[845,"1/2"],[847,"1"],[848,"-1/2"],[849,"1"],[850,"-1/2"],[852,"-1/2"],[853,"-1/2"],[854,"-1/2"],[855,"1/2"],[857,"1/2"],[858,"1"],[859,"1/2"],[860,"1/2"],[861,"1/2"],[862,"1/2"],[864,"-1/2"],[868,"1/2"],[869,"1"],[870,"1/2"],[871,"1/2"],[872,"1/2"],[873,"-1/2"],[877,"-1/2"],[878,"-1/2"],[879,"-1/2"],[1079,"1"],[1169,"1"],[1177,"1"],[1199,"-1"]],"source_direction":[[347,"1"],[436,"1/2"],[474,"-1"],[540,"-1"]],"readout":[[104443,"1"]],"return_direction":[[347,"1"],[436,"1/2"],[474,"-1"],[540,"-1"]],"return_covector":[[540,"1"]],"calibration":[[100629,"1"],[103597,"1"],[104443,"-1"]],"pulse":[[100624,"1"],[100625,"1"]]}, + {"event":"split","direction":"transpose","role":278,"source_chart":127,"split_chart":549,"return_chart":3,"source_covector":[[19,"2"],[30,"-2"],[38,"2"],[342,"-1/2"],[428,"-1/2"],[752,"1"],[773,"1/2"],[776,"1/2"],[777,"1/2"],[779,"-1/2"],[782,"-1/2"],[783,"-1/2"],[784,"-1/2"],[785,"-1/2"],[790,"-1/2"],[796,"-1/2"],[798,"1/2"],[801,"1/2"],[804,"-1/2"],[808,"-1/2"],[809,"-1/2"],[815,"-1/2"],[817,"-1/2"],[820,"-1/2"],[821,"-1/2"],[822,"1/2"],[826,"-1/2"],[827,"-1/2"],[828,"1/2"],[832,"-1/2"],[833,"-1/2"],[834,"1/2"],[835,"1/2"],[837,"1/2"],[842,"-1/2"],[843,"1/2"],[844,"1/2"],[849,"-1/2"],[851,"-1/2"],[852,"1/2"],[856,"1/2"],[858,"1/2"],[859,"1/2"],[862,"-1/2"],[864,"-1/2"],[865,"1/2"],[868,"-1/2"],[871,"-1/2"],[872,"-1/2"],[873,"-1/2"],[874,"1/2"],[878,"-1/2"],[879,"-1/2"],[880,"1/2"],[881,"1/2"],[1169,"-1/2"],[1199,"1/2"]],"source_direction":[[173,"-8"],[228,"8"],[255,"4"],[278,"33/2"],[379,"-4"],[437,"-4"],[495,"33/2"],[508,"33/2"],[522,"4"],[565,"-99/16"],[566,"-33/8"],[567,"-99/8"],[568,"-33/8"],[569,"-33/4"],[752,"2"],[767,"33/8"],[1204,"33/2"],[1259,"33/4"]],"readout":[[103804,"1"]],"return_direction":[[173,"-8"],[228,"8"],[255,"4"],[278,"33/2"],[379,"-4"],[437,"-4"],[495,"33/2"],[508,"33/2"],[522,"4"],[565,"-99/16"],[566,"-33/8"],[567,"-99/8"],[568,"-33/8"],[569,"-33/4"],[752,"2"],[767,"33/8"],[1204,"33/2"],[1259,"33/4"]],"return_covector":[[173,"-3/4"],[255,"3/2"],[278,"1"],[342,"3/2"],[428,"3/2"],[522,"-3"],[609,"3/2"],[611,"-3/4"],[752,"-6"],[812,"-3/2"],[1122,"3"],[1169,"3/2"],[1199,"-3/2"],[1228,"-3/8"]],"calibration":[[103587,"1"]],"pulse":[[95997,"2"],[96011,"9/2"],[96012,"-9/4"],[96040,"9/2"],[97424,"9/2"],[98070,"9/2"],[99215,"1"]]}, + {"event":"split","direction":"forward","role":548,"source_chart":3,"split_chart":879,"return_chart":127,"source_covector":[[349,"-1"],[475,"1"],[548,"1"],[635,"1/2"],[643,"1/2"],[886,"1"],[887,"1"],[972,"-1"],[973,"-1"],[1095,"1/2"],[1175,"1"],[1234,"1"],[1300,"-1/2"],[1322,"1/2"]],"source_direction":[[548,"1"]],"readout":[[95661,"1"]],"return_direction":[[548,"1"]],"return_covector":[[24,"1/2"],[45,"1/2"],[48,"-1/2"],[85,"-1/2"],[233,"-1/4"],[349,"1"],[363,"1/2"],[366,"1/4"],[504,"1/4"],[548,"-1"],[551,"1/8"],[600,"1/2"],[726,"-1/8"],[1033,"1/2"],[1300,"1/2"]],"calibration":[[95661,"-1"],[99838,"1"]],"pulse":[[101259,"1"],[104296,"1"],[104441,"-1"]]}, + {"event":"split","direction":"forward","role":549,"source_chart":3,"split_chart":880,"return_chart":127,"source_covector":[[397,"-1"],[476,"1"],[549,"1"],[655,"1/2"],[940,"-1"],[941,"-1"],[944,"1"],[945,"1"],[1176,"1"],[1233,"1"],[1293,"-1"],[1302,"-1/2"],[1321,"1/2"]],"source_direction":[[549,"1"]],"readout":[[95663,"1"]],"return_direction":[[549,"1"]],"return_covector":[[32,"-1/2"],[35,"1/2"],[98,"-1/2"],[107,"1/2"],[233,"-1/4"],[363,"1/2"],[366,"1/4"],[504,"1/4"],[549,"-1"],[551,"1/8"],[600,"1/2"],[726,"-1/8"],[1033,"1/2"],[1293,"1"],[1302,"1/2"]],"calibration":[[95663,"-1"],[99841,"1"]],"pulse":[[100872,"1"],[103989,"1"],[104457,"-1"]]}, + {"event":"restrict","direction":"transpose","role":523,"source":[[-524,"1"]],"banks":[{"chart":726,"remove":98779,"relation":[[98779,"4"],[100809,"1"]]},{"chart":862,"remove":103747,"relation":[[99402,"4"],[103747,"2"]]}]}, + {"event":"restrict","direction":"transpose","role":278,"source":[[-279,"1"]],"banks":[{"chart":549,"remove":103804,"relation":[[103804,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1506,"source":[[-1507,"1"]],"banks":[{"chart":879,"remove":104296,"relation":[[101259,"-1"],[104296,"-1"],[104441,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":540,"source":[[-541,"1"]],"banks":[{"chart":869,"remove":104443,"relation":[[104443,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":408,"source":[[-409,"1"]],"banks":[{"chart":498,"remove":103937,"relation":[[103937,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1507,"source":[[-1508,"1"]],"banks":[{"chart":880,"remove":103989,"relation":[[100872,"-1"],[103989,"-1"],[104457,"1"]]}]}, + {"event":"restrict","direction":"transpose","role":1502,"source":[[-1503,"1"]],"banks":[{"chart":3,"remove":98460,"relation":[[88831,"-1"],[88836,"1"],[98460,"1"]]}]}, + {"event":"restrict","direction":"forward","role":548,"source":[[-549,"1"]],"banks":[{"chart":354,"remove":93304,"relation":[[93304,"1"],[94477,"1"],[94478,"-1"]]},{"chart":879,"remove":95661,"relation":[[95661,"1"]]}]}, + {"event":"restrict","direction":"forward","role":549,"source":[[-550,"1"]],"banks":[{"chart":352,"remove":93229,"relation":[[93229,"1"],[94480,"1"],[94481,"-1"]]},{"chart":880,"remove":95663,"relation":[[95663,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1504,"source":[[-1505,"-1"],[-1178,"-1"],[-972,"1"],[-965,"-1"],[-891,"1"]],"banks":[{"chart":351,"remove":93312,"relation":[[93053,"-1"],[93054,"1"],[93312,"1"]]},{"chart":869,"remove":100625,"relation":[[100625,"1"]]}]}, + {"event":"restrict","direction":"forward","role":1505,"source":[[-1506,"-15"],[-1350,"-20/3"],[-1296,"1/2"],[-1288,"-5/3"],[-1284,"-8/3"],[-1282,"4/3"],[-1280,"-10"],[-1266,"-5/2"],[-1260,"20/3"],[-1259,"-5/6"],[-1256,"-10"],[-1251,"-5/3"],[-1243,"10/3"],[-1236,"10"],[-1235,"-10/3"],[-1234,"-10/3"],[-1230,"-10/3"],[-1229,"-10"],[-1228,"-10/3"],[-1213,"5/3"],[-1211,"-20/3"],[-1209,"20/3"],[-1206,"-20/3"],[-1205,"40/3"],[-1203,"20/3"],[-1202,"20/3"],[-1196,"40/3"],[-1179,"20/3"],[-1178,"20/3"],[-1177,"-10/3"],[-1176,"-10/3"],[-1172,"20/3"],[-1171,"-20/3"],[-1155,"-16/3"],[-1151,"8"],[-1121,"5/3"],[-1119,"5/3"],[-1117,"40/3"],[-1115,"5/3"],[-1114,"10/3"],[-1096,"5/3"],[-1095,"40/3"],[-1080,"-5"],[-1079,"20/3"],[-1075,"-5/3"],[-1074,"-5/3"],[-1073,"-20/3"],[-1066,"20/3"],[-1064,"-20/3"],[-1063,"-20/3"],[-1044,"-20/3"],[-1033,"20/3"],[-1004,"5/3"],[-1003,"40/3"],[-995,"2"],[-994,"8/3"],[-989,"-20/3"],[-974,"20/3"],[-973,"20/3"],[-972,"20/3"],[-971,"-20/3"],[-969,"-20/3"],[-968,"20/3"],[-967,"20/3"],[-966,"20/3"],[-965,"20/3"],[-964,"20/3"],[-963,"20/3"],[-961,"20/3"],[-960,"20/3"],[-959,"20/3"],[-958,"-20/3"],[-957,"20/3"],[-956,"-20/3"],[-952,"20/3"],[-951,"20/3"],[-950,"20/3"],[-949,"20/3"],[-948,"20/3"],[-947,"20/3"],[-946,"20/3"],[-945,"20/3"],[-944,"20/3"],[-943,"20/3"],[-942,"20/3"],[-941,"20/3"],[-940,"-20/3"],[-939,"-20/3"],[-937,"20/3"],[-936,"20/3"],[-935,"-20/3"],[-914,"-10/3"],[-910,"20/3"],[-909,"20/3"],[-908,"20/3"],[-907,"20/3"],[-906,"20/3"],[-894,"-20/3"],[-893,"-20/3"],[-891,"20/3"],[-890,"-20/3"],[-889,"20/3"],[-888,"20/3"],[-887,"20/3"],[-885,"20/3"],[-884,"20/3"],[-883,"20/3"],[-813,"-5"],[-753,"250/33"],[-705,"-5/3"],[-698,"5"],[-656,"5/3"],[-644,"5/3"],[-642,"-5"],[-641,"5/2"],[-625,"-5/3"],[-620,"-5/3"],[-618,"-5"],[-612,"-10"],[-610,"5/2"],[-609,"-5/6"],[-600,"10"],[-568,"10/3"],[-566,"5/3"],[-565,"10/3"],[-564,"10/3"],[-545,"-10"],[-544,"-40/3"],[-539,"-5/3"],[-538,"20/3"],[-537,"-40/3"],[-531,"20"],[-529,"-5"],[-528,"-20/3"],[-523,"-490/33"],[-513,"-10/3"],[-512,"-10/3"],[-511,"10/3"],[-509,"-20/3"],[-500,"-10/3"],[-497,"-20"],[-462,"-10/3"],[-450,"20/3"],[-449,"-20/3"],[-440,"-25"],[-438,"160/33"],[-419,"4"],[-417,"-8"],[-415,"-20/3"],[-412,"8/3"],[-410,"-4"],[-400,"-20/3"],[-389,"-2"],[-384,"10"],[-383,"10/3"],[-381,"10/3"],[-380,"380/33"],[-378,"20/3"],[-377,"20/3"],[-373,"-10/3"],[-371,"20/3"],[-366,"-10/3"],[-361,"-10/3"],[-337,"-20/3"],[-317,"15"],[-314,"-20/3"],[-312,"20"],[-307,"-5/3"],[-273,"50"],[-268,"-4/3"],[-256,"-325/33"],[-248,"-10/3"],[-239,"-2/3"],[-237,"-30"],[-229,"-320/33"],[-174,"180/11"],[-173,"-10/3"],[-143,"-10/3"],[-127,"1"]],"banks":[{"chart":549,"remove":99215,"relation":[[96011,"-15"],[96012,"15/2"],[96040,"-15"],[97424,"-15"],[98070,"-15"],[99215,"-10/3"]]},{"chart":593,"remove":91873,"relation":[[91873,"-40/3"],[91875,"80/3"],[91877,"-40/3"],[94057,"20/3"],[94059,"20/3"],[94061,"10/3"],[95080,"20/3"],[95082,"-20/3"],[98514,"10/3"]]}]}, + {"event":"split","direction":"transpose","role":238,"source_chart":127,"split_chart":498,"return_chart":3,"source_covector":[[16,"-1"],[43,"1"],[104,"-1"],[411,"2"],[815,"3/2"],[869,"3/2"],[874,"3"],[1154,"1"]],"source_direction":[[126,"19/40"],[238,"-3/20"],[267,"-3/10"],[388,"-9/20"],[409,"-33/20"],[411,"8/5"],[416,"-43/10"],[418,"9/10"],[993,"3/5"],[994,"9/20"],[1150,"29/5"],[1154,"-26/5"],[1281,"4/5"],[1283,"-8/5"],[1295,"9/80"]],"readout":[[104301,"1"]],"return_direction":[[126,"19/40"],[238,"-3/20"],[267,"-3/10"],[388,"-9/20"],[409,"-33/20"],[411,"8/5"],[416,"-43/10"],[418,"9/10"],[993,"3/5"],[994,"9/20"],[1150,"29/5"],[1154,"-26/5"],[1281,"4/5"],[1283,"-8/5"],[1295,"9/80"]],"return_covector":[[3,"-1/2"],[39,"1"],[112,"1/2"],[113,"1/2"],[114,"1/2"],[116,"1/2"],[117,"1/2"],[121,"-1/2"],[125,"1/2"],[126,"3"],[129,"-1"],[134,"-1/2"],[135,"-1/2"],[140,"1/2"],[144,"1/2"],[150,"1"],[153,"-1/2"],[154,"-1/2"],[156,"-1/2"],[157,"-1/2"],[158,"-1/2"],[159,"-1"],[161,"1/2"],[162,"1/2"],[164,"1"],[165,"1/2"],[168,"1/2"],[169,"-1/2"],[171,"1/2"],[172,"1"],[173,"-1/4"],[174,"-1/2"],[175,"-1/2"],[178,"1/2"],[180,"1/2"],[181,"1/2"],[184,"1/2"],[187,"1/2"],[190,"1/2"],[191,"-1/2"],[192,"1/2"],[193,"-1/2"],[195,"1/2"],[196,"1/2"],[197,"1/2"],[198,"1/2"],[199,"1/2"],[200,"1/2"],[202,"1/2"],[203,"1/2"],[207,"-1/2"],[212,"-1/2"],[216,"-1/2"],[219,"-1/2"],[222,"-1/2"],[223,"-1/2"],[238,"-3/2"],[252,"-1/2"],[255,"1/2"],[265,"-1"],[267,"1"],[334,"-1"],[349,"-1/8"],[359,"-1/2"],[383,"-1"],[388,"1/4"],[404,"1/4"],[409,"3/2"],[411,"-7/4"],[414,"-1/2"],[416,"-3/2"],[417,"-1/8"],[442,"1/2"],[446,"-1/2"],[456,"-1"],[461,"-1"],[464,"1/2"],[467,"1/4"],[471,"-1/2"],[504,"1/2"],[508,"-1/2"],[511,"1/8"],[518,"-1"],[519,"1/2"],[522,"-1"],[525,"1/4"],[526,"1/2"],[527,"1/4"],[543,"1/8"],[545,"-1/4"],[558,"-1"],[560,"-1"],[561,"-1"],[565,"-1"],[567,"-1/2"],[570,"-1/2"],[572,"1/8"],[578,"-1"],[580,"1/8"],[592,"1/4"],[600,"-1/4"],[608,"-1/4"],[609,"3/4"],[611,"-1/8"],[617,"-1/8"],[624,"1/8"],[635,"-1/4"],[643,"-1/8"],[664,"1/2"],[665,"1/4"],[679,"1/2"],[688,"1/4"],[689,"-1/2"],[695,"1/4"],[758,"-1/2"],[775,"-1/2"],[793,"-1/16"],[812,"-1/4"],[924,"-7/8"],[993,"1/4"],[994,"1/2"],[1007,"9/8"],[1015,"1/16"],[1017,"1"],[1020,"-1/16"],[1047,"-2"],[1060,"-3/32"],[1073,"1/4"],[1095,"1/4"],[1109,"1/2"],[1118,"-1/4"],[1120,"1/2"],[1122,"1"],[1126,"1"],[1127,"4"],[1128,"-1"],[1148,"7/16"],[1150,"-3/8"],[1157,"1/4"],[1173,"1/4"],[1175,"1/8"],[1181,"-1/4"],[1216,"-1"],[1228,"-3/16"],[1234,"-1/16"],[1244,"-1/4"],[1253,"-1/4"],[1256,"1/4"],[1257,"-1/2"],[1259,"-1/2"],[1264,"1/8"],[1265,"1/4"],[1272,"-1/16"],[1273,"1/2"],[1281,"-1/2"],[1283,"-1/4"],[1295,"-1"],[1300,"-1/4"],[1306,"39/32"],[1309,"-1/2"],[1317,"-3"],[1319,"1/2"],[1329,"1/2"],[1472,"-1"]],"calibration":[[92636,"1"],[95658,"-3/16"],[103595,"-3/2"],[103933,"3/16"],[104022,"3/32"],[104301,"-3/16"],[104376,"9/8"],[104384,"-3/4"],[104418,"3/8"]],"pulse":[[92453,"-1/4"],[92454,"1"],[92456,"1/4"],[92458,"1"],[92462,"2"],[92464,"3/2"],[92471,"-3/2"],[92674,"1"],[92677,"1"],[92684,"-1/2"],[92689,"3/2"],[92690,"1"]]}, + {"event":"pivot","direction":"forward","remove":97181,"pivot":104441,"source_chart":766,"combination":[[104441,"2"]],"sender":[[95660,"2"],[97179,"1"],[99108,"-1/6"]],"receiver":[]}, + {"event":"pivot","direction":"forward","remove":97185,"pivot":104457,"source_chart":767,"combination":[[104457,"2"]],"sender":[[95662,"2"],[97183,"1"],[99113,"-1/6"]],"receiver":[]}, + {"event":"pivot","direction":"transpose","remove":103597,"pivot":100624,"source_chart":127,"combination":[[100624,"-1"]],"sender":[[-1200,"1"],[-1178,"-1"],[-1170,"-1"],[-1080,"-1"],[-880,"1/2"],[-879,"1/2"],[-878,"1/2"],[-874,"1/2"],[-873,"-1/2"],[-872,"-1/2"],[-871,"-1/2"],[-870,"-1"],[-869,"-1/2"],[-865,"1/2"],[-863,"-1/2"],[-862,"-1/2"],[-861,"-1/2"],[-860,"-1/2"],[-859,"-1"],[-858,"-1/2"],[-856,"-1/2"],[-855,"1/2"],[-854,"1/2"],[-853,"1/2"],[-851,"1/2"],[-850,"-1"],[-849,"1/2"],[-848,"-1"],[-846,"-1/2"],[-845,"-1/2"],[-844,"-1/2"],[-840,"-1/2"],[-839,"-1/2"],[-838,"-1/2"],[-837,"1/2"],[-836,"1/2"],[-835,"1/2"],[-830,"1/2"],[-829,"1/2"],[-823,"-1/2"],[-819,"-1/2"],[-817,"-1/2"],[-816,"1/2"],[-813,"1"],[-810,"1/2"],[-809,"1/2"],[-806,"-1"],[-805,"-1"],[-804,"-1"],[-802,"-1/2"],[-801,"-1/2"],[-799,"-1/2"],[-798,"-1"],[-797,"-1/2"],[-796,"-1/2"],[-795,"-1/2"],[-793,"1"],[-791,"-1/2"],[-789,"1"],[-785,"1/2"],[-784,"-1/2"],[-783,"-1/2"],[-782,"-1/2"],[-781,"1"],[-780,"-1/2"],[-775,"1/2"],[-773,"-1/2"],[-625,"1"],[-618,"-1"],[-610,"2"],[-609,"-2"],[-522,"1/2"],[-475,"1"],[-429,"-1"],[-377,"-1/2"],[-343,"-1"],[-61,"-2"],[-48,"2"],[-31,"2"],[-20,"2"],[-18,"2"]],"receiver":[]}, + {"event":"pivot","direction":"transpose","remove":99850,"pivot":98461,"source_chart":884,"combination":[[98461,"1"]],"sender":[[102713,"1"],[102736,"1"]],"receiver":[[95303,"4"]]}, + {"event":"restrict","direction":"forward","role":238,"source":[[-239,"1"]],"banks":[{"chart":127,"remove":103711,"relation":[[103711,"1/4"],[103933,"1/2"],[104021,"-1/2"],[104123,"-1/16"],[104262,"3/16"],[104301,"1"],[104418,"-1/4"]]}]}, + {"event":"split","direction":"transpose","role":267,"source_chart":127,"split_chart":498,"return_chart":3,"source_covector":[[16,"-3"],[43,"5"],[104,"-1"],[349,"-1/2"],[411,"4"],[414,"-2"],[417,"-1/2"],[442,"2"],[471,"-2"],[511,"1/2"],[527,"1"],[543,"1/2"],[570,"-2"],[572,"1/2"],[580,"-1/2"],[608,"-1"],[609,"1"],[611,"1/2"],[617,"-1/2"],[624,"1/2"],[635,"-1"],[643,"-1/2"],[812,"1"],[815,"7/2"],[816,"-1"],[822,"1"],[848,"1"],[869,"1/2"],[874,"3"],[924,"-3/2"],[993,"-1/2"],[1007,"5/2"],[1020,"-1/4"],[1060,"-3/8"],[1073,"1"],[1095,"1"],[1118,"1"],[1148,"1/4"],[1154,"7/4"],[1157,"1"],[1175,"1/2"],[1228,"-1/4"],[1234,"-1/4"],[1265,"1"],[1273,"2"],[1281,"1"],[1283,"-1"],[1300,"-1"],[1306,"3/8"]],"source_direction":[[126,"-4/3"],[267,"1"],[388,"1"],[409,"4"],[411,"-10/3"],[416,"28/3"],[418,"-2"],[994,"-1"],[1150,"-40/3"],[1154,"40/3"],[1281,"-2/3"],[1283,"16/3"],[1295,"-1/4"]],"readout":[[104301,"1"]],"return_direction":[[126,"-4/3"],[267,"1"],[388,"1"],[409,"4"],[411,"-10/3"],[416,"28/3"],[418,"-2"],[994,"-1"],[1150,"-40/3"],[1154,"40/3"],[1281,"-2/3"],[1283,"16/3"],[1295,"-1/4"]],"return_covector":[[3,"-1/4"],[39,"1/2"],[112,"1/4"],[113,"-1/4"],[114,"1/4"],[116,"1/4"],[117,"1/4"],[118,"1/2"],[120,"1/2"],[121,"-3/4"],[122,"-1/2"],[123,"-1/2"],[125,"1/4"],[126,"-3/2"],[128,"-1/2"],[129,"1/2"],[130,"1/2"],[131,"1"],[134,"-1/4"],[135,"-1/4"],[137,"1/2"],[139,"1/2"],[140,"3/4"],[141,"1/2"],[142,"1"],[143,"-1/2"],[144,"1/4"],[147,"-1/2"],[148,"1/2"],[149,"1/2"],[150,"1/2"],[153,"-1/4"],[154,"-1/4"],[156,"-1/4"],[157,"1/4"],[158,"1/4"],[159,"1/2"],[161,"1/4"],[162,"1/4"],[163,"-1/2"],[164,"-1/2"],[165,"-1/4"],[166,"-1/2"],[167,"-1/2"],[168,"-1/4"],[169,"-3/4"],[170,"1/2"],[171,"3/4"],[172,"3/2"],[173,"-1/8"],[174,"-1/4"],[175,"-1/4"],[178,"1/4"],[179,"1/2"],[180,"3/4"],[181,"3/4"],[182,"1/2"],[183,"1/2"],[184,"3/4"],[187,"1/4"],[190,"-1/4"],[191,"-1/4"],[192,"3/4"],[193,"-1/4"],[195,"1/4"],[196,"1/4"],[197,"-1/4"],[198,"1/4"],[199,"3/4"],[200,"1/4"],[202,"1/4"],[203,"1/4"],[204,"-1/2"],[206,"-1/2"],[207,"1/4"],[208,"1/2"],[209,"1/2"],[210,"1/2"],[212,"-1/4"],[215,"1/2"],[216,"-3/4"],[217,"-1/2"],[218,"-1/2"],[219,"-1/4"],[222,"-1/4"],[223,"-1/4"],[252,"-1/4"],[255,"1/4"],[265,"-1/2"],[267,"1/2"],[272,"-1/4"],[302,"1"],[334,"-1/2"],[342,"5/2"],[349,"1/16"],[352,"1/4"],[356,"-1"],[358,"-1/2"],[359,"-1/4"],[360,"-1/4"],[363,"-1/2"],[364,"-1/2"],[366,"1/2"],[383,"-1/2"],[388,"1/8"],[404,"1/8"],[409,"-7/4"],[411,"7/8"],[414,"1/4"],[416,"5/4"],[417,"1/16"],[428,"5/2"],[439,"1/2"],[442,"-1/4"],[445,"-1"],[446,"-1/4"],[456,"-1/2"],[458,"-1"],[461,"-1/2"],[464,"1/4"],[466,"-1/2"],[467,"1/8"],[471,"1/4"],[478,"1/2"],[482,"1"],[484,"1"],[489,"-1/4"],[490,"-1"],[494,"1/2"],[496,"-1"],[497,"-1/2"],[499,"-1/4"],[502,"1/2"],[504,"1/4"],[508,"-1/4"],[511,"-1/16"],[518,"-1/2"],[519,"1/4"],[522,"-1/2"],[525,"1/8"],[526,"1/4"],[527,"-1/8"],[543,"-1/16"],[545,"-1/8"],[547,"-1/4"],[558,"-3/2"],[560,"-3/2"],[561,"-1/2"],[562,"-1/2"],[565,"-1/2"],[567,"-1/4"],[569,"-1/2"],[570,"1/4"],[571,"1"],[572,"-5/16"],[574,"1"],[577,"-1/4"],[578,"-1/2"],[580,"3/16"],[592,"1/8"],[600,"-1/8"],[608,"1/8"],[609,"1/8"],[611,"-3/16"],[617,"1/16"],[624,"-1/16"],[625,"1/2"],[635,"1/8"],[640,"1/2"],[643,"1/16"],[659,"-1/2"],[664,"1/4"],[665,"1/8"],[671,"1/4"],[679,"-1/4"],[688,"3/8"],[689,"1/4"],[695,"1/8"],[726,"-1"],[758,"-1/4"],[767,"-1"],[775,"-1/4"],[793,"-1/32"],[812,"-7/8"],[924,"-9/16"],[993,"-3/8"],[994,"1/4"],[1003,"-1/2"],[1007,"-1/16"],[1015,"1/32"],[1017,"1/2"],[1020,"1/32"],[1044,"-3/2"],[1047,"-1"],[1055,"-1/8"],[1058,"1/8"],[1060,"-5/64"],[1073,"-5/8"],[1074,"-1/2"],[1077,"1"],[1079,"-1/2"],[1094,"1"],[1095,"-1/8"],[1102,"-1/8"],[1104,"2"],[1109,"-1/4"],[1116,"-1"],[1118,"-3/8"],[1120,"-1/4"],[1121,"-1/2"],[1122,"1/2"],[1126,"1/2"],[1127,"2"],[1128,"-1/2"],[1148,"-7/32"],[1150,"7/16"],[1154,"1/8"],[1155,"1/4"],[1157,"-1/8"],[1169,"5/2"],[1173,"1/8"],[1175,"-1/16"],[1180,"1/8"],[1181,"-1/8"],[1199,"-5/2"],[1203,"-1/4"],[1207,"1"],[1216,"-1/2"],[1228,"-1/32"],[1234,"1/32"],[1241,"1/2"],[1244,"1/8"],[1253,"1/8"],[1255,"-1/4"],[1256,"1/8"],[1257,"-1/4"],[1259,"-1/4"],[1260,"-1"],[1264,"3/16"],[1265,"-1/8"],[1272,"-1/32"],[1273,"-1/4"],[1277,"-1/4"],[1279,"-1/8"],[1281,"3/4"],[1283,"1/8"],[1295,"-1/2"],[1300,"1/8"],[1306,"33/64"],[1307,"1/4"],[1309,"-1/4"],[1317,"-3/2"],[1319,"1/4"],[1329,"1/4"],[1472,"-1/2"]],"calibration":[[92636,"1/2"],[94005,"1"],[95658,"3/32"],[103595,"-1/4"],[103933,"-11/32"],[104021,"1/4"],[104022,"-3/64"],[104301,"7/32"],[104376,"-9/16"],[104384,"7/8"],[104418,"5/16"]],"pulse":[[92453,"-1/4"],[92454,"-1"],[92456,"1/4"],[92458,"-1"],[92464,"-1/2"],[92471,"1/2"],[92669,"4"],[92674,"-3"],[92677,"-1"],[92684,"-1/2"],[92689,"-1/2"],[92690,"1"]]}, + {"event":"restrict","direction":"transpose","role":267,"source":[[-268,"1"]],"banks":[{"chart":498,"remove":104301,"relation":[[104301,"1"]]}]}, + {"event":"split","direction":"forward","role":294,"source_chart":3,"split_chart":288,"return_chart":127,"source_covector":[[21,"1"],[61,"-1/2"],[126,"-1/12"],[142,"-1/4"],[150,"-1/4"],[152,"-1/4"],[188,"3"],[226,"3"],[232,"3"],[237,"3"],[243,"1"],[249,"1"],[250,"3"],[257,"1"],[268,"-4"],[272,"-1/4"],[276,"-3/8"],[280,"-2"],[281,"1"],[283,"-3"],[284,"3/4"],[288,"-21/8"],[290,"3"],[294,"-3"],[295,"-1/2"],[299,"12"],[302,"-1/16"],[306,"-1/8"],[313,"-1"],[319,"1/2"],[331,"1/2"],[334,"1/4"],[336,"-1/2"],[344,"1/2"],[352,"-1/8"],[354,"1/16"],[356,"-1/8"],[360,"-1/4"],[363,"2"],[364,"1/4"],[365,"-1/4"],[366,"1"],[370,"1/2"],[372,"-1/4"],[376,"1/2"],[382,"1/4"],[399,"-3/2"],[404,"1"],[407,"-1"],[409,"1/4"],[411,"-1/3"],[414,"-1"],[416,"5/6"],[417,"1"],[424,"-1/2"],[429,"8"],[434,"-1/2"],[439,"1/8"],[440,"1/2"],[441,"-2"],[442,"1/4"],[448,"-1/2"],[449,"-1"],[458,"-1/4"],[469,"-1"],[470,"-1"],[471,"1/4"],[479,"-1"],[490,"1/2"],[491,"-2"],[494,"-1/2"],[499,"-1/4"],[502,"-1/4"],[504,"1"],[510,"1/4"],[511,"3/4"],[513,"-1/4"],[517,"-2"],[525,"1/4"],[527,"-1"],[528,"-3/4"],[536,"-2"],[537,"3"],[538,"15/8"],[541,"-1"],[543,"-7/4"],[544,"-5/4"],[547,"1"],[551,"1/2"],[558,"1"],[560,"-1"],[561,"1/8"],[562,"1/4"],[565,"-1/8"],[567,"-1/4"],[568,"-1/4"],[570,"1/4"],[571,"-1/8"],[573,"-1/2"],[581,"-3/8"],[583,"1/8"],[587,"5/8"],[589,"1"],[591,"1/8"],[600,"2"],[608,"-1/8"],[609,"-3/16"],[619,"-1/8"],[624,"-1/4"],[635,"1/4"],[640,"-5/16"],[643,"3/8"],[655,"1/4"],[659,"1/4"],[680,"1/16"],[681,"-1/8"],[688,"-1/8"],[691,"-1/8"],[704,"-7/4"],[707,"1/8"],[711,"1"],[726,"-1/2"],[732,"4"],[733,"2"],[756,"2"],[760,"-1/2"],[761,"-1/8"],[789,"1"],[802,"1/4"],[806,"-2"],[810,"-1"],[811,"1/2"],[883,"1/2"],[884,"1/2"],[886,"-1/2"],[889,"-1/2"],[890,"1/2"],[892,"1/2"],[895,"-1/2"],[896,"-1/2"],[897,"-1/2"],[898,"1/2"],[899,"1/2"],[900,"-1/2"],[902,"1"],[903,"1/2"],[904,"1"],[905,"1/2"],[906,"1"],[907,"1"],[908,"1/2"],[910,"1/2"],[912,"-1/2"],[913,"-1/8"],[914,"1"],[916,"-1/2"],[918,"1/2"],[920,"1/2"],[921,"1/2"],[922,"1/2"],[923,"-1/2"],[924,"-1/2"],[925,"-1/2"],[927,"-1/2"],[928,"-1/2"],[929,"1/2"],[930,"-1/2"],[931,"1/2"],[933,"1/2"],[934,"1/2"],[936,"1/2"],[938,"-1/2"],[940,"1"],[941,"1/2"],[942,"1"],[943,"-1/2"],[945,"-1/2"],[946,"1/2"],[948,"1/2"],[949,"1/2"],[951,"1/2"],[953,"1/2"],[954,"-1/2"],[956,"-1/2"],[957,"1/2"],[959,"1/2"],[962,"1/2"],[965,"1/2"],[966,"1"],[967,"1/2"],[968,"-1/2"],[971,"1/2"],[972,"1"],[973,"1/2"],[974,"-1/2"],[975,"-1/2"],[977,"1/2"],[980,"1/2"],[981,"1"],[982,"1/2"],[983,"1/2"],[984,"1"],[985,"1/2"],[986,"-1/2"],[988,"-5/8"],[990,"1/2"],[999,"1/4"],[1002,"1/2"],[1004,"1"],[1005,"1"],[1007,"-1/2"],[1009,"-1"],[1011,"-1/4"],[1013,"2"],[1018,"-1/4"],[1019,"1/2"],[1021,"-1"],[1027,"1"],[1029,"-1/4"],[1031,"-1/2"],[1032,"-1"],[1033,"5/2"],[1034,"-1/2"],[1035,"-2"],[1037,"1"],[1039,"-1"],[1042,"-1/2"],[1043,"-1"],[1046,"1"],[1048,"2"],[1053,"-1"],[1055,"-1/2"],[1058,"-1/2"],[1060,"2"],[1063,"3/2"],[1065,"-1/2"],[1066,"1/2"],[1068,"1"],[1072,"-1/4"],[1073,"-1/8"],[1074,"-1/4"],[1075,"-1/2"],[1077,"1"],[1078,"1"],[1079,"-3/8"],[1080,"1/2"],[1081,"1/2"],[1086,"1/8"],[1094,"1"],[1095,"1/4"],[1109,"1/8"],[1110,"1/8"],[1112,"1/2"],[1113,"-1/4"],[1114,"-3/8"],[1116,"1/2"],[1118,"1/8"],[1121,"1/2"],[1127,"1/8"],[1128,"1/8"],[1141,"2"],[1143,"2"],[1146,"-1"],[1150,"-4/3"],[1154,"4/3"],[1162,"-1/2"],[1170,"-1"],[1171,"7"],[1172,"-1"],[1173,"1/2"],[1174,"-1/4"],[1175,"1/2"],[1176,"1/4"],[1178,"-1/4"],[1180,"1/4"],[1181,"1/4"],[1182,"-1/4"],[1184,"1/4"],[1186,"-1/4"],[1187,"-1"],[1188,"-1/8"],[1190,"-1/8"],[1191,"-1/8"],[1193,"1/8"],[1194,"1/2"],[1195,"1/2"],[1198,"-1/2"],[1201,"1"],[1203,"1/2"],[1204,"1"],[1206,"2"],[1207,"1/4"],[1208,"1/2"],[1212,"-3/8"],[1214,"1/2"],[1216,"5/2"],[1221,"1/2"],[1222,"-3/4"],[1227,"-1/4"],[1228,"-3/4"],[1230,"1/8"],[1233,"1/2"],[1234,"1/4"],[1236,"-1/2"],[1240,"-1/8"],[1242,"1/4"],[1243,"-1/2"],[1244,"-1/2"],[1245,"-1/2"],[1248,"-1/4"],[1249,"1/4"],[1250,"-1/4"],[1253,"1/2"],[1255,"1/4"],[1256,"-1/2"],[1257,"-1/2"],[1258,"-1/16"],[1259,"1/2"],[1260,"1/4"],[1262,"-1/4"],[1264,"1/4"],[1273,"1/4"],[1274,"3/8"],[1279,"-3/4"],[1281,"-1/6"],[1283,"1/3"],[1287,"-1/8"],[1306,"2"],[1309,"-1/8"],[1319,"-1/8"],[1328,"-2"],[1340,"1"],[1343,"-2/3"],[1349,"-1/4"],[1449,"-2"],[1466,"-1"],[1469,"-2"],[1470,"-3/8"],[1471,"-4"],[1473,"-1"]],"source_direction":[[61,"2"],[290,"2"],[294,"3"],[299,"1/2"],[300,"1"]],"readout":[[89190,"1"],[89191,"-2"],[89199,"2"],[89218,"1"],[94261,"1"]],"return_direction":[[61,"2"],[290,"2"],[294,"3"],[299,"1/2"],[300,"1"]],"return_covector":[[62,"1/2"],[70,"-1/2"],[188,"1/2"],[226,"1/2"],[232,"1/2"],[237,"1/2"],[250,"1/2"],[288,"-1/2"],[290,"1/2"],[294,"-1/2"],[299,"2"]],"calibration":[[89199,"1"]],"pulse":[[104083,"1"],[104128,"-4"],[104419,"1/2"]]}, + {"event":"split","direction":"transpose","role":288,"source_chart":127,"split_chart":288,"return_chart":3,"source_covector":[[782,"-1"],[783,"-1"],[832,"-3"],[833,"1"],[840,"3"],[841,"-1"],[860,"1"],[861,"1"],[1004,"1"]],"source_direction":[[188,"-1"],[226,"-1"],[232,"-1"],[237,"-1"],[249,"-1"],[250,"-1"],[288,"1"],[431,"1"],[1004,"-4"],[1049,"-2"],[1050,"2"],[1057,"1"]],"readout":[[103826,"1"]],"return_direction":[[188,"-1"],[226,"-1"],[232,"-1"],[237,"-1"],[249,"-1"],[250,"-1"],[288,"1"],[431,"1"],[1004,"-4"],[1049,"-2"],[1050,"2"],[1057,"1"]],"return_covector":[[61,"1/3"],[112,"-1/2"],[116,"-1/2"],[118,"-1/2"],[122,"1/2"],[124,"-1/2"],[125,"-1/2"],[127,"-1/2"],[130,"1/2"],[132,"-1/2"],[134,"1/2"],[136,"1/2"],[138,"1/2"],[139,"1/2"],[140,"1/2"],[142,"1"],[145,"-1/2"],[147,"1/2"],[149,"-1/2"],[150,"1"],[152,"1"],[154,"-1/2"],[158,"-1/2"],[160,"-1/2"],[162,"-1/2"],[163,"-1/2"],[165,"-1/2"],[167,"-1/2"],[171,"1/2"],[174,"-1/2"],[176,"1/2"],[178,"1/2"],[179,"-1/2"],[181,"-1/2"],[183,"-1/2"],[186,"-1/2"],[189,"1/2"],[190,"-1/2"],[192,"-1/2"],[193,"1/2"],[194,"-1/2"],[196,"-1/2"],[198,"1/2"],[202,"1/2"],[204,"-1/2"],[208,"1/2"],[210,"-1/2"],[211,"-1/2"],[212,"-1/2"],[214,"-1/2"],[217,"1/2"],[220,"1/2"],[222,"-1/2"],[228,"-1/4"],[230,"-1/4"],[236,"-1/4"],[243,"-1/2"],[251,"-1/4"],[268,"-1/2"],[288,"1"],[290,"-1/6"],[299,"1/3"],[300,"1/6"],[306,"-1/2"],[316,"-1/2"],[320,"1"],[332,"1"],[336,"-1/4"],[342,"3/2"],[351,"-1/4"],[372,"-1/4"],[399,"1"],[428,"3/2"],[437,"-1/2"],[438,"-1/2"],[472,"1"],[485,"1"],[504,"1/2"],[531,"-1/4"],[537,"1"],[538,"1"],[541,"-1/2"],[570,"1"],[573,"-1/4"],[575,"1"],[577,"-1/4"],[581,"-1/4"],[587,"1"],[589,"-1/4"],[600,"-1/4"],[609,"-1/2"],[611,"-1/4"],[627,"-1/4"],[640,"-1/2"],[711,"1"],[732,"-1/2"],[1007,"1/2"],[1048,"1/16"],[1060,"-1/8"],[1079,"-1/2"],[1114,"-1/2"],[1139,"1/16"],[1141,"-1"],[1143,"-1"],[1146,"1/2"],[1169,"3/2"],[1199,"-3/2"],[1206,"1/16"],[1216,"1/16"],[1222,"1/2"],[1228,"1/8"],[1255,"-1/4"],[1273,"1"],[1279,"1/8"],[1306,"-1/8"],[1331,"-1/2"],[1466,"1/2"]],"calibration":[[89763,"1"],[104083,"-1/2"],[104137,"-1/2"],[104419,"1/4"]],"pulse":[[89191,"4"],[89195,"-2"],[89198,"-2"],[89199,"-4"],[94245,"1"],[94251,"2"]]}, + {"event":"split","direction":"transpose","role":302,"source_chart":127,"split_chart":306,"return_chart":3,"source_covector":[[842,"2"],[849,"2"],[1059,"1"]],"source_direction":[[248,"1/2"],[302,"1/2"],[329,"-1/2"],[343,"-1/2"],[388,"-1/2"],[392,"1/2"],[409,"-2"],[411,"3"],[416,"-8"],[418,"1"],[709,"-1/2"],[993,"4"],[994,"1/2"],[1014,"2"],[1059,"-2"],[1064,"-5/2"],[1150,"8"],[1154,"-4"],[1281,"3"],[1295,"1/8"]],"readout":[[104438,"1"]],"return_direction":[[248,"1/2"],[302,"1/2"],[329,"-1/2"],[343,"-1/2"],[388,"-1/2"],[392,"1/2"],[409,"-2"],[411,"3"],[416,"-8"],[418,"1"],[709,"-1/2"],[993,"4"],[994,"1/2"],[1014,"2"],[1059,"-2"],[1064,"-5/2"],[1150,"8"],[1154,"-4"],[1281,"3"],[1295,"1/8"]],"return_covector":[[21,"1/2"],[112,"1/2"],[113,"1/2"],[114,"1/2"],[118,"1/2"],[119,"-1/2"],[120,"1/2"],[124,"1/2"],[128,"1/2"],[134,"1/2"],[135,"1/2"],[136,"1/2"],[137,"1/2"],[138,"1/2"],[139,"1/2"],[143,"1/2"],[147,"1/2"],[153,"1/2"],[154,"1/2"],[155,"1/2"],[156,"1/2"],[157,"1/2"],[166,"1/2"],[167,"1/2"],[168,"1/2"],[169,"1/2"],[176,"1/2"],[177,"1/2"],[178,"1/2"],[182,"1/2"],[183,"1/2"],[184,"1/2"],[185,"1/2"],[186,"1/2"],[187,"1/2"],[194,"1/2"],[195,"1/2"],[196,"1/2"],[201,"1/2"],[202,"1/2"],[203,"1/2"],[207,"1/2"],[208,"1/2"],[209,"1/2"],[212,"1/2"],[213,"1/2"],[214,"1/2"],[216,"1/2"],[217,"1/2"],[218,"1/2"],[219,"1/2"],[220,"1/2"],[221,"1/2"],[248,"1"],[257,"1/2"],[258,"1"],[260,"2"],[280,"-1"],[283,"-1/2"],[285,"1/2"],[286,"1/2"],[315,"1/4"],[429,"-1/4"],[441,"-1"],[449,"-1"],[469,"-1"],[479,"-1"],[491,"-1"],[517,"-1"],[716,"-1"],[789,"-5/2"],[1035,"1"],[1042,"1"],[1046,"-2"],[1171,"1"],[1172,"1"],[1328,"-1"],[1340,"-1/2"],[1449,"1"],[1469,"4"],[1471,"1/2"]],"calibration":[[96356,"1"],[103726,"-1/2"],[104267,"-1/4"],[104467,"1/2"]],"pulse":[[90122,"2"],[90126,"-2"],[90129,"1"],[94336,"-1"],[96307,"1"],[96330,"1"]]} +] diff --git a/research/interleaved-basis-residual-audit/retained/source/LICENSE b/research/interleaved-basis-residual-audit/retained/source/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/interleaved-basis-residual-audit/retained/source/NOTICE b/research/interleaved-basis-residual-audit/retained/source/NOTICE new file mode 100644 index 0000000000..051d4cba2d --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/NOTICE @@ -0,0 +1,3 @@ +Apache License 2.0. Ali Romman prepared the new P104 construction and verification with substantial OpenAI Codex assistance. + +Retain CREDITS.md, LICENSE, SOURCE-PINS.json, SOURCES.json and the notices in credits/ with this package. They identify the authors, source commits and licenses of the parent, causal split, physical and caller engines, signed-curvature interval gate and chart-operator checks. diff --git a/research/interleaved-basis-residual-audit/retained/source/PRICE.json b/research/interleaved-basis-residual-audit/retained/source/PRICE.json new file mode 100644 index 0000000000..fc35a134bb --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/PRICE.json @@ -0,0 +1,8 @@ +{ + "claim": "0.00378751509478", + "probe": "0.00378751509485", + "bracket": [ + "0.00378751509486", + "0.00378751509487" + ] +} diff --git a/research/interleaved-basis-residual-audit/retained/source/PROOF.md b/research/interleaved-basis-residual-audit/retained/source/PROOF.md new file mode 100644 index 0000000000..b8076440f4 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/PROOF.md @@ -0,0 +1,39 @@ +# Why the changed public interface works + +Use a rational scalar at each public entrance. Each paid instruction reads an exact linear combination of scalars at one chart and installs its result at a second chart. A terminal reads scalars at its own chart. The prescribed physical chart operators are unitary. The scalar network describes the circuit in these chart coordinates. The catalogue checks the phased operators that convert between them. + +The parent scalar operator is a direct sum of the 104 port maps and the identity on independent helper coordinates. Write this operator as $U$. Every edit protects all 400 main coordinates. Retired helpers have an isolated identity row while the journal is in use. The final graph deletes the input and output of each such row. + +## Remove a helper and its paid returns + +Choose an independent helper coordinate $r$. At its source chart take a linear form $s$ in local banks with a nonzero coefficient on its input. Its full expansion also has a nonzero coefficient on $x_r$. For each listed receiver, the journal supplies local banks whose linear combination has exactly the same full expansion as $s$. Impose $s=0$. At the source, solve for the old pivot input. At each receiver, solve for one arrival in that receiver's equation. Substitute these solutions in every reader of the respective pivot. Erase the paid instruction for each eliminated arrival. + +For arbitrary values of the surviving inputs there is a unique old $x_r$ that satisfies the constraint. The outputs for these inputs were independent of $x_r$, since the old helper was an identity summand. Thus the restricted old circuit has the required outputs. The schedule and the bank checks establish that each substitution uses available local values. The witness expands the source and every receiver relation on all old inputs. Some steps remove a target and a paid transfer of equal rank. These steps permit later changes of the graph. + +## Split one helper using a local observation and a controlled input + +Work in either orientation. Suppose helper $r$ goes from chart $A$ to chart $Z$. At chart $C$ the old network offers a readout with entrance covector $s$ and a calibration with value $y U x$. A pulse is a specified vector of additions to local send instructions and terminal reads at $C$. The witness checks its full terminal response $t$. A source direction $w$ has the same response, $U w=t$. Both $s$ and $w$ use only inputs at $A$. Both $y$ and $t$ use only outputs at $Z$. The pulse has zero response at the readout and calibration. The three scalars $s w$, $y t$ and $t_r$ are nonzero. + +Give the shortened helper an arbitrary input $h$ at $A$. Give a fresh helper an independent input $g$ at $C$. Let $x^0$ contain the other original inputs and have coordinate $r$ equal to zero. In the old source banks use + +$$ +v=x^0+w\frac{h-sx^0}{sw}. +$$ + +The readout at $C$ now returns $s v=h$. At $C$ apply the pulse with amplitude $(g-yUv)/(yt)$. Write $b=Uv+t(g-yUv)/(yt)$ for the resulting old output vector. Its decoded value $y b$ is $g$. Install this value as the fresh return at $Z$. For every $i$ other than $r$ at which $t_i$ is nonzero, install $b_i-(t_i/t_r)b_r$. All other surviving outputs keep their values. + +Indeed $b-Ux^0$ is a scalar multiple of $t$ and $(U x^0)_r=0$. These local corrections recover every component of $U x^0$ except the surrendered coordinate, which the readout now returns at $C$. The two new owners earn the exact ranks for $A$ to $C$ and $C$ to $Z$. This argument permits different source and return covectors and different nonzero normalization factors. The implementation checks the actual rational responses and the final acyclic schedule. [Split construction](split.py) · [Equation checks](witness.py) + +## Transpose, reroute and count + +Transposing the scalar graph reverses each paid edge, exchanges the public entrances and terminals, and transposes the full linear map. A helper identity summand remains an identity summand in this orientation. The journal can therefore apply a restriction or split to the transposed graph, then transpose back. A paid pivot or hub reroute uses the retained recoding identities. Both the final forward propagation and a separate reverse propagation check the entire resulting operator. + +The compact graph keeps the first-plane partner of each live port at offset 112. It gives each surviving helper exactly one public label. Each of the 16 calls receives fresh helper owners. The signed caller supplies the root targets and the external paid operations at their actual multiplicities. Price every job of rank $r$ at $r^{1-\kappa}$. The complete margin is the sum of the productive prices minus the sum of the paid prices. The replay checks the signs on both sides of its crossing with directed bounds. It also checks a strictly interior probe, the physical resource bounds and the outer compiler inequalities. [Complete application](application.py) · [Physical and price evidence](results/application.json) + +## Three restrictions that enable the last three splits + +For role 1400, the transposed relation removes arrival 98393 at chart 280. This changes the forward readout for helper 294 at chart 288. The source-steering product is 2, the return-decoding product is 1/2 and the pivot component is 3. Bank 89199 supplies the calibration. Under the alternate forward restriction, 16 readout coefficients differ. Input 10 alone changes the readout by one unit. + +For role 1401, the chosen restriction removes arrival 91108 and permits the second split at chart 288. The alternate relation gives 16 incorrect coefficients in the pulse response. For role 1409, the equation removes arrival 96030. Its source includes one half of the input at stable role 549. This coefficient is needed at that point in the journal. The alternate relation gives 27 incorrect response coefficients for the split at chart 306. The controls rebuild the full prefix in each case. [Rational journal](EDITS.json) · [Worked counterexamples](results/witness.json) + +The search used modular linear algebra to locate possible receiver relations, causal pulses and paid reroutes. It also tested smaller sets of earlier edits to identify conditions for a split. The final replay uses rational arithmetic for every chosen relation and integer arithmetic for all public columns. The certificate establishes this construction's price. Optimality across possible helper bases remains open. diff --git a/research/interleaved-basis-residual-audit/retained/source/README.md b/research/interleaved-basis-residual-audit/retained/source/README.md new file mode 100644 index 0000000000..d55beb8690 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/README.md @@ -0,0 +1,41 @@ +# Conditional κ ≥ 0.00378751509478 from interleaved P104 helper bases + +This construction raises the conditional lower bound to **0.00378751509478**. It exceeds the upper endpoint 0.00376313686062 of the stronger pending comparison by **0.00002437823416**, or **0.64782%**. This increment is **15.24% larger** than the preceding increment of 0.00002115478655. The directed interval for the new raw crossing is **[0.00378751509486, 0.00378751509487]**. The compiler uses a strictly smaller point. [Previous complete proposal](https://github.com/CrocSwap/integer-mult-bounds/pull/7717) · [Preceding increment](https://github.com/CrocSwap/integer-mult-bounds/pull/7713) · [New price and compiler receipt](results/application.json) + +| Complete count | PR 7717 | This construction | +| --- | ---: | ---: | +| Public fields per native call | 1,470 | 1,260 | +| Independent helpers per native call | 1,070 | 860 | +| Paid native instructions per call | 6,054 | 5,810 | +| Paid recursive jobs across 16 calls and the caller | 100,416 | 96,512 | +| Productive recursive jobs across 16 calls and the caller | 20,656 | 17,296 | +| Productive rank mass less paid rank mass | 1,328 | 1,328 | + +## Construction + +Start from the compact 1,468-field graph in PR 7713. The journal removes 220 helper targets and their 230 dependent paid returns, splits 12 helpers and applies 14 paid pivots and nine hub reroutes. It can make an edit in either orientation. The fixed 400 main fields retain the port contract throughout. Every surrendered helper is debited. Every fresh helper has its own arbitrary input and output. [Source graph](data/BASE-GRAPH.json.gz) · [Exact journal](EDITS.json) · [Construction proof](PROOF.md) + +Three choices matter near the end. The alternatives retire the same helpers and paid instructions. Changing their local equations makes two splits at chart 288 and one at chart 306 possible. A separate restriction enables the split at chart 2. All four coexist in one causal graph. In the forward chart-288 split, five local banks read the new input, one bank supplies the calibration and three local instructions carry the pulse. With the earlier role-1400 restriction, that same readout has an unwanted coefficient of one on input 10. The two transposed controls give incorrect pulse responses at the terminals. [Alternative equations](data/RESTRICTION-CONTROLS.json) · [Exact differences](results/witness.json) + +At unit rank price the old and new bills have the same surplus. At the exponent used by the compiler, the changed distribution of paid and productive ranks increases the margin. The exact comparison also gives weak dominance over PR 7717 for every increasing concave rank price that vanishes at zero. The directed power and compiler checks establish the stated strict improvement. [Complete signed comparison](results/application.json) + +## Replay + +Use CPython 3.12 and run the following command at the repository root. The five registered checks use the standard library. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-interleaved-helper-bases +``` + +The application rebuilds the compact graph, checks all 1,260 public rows and prices the full signed caller. It checks 10,483,566 scalar products and 5,586,926 nontrivial exact divisions. The reverse sweep checks all 1,260 input columns using a further 10,218,280 exact products. The witness verifies all 230 receiver equations, all 12 split equations and one altered pulse per split. It reconstructs the signed bill again from the journal. The three catalogue checks cover all 2,938 surviving phased chart pairs and all 1,664 port-stage contacts. [Replay manifest](VERIFY.json) · [Forward receipt](results/application.json) · [Reverse and witness receipt](results/witness.json) · [Chart receipts](results) + +To export the canonical graph, run `python3.12 -I -B research/p104-interleaved-helper-bases/construction.py > /tmp/p104-interleaved.json`. Its SHA-256 is `ba59d5db17c40185c8608a734ced10135d8c041e432c3840e9034868781c31a2`. The package contains the pending source inputs and authenticates their bytes. [Source pins](SOURCE-PINS.json) · [Base manifest](SOURCES.json) + +The 54 strict and four functional compiler predicates pass under the selected framework. The five inherited assumptions cover native all-column application, owned erasure, the recursive compiler, precision and tape accounting, and analytic recovery. Independent scientific review and practical multiplication timings remain open. The physical replay uses a sufficient scalar grid. The minimum grid for this graph remains open. [Assumptions](vendor/selected-claim.json) · [Prior finite-scale work](https://github.com/CrocSwap/integer-mult-bounds/pull/7718) + +## Open next questions + +- Can an independent implementation recover all three failed equations when it restores the alternate restrictions, then derive the corrected splits using its own bank bases? +- Which other equal-rank helper restrictions can preserve two independent readouts or pulse directions at different charts? Count both owner changes and the complete signed price on the same graph. + +Ali Romman prepared this contribution with substantial OpenAI Codex assistance. The source inventory and notices identify the prior constructions, authors and engines. [Credit](CREDITS.md) · [Canonical investigation](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19712230) diff --git a/research/interleaved-basis-residual-audit/retained/source/SOURCE-PINS.json b/research/interleaved-basis-residual-audit/retained/source/SOURCE-PINS.json new file mode 100644 index 0000000000..4fd73f1893 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/SOURCE-PINS.json @@ -0,0 +1,226 @@ +[ + { + "path": "LICENSE", + "source_path": "research/p104-helper-quotients/LICENSE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "credits/7658-NOTICE", + "source_path": "research/p104-helper-quotients/credits/7658-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "2baa2a719ea3a9ec94c2e7aec72702ec8c92b346", + "sha256": "2732575164931c53cc4bc57145c31d87741489e3048afee6899e856c0ea503b5" + }, + { + "path": "credits/7700-CITATION.cff", + "source_path": "research/p104-helper-quotients/credits/7700-CITATION.cff", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "d80f6b8660d6caaa82cb194fc22d0817d642d043", + "sha256": "50399ea15e9ce49baafbd00d6da16e662ac46c566e3c04af3993e23cf0b62ff4" + }, + { + "path": "credits/7700-NOTICE", + "source_path": "research/p104-helper-quotients/credits/7700-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "59d8e0cf3102e15bd11db430838365531e2d7f18", + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "path": "credits/OUTER-GATE-NOTICE", + "source_path": "research/p104-helper-quotients/credits/OUTER-GATE-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "1bc9b4da2b8398954cd7a49356eb9d397785d0a6", + "sha256": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8" + }, + { + "path": "credits/PR7663-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7663-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "6ce1bc49a3612c9e906df02de81bcba84be8e803", + "sha256": "5fd4367578d2339fbdcd7dc116b6c12cb4fa72e92d2e3d67be537a36c8bd9d40" + }, + { + "path": "credits/PR7669-PROVENANCE.md", + "source_path": "research/p104-helper-quotients/credits/PR7669-PROVENANCE.md", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "bbee2437f012c3268eb5cd920adfa37394c1de72", + "sha256": "706c6c852e87e371ddf1828244b2f0c2b00279728818023aa911c8947d69ab83" + }, + { + "path": "credits/PR7674-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7674-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "951f081717e0769f3bcc0f442f133965c064d2ce", + "sha256": "382537634a3d9fa0a8089d6121a506a399382f9310088b1f29586dcc93eec92d" + }, + { + "path": "credits/PR7682-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7682-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "4654631de087fe5034d30abc17e9d57582e5ed9c", + "sha256": "7590f71de481c424d2315e9ea4884bea1557481676fa5f930f7a0bed637a56a1" + }, + { + "path": "credits/PR7704-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7704-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "7d2dfec60a3a8c30bbc639104905d5ce1c0926e4", + "sha256": "49657dd50c9431642a9527b0d625197cb34d1838dcf00fe4d92040f9605c8ce0" + }, + { + "path": "credits/PR7705-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7705-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "2a92a9df69de4335966a1b12f79355244a7710f4", + "sha256": "43510816b93ea09e0d716ccc6261c84ce081821c0d5dea7d6e748863d55f8f40" + }, + { + "path": "credits/PR7708-NOTICE", + "source_path": "research/p104-helper-quotients/credits/PR7708-NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "4a24e9bcb74d349b7f245f2b43edb6faba716429", + "sha256": "c3762acca6fa198c621e0aacf8aa06526aa7716c20c761141c07393fdba6bc46" + }, + { + "path": "credits/PR7713-NOTICE", + "source_path": "research/p104-helper-quotients/NOTICE", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "8fa17b3fd69ddd3be7caeaaff72848e0ac8d517a", + "sha256": "8852b94801cd022eb5d42dc57b7592ab22f87b441566a1ce62c8697733c82da6" + }, + { + "path": "credits/PR7716-CREDITS.md", + "source_path": "research/quotient-causal-split-composition/CREDITS.md", + "commit": "1636b3c9b922d23b222b60dd52e005e60c592491", + "git_blob": "baa9d2f16c76c21437a61916a06f4be4d38ad54a", + "sha256": "dad56f9bca6dd9b902cf77dfbae0da49bbc091e63857313f5e6add52021085b2" + }, + { + "path": "credits/PR7717-CREDITS.md", + "source_path": "research/quotient-split-physical-application/CREDITS.md", + "commit": "586f4f81a8bd09a65a8e6d0bfff57a0fec8925e8", + "git_blob": "538263114c08217081d3f05bd2383c50a7ae74b8", + "sha256": "515a2d475a2580bbe1c213d10526ce5eef7eaa9a11924e5d72e30221676f7aa4" + }, + { + "path": "data/BASE-GRAPH.json.gz", + "source_path": "research/quotient-causal-split-composition/compact.json.gz", + "commit": "1636b3c9b922d23b222b60dd52e005e60c592491", + "git_blob": "9b797d51003786c8c7d205d0aa32d7897317cd27", + "sha256": "9f3923af2a1d4f97a28653c6b20cc3126d5404ff43ca07ea9bdc7fdda20dee1e" + }, + { + "path": "data/BASE-INTERFACE.json", + "source_path": "research/quotient-causal-split-composition/interface.json", + "commit": "1636b3c9b922d23b222b60dd52e005e60c592491", + "git_blob": "aae538bb9d6fb34e99eefc7ee374b25c7a39abeb", + "sha256": "8d2f95361baa7f20cb907f89a4fdbc87fc1266b8442175d0ee1e603f77b8a6d0" + }, + { + "path": "data/CALLER-PHASE-BASES.json", + "source_path": "research/p104-helper-quotients/data/CALLER-PHASE-BASES.json", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "3e4aa383a5e3343c4688bff62bd39587b90c31b4", + "sha256": "325a1eb4aa7fe5f918b1d8344b88ad132ef4606268bccec20f223ace5feda18b" + }, + { + "path": "data/CALLER.json.gz", + "source_path": "research/p104-helper-quotients/data/CALLER.json.gz", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "26a75a1ae32cb4944a65281cfb08775967cb39a0", + "sha256": "d889996a337f648087208ab51c98eaf052705d4fca88b5d01b6e9257a829897a" + }, + { + "path": "data/COMPARATOR-APPLICATION.json", + "source_path": "research/quotient-split-physical-application/results/application.json", + "commit": "586f4f81a8bd09a65a8e6d0bfff57a0fec8925e8", + "git_blob": "197c3a8a09ac99492bc88288aa662db4b95a49d6", + "sha256": "ed547c404492ee7672f17bbe793f049bc0484cf55170c776ee3a69ee4e3914c5" + }, + { + "path": "data/QUOTIENT-APPLICATION.json", + "source_path": "research/p104-helper-quotients/results/application.json", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "9a304f165eb74425db79115bd79e6f7dcedffeff", + "sha256": "f8d2499823054e44441c8f4dbbe1b8d430abe02eeeed09b0f55b08ab78b6f71d" + }, + { + "path": "vendor/binding16.py", + "source_path": "research/p104-helper-quotients/vendor/binding16.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "d07341b81719d96e336a47907d48c73772ec1ccb", + "sha256": "589058311e44f2d8909495c005bee6d54828ebe561d4673b599193d269006170" + }, + { + "path": "vendor/caller16.py", + "source_path": "research/p104-helper-quotients/vendor/caller16.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "2865530b7878dec54286a67e82b83093911ec43c", + "sha256": "ced48867f07ca0143604aa98cfd74fa7453696b9d3221f7c230d73e9ab9ba81f" + }, + { + "path": "vendor/construct.py", + "source_path": "research/p104-helper-quotients/vendor/construct.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "25115bba74690dd19dfbd987a1eb47d471f14f2d", + "sha256": "f45dab80a16b2293488dd6a37048b965a46c572619b191062bc1511c5c0ce4ff" + }, + { + "path": "vendor/interval_gate_signed.py", + "source_path": "research/p104-gate-ceiling-lift/interval_gate_signed.py", + "commit": "5c7b96af66acc625e0f8497d6faf060c84770cdf", + "git_blob": "2d8b9255d5422a51b8105695caff72f4a388a2a0", + "sha256": "e111ccdfcca3381a6a276e5ee012f156de613a7af98b14b037a21924250641cf" + }, + { + "path": "vendor/network.py", + "source_path": "research/p104-helper-quotients/vendor/network.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "0ebc1925c40cc6c11af59e405221ea51801a6e92", + "sha256": "a9169fd6ad0a13c69cf39bd32649d53256f6d6fa2ed2ceda854f848b64f4c546" + }, + { + "path": "vendor/physical.py", + "source_path": "research/p104-helper-quotients/vendor/physical.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "e7c4e5798bd37df287f431069ab0cffe73dbe3a3", + "sha256": "24c9cf906596c9ef1533c1d25f61403db3ff6389478f64359d9d12c5fef87b69" + }, + { + "path": "vendor/recoding.py", + "source_path": "research/p104-helper-quotients/vendor/recoding.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "c96d8b844d0e8028dc1616cf86a5130ed248de7e", + "sha256": "a56f02dd59430af46acbd4d5de240c377746fb74da46568195de68d5cb83b287" + }, + { + "path": "vendor/selected-bit-ambient.json", + "source_path": "research/p104-helper-quotients/vendor/selected-bit-ambient.json", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "cd19f356a5549f6b70557095e7745cdddde0485c", + "sha256": "437ad2f9e7956e7f2b477b546f53a6c8cfa0567e207024300e9a7e58d3c0202c" + }, + { + "path": "vendor/selected-claim.json", + "source_path": "research/p104-helper-quotients/vendor/selected-claim.json", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "c9b816f8445be9dc19b2259e03e9d8709d18c87a", + "sha256": "3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2" + }, + { + "path": "vendor/selected-validation.json", + "source_path": "research/p104-helper-quotients/vendor/selected-validation.json", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "7291ce5ab9c59f07ead921fbad9966b4a54e3292", + "sha256": "e1374a98b240d7f9f2cca2a1e74b93f240b1bfc94b8cc4b94a385a50281d494e" + }, + { + "path": "vendor/upstream_application.py", + "source_path": "research/p104-helper-quotients/vendor/upstream_application.py", + "commit": "06b75fde21f4231a2bd0725542c3ba60a908d83b", + "git_blob": "1a6d358cbec88e70615e5314cdfca9e123124f83", + "sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184" + } +] diff --git a/research/interleaved-basis-residual-audit/retained/source/SOURCES.json b/research/interleaved-basis-residual-audit/retained/source/SOURCES.json new file mode 100644 index 0000000000..f51fc62b8a --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/shared-wire-split-composition/frozen/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/shared-wire-split-composition/frozen/native_verify.py", + "usage": "input", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "scripts/compare_recursive_invoices.py", + "usage": "input", + "git_blob": "fda2a852e9937e42fe40df0707694465ca7c1b48", + "sha256": "3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6" + }, + { + "path": "scripts/evaluate_recursive_power.py", + "usage": "input", + "git_blob": "ca50f8021fc3238a58fd420383f4619a8d008ace", + "sha256": "52b20f41fd0bb55fa88dccd6015af2ce358917817b9506720f3e60ce681cc3ad" + } + ] +} diff --git a/research/interleaved-basis-residual-audit/retained/source/TASK.json b/research/interleaved-basis-residual-audit/retained/source/TASK.json new file mode 100644 index 0000000000..539432c59b --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/TASK.json @@ -0,0 +1,133 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Rebuild the PR 7713 graph. Interleave restrictions, paid reroutes and independent splits in both orientations. Test three alternative restrictions and the splits they permit at charts 288 and 306. Include the chart-2 split. Check the full physical application and reprice all 16 calls against PR 7717.", + "scope_change_reason": "The current Research Agenda calls for joint helper bases and a legal split. The source has the later relay, paid recodings and 33 prior restrictions. An equal-rank restriction can change which scalar the next split can read, even when it has zero immediate price effect.", + "bottleneck_link": "Every surrendered helper loses a productive return. Every new helper needs an arbitrary input, an available readout and a distinct owner through the signed caller. The complete price counts all these changes in all 16 calls.", + "budget_minutes": null, + "stop_rule": "The donor requested an extended search. The new conditional lower endpoint must exceed the stronger PR 7717 upper endpoint by more than the preceding increment, 0.00002115478655. Check the source, rational witnesses, full operator, physical schedule, signed bill and compiler.", + "outcome": "completed", + "evidence": "EDITS.json, PROOF.md, results/witness.json, results/application.json and results/catalogue-0.json through results/catalogue-2.json.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing.", + "open_questions": [ + { + "question": "Can an independent implementation derive the last three splits and reproduce the failed equations for all three alternate restrictions?", + "why_it_matters": "The new constraint removes the same paid arrival and gives the split a different local bank.", + "first_step": "Rebuild each prefix, expand the bank equations and pulse response at charts 288 and 306, and compare the full signed bill.", + "blocked_by": "This requires independent operator and invoice review." + }, + { + "question": "Can a second change of restriction preserve another independent split?", + "why_it_matters": "A profitable edit on a different graph can consume a paid return that this construction already removes.", + "first_step": "Choose one remaining equal-rank restriction, change the receiver equation, and test both edits together with distinct helper owners.", + "blocked_by": "An exact causal witness and a lower complete price are required." + } + ], + "coordination": { + "canonical": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19712230", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7713", + "comparator": "https://github.com/CrocSwap/integer-mult-bounds/pull/7717", + "comparator_head": "586f4f81a8bd09a65a8e6d0bfff57a0fec8925e8", + "upstream_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "priority_revision": 8, + "checkpoint_utc": "2026-11-18T18:19:43Z", + "overlap": "The handoff and mechanism Discussions and the PR and package overlap search were checked. PRs 7715 and 7719 audit earlier restrictions and paid recodings. PRs 7712, 7716 and 7717 supply prior causal splits and the comparison. PR 7718 changes the finite scalar scale. PR 7720 concerns the BIT word, and PR 7721 concerns a reversible half-sum. PR 7722 is a fixed BIT boundary obstruction. The refreshed index covered 1,023 open PRs and 7,671 Discussion records. The sparse local README inventory was partial." + } +} diff --git a/research/interleaved-basis-residual-audit/retained/source/VERIFY.json b/research/interleaved-basis-residual-audit/retained/source/VERIFY.json new file mode 100644 index 0000000000..8d8fe08785 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/VERIFY.json @@ -0,0 +1,67 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/shared-wire-split-composition/frozen/clifford_exact.py", + "research/shared-wire-split-composition/frozen/native_verify.py", + "scripts/compare_recursive_invoices.py", + "scripts/evaluate_recursive_power.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/application.py" + ], + "timeout_seconds": 165, + "checks": "Authenticate all source bytes. Build the compact graph. Verify every public row, occupied banks, exact products, scalar work, both complete invoices, the two crossing signs and the 58 outer tests." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/witness.py" + ], + "timeout_seconds": 190, + "checks": "Expand every restriction and helper split on independent inputs. Verify all public columns in reverse and reject altered receiver and pulse coefficients." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/catalogue.py", + "0" + ], + "timeout_seconds": 190, + "checks": "Check the complete phased operators and ranks on this subset of surviving chart pairs, all assigned main adapters and signed stage contacts. Check one pair on all 512 columns in both directions and reject phase faults." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/catalogue.py", + "1" + ], + "timeout_seconds": 190, + "checks": "Check the complete phased operators and ranks on this subset of surviving chart pairs, all assigned main adapters and signed stage contacts. Check one pair on all 512 columns in both directions and reject phase faults." + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/catalogue.py", + "2" + ], + "timeout_seconds": 190, + "checks": "Check the complete phased operators and ranks on this subset of surviving chart pairs, all assigned main adapters and signed stage contacts. Check one pair on all 512 columns in both directions and reject phase faults." + } + ] +} diff --git a/research/interleaved-basis-residual-audit/retained/source/application.py b/research/interleaved-basis-residual-audit/retained/source/application.py new file mode 100644 index 0000000000..282e388c36 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/application.py @@ -0,0 +1,139 @@ +"""Check the physical bill and complete conditional compiler application. + +The calculation uses the retained engines from PR7704 and PR7713. +See CREDITS.md for source authors and the exact source files. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as F +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from common import HERE, digest, inputs, jobs, need, owner_stages, physical, provenance, read, receipt +from caller16 import signed_caller +from interval_gate_signed import gate + +sys.path.insert(0, str(HERE.parents[1] / "scripts")) +from compare_recursive_invoices import compare_invoices +from evaluate_recursive_power import evaluate + +price = read("PRICE.json") +CLAIM, PROBE = price["claim"], price["probe"] +LOWER, UPPER = price["bracket"] +PREVIOUS_UPPER = "0.00376313686062" +PREVIOUS_GAIN = "0.00002115478655" +BIT = "0.00385248" + + +def selected_interfaces(): + claim = read("vendor/selected-claim.json") + bit, = [r for r in claim["uniform_templates"] if r["family"] == "BIT before cover"] + validation, repair = read("vendor/selected-validation.json"), read("vendor/selected-bit-ambient.json") + need(bit["ambient"] == 134 and bit["rank_encoding"] == "2^296630000000000" + and F(bit["saving"]) > F(BIT), "selected BIT bound") + need(validation["status"] == "admitted_conditional" and validation["registered_replays_complete"] + and repair["exit_code"] == 0 and repair["source_unchanged"], "selected conditional record") + assumptions = [r["id"] for r in claim["assumptions"]] + need(assumptions == ["native_all_columns", "owned_erasure", "compiler", "precision_tape", + "analytic_recovery"], "five inherited interfaces") + return assumptions + + +def invoice(native, helpers, signed, contract): + def total(local, fixed): + count = Counter({r: signed["calls"] * n for r, n in local.items()}) + count.update(fixed) + return {str(r): n for r, n in sorted(count.items())} + return dict(schema="integer-mult-recursive-invoice/v1", contract=contract, + paid=total(native, signed["fixed_caller_paid"]), + targets=total(helpers, signed["fixed_root_targets"])) + + +def prices(old, new): + order = compare_invoices(old, new) + empty = dict(new, paid={}, targets={}) + points = [] + for hist, at, sign in ((old, PREVIOUS_UPPER, "higher"), (new, PREVIOUS_UPPER, "lower"), + (new, CLAIM, "lower"), (new, PROBE, "lower"), + (new, LOWER, "lower"), (new, UPPER, "higher")): + result = evaluate(empty, hist, 1 - F(at), 256) + need(result["classification"] == "new_cost_" + sign, "directed power at " + at) + points.append(dict(graph="parent" if hist is old else "candidate", kappa=at, + paid_minus_productive=result["new_minus_old"])) + weights = {name: {int(r): n for r, n in new[key].items()} + for name, key in (("P", "paid"), ("T", "targets"))} + compiler = gate(weights, CLAIM, PROBE, LOWER, UPPER, BIT) + need(F(CLAIM) - F(PREVIOUS_UPPER) > F(PREVIOUS_GAIN), "separated complete lower point") + return order, points, compiler + + +def verify(): + source_files = provenance() + assumptions = selected_interfaces() + graph, layout, moves, rows, interface = inputs() + caller = read("data/CALLER.json.gz") + signed = signed_caller(caller, layout, 2025, 9) + stages = owner_stages(layout, interface[0], caller) + alias = deepcopy(caller) + joint = next(e for e in alias["events"] if e[0] == "J") + joint[2][1] = joint[2][0] + try: + owner_stages(layout, interface[0], alias) + except ValueError as error: + need(str(error) == "signed main owners", "owner alias rejection reason") + else: + raise ValueError("aliased caller owners accepted") + native_jobs, helpers, _ = jobs(graph, interface[0], moves) + parent = read("data/COMPARATOR-APPLICATION.json") + need(parent["bracket"][1] == PREVIOUS_UPPER, "parent crossing pin") + new = invoice(native_jobs, helpers, signed, parent["invoice"]["contract"]) + order, powers, compiler = prices(parent["invoice"], new) + native = physical.graph_bounds(graph, moves, rows, interface[0]) + grid = native["path_grid"] + expected = physical.expected_rows(layout["public"], layout, interface, grid) + native.update(physical.exact_basis_grid(graph, moves, rows, grid, expected)) + native.update(physical.held_schedule(graph, moves, rows, grid, expected, control=True)) + need(native["live_sender_alias_control_rejected"] + and set(native["missing_odd_factor_controls"]) == {3, 5}, "inherited grid and sender controls") + missing_primes = [] + for prime in (7, 17): + reduced = grid + while reduced % prime == 0: + reduced //= prime + if reduced == grid: + continue + try: + physical.exact_basis_grid(graph, moves, rows, reduced, + physical.expected_rows(layout["public"], layout, interface, reduced)) + except ValueError as error: + need(str(error) == "nonintegral scalar pre-product", "missing prime rejection") + else: + raise ValueError("inexact product accepted") + missing_primes.append(prime) + envelope = physical.caller_envelope(caller) + need(envelope["uses"] == signed["uses"], "independent caller count") + root = physical.root_envelope({"candidate": native}, envelope) + guard = physical.check_depth_guard(root, int(compiler["H"])) + scalars = physical.scalar_cases([rows], caller, (signed["odd_scale"], native["path_grid_odd"])) + shifts = sum(len(t["ports"]) * sum(row[0] < 0 for row in t["diagonal"]) for t in caller["types"].values()) + need(shifts == 3536, "all negative-q translations") + ordinary = physical.ordinary_budget(native, signed, shifts, scalars["coefficient_bits"]) + paid, productive = sum(new["paid"].values()), sum(new["targets"].values()) + need((paid, productive) == (ordinary["raw_paid_positions"], ordinary["raw_productive_targets"]), "complete physical and recursive denominators") + need(productive == signed["root_owners"] + sum(stage[2] for stage in stages), "complete productive owners") + return dict(claim=CLAIM, probe=PROBE, bracket=[LOWER, UPPER], previous_upper=PREVIOUS_UPPER, + authenticated_package_sources=source_files, + gain_over_previous_upper=str(F(CLAIM) - F(PREVIOUS_UPPER)), graph_sha256=digest(graph), + stages=stages, owner_alias_rejected=True, caller=signed, paid=paid, productive=productive, invoice=new, + comparison=order, powers=powers, compiler=compiler, conditional_interfaces=assumptions, + physical=dict(native=native, caller_envelope=envelope, common_root=root, depth_guard=guard, + ordinary=ordinary, scalars=scalars, extra_prime_rejections=missing_primes, + partial_clear_control=physical.partial_clear_control())) + + +if __name__ == "__main__": + need(sys.flags.optimize == 0, "outer gate assertions enabled") + result = verify() + receipt("application", result) + print("PASS_INTERLEAVED_APPLICATION", CLAIM, result["paid"], result["productive"]) diff --git a/research/interleaved-basis-residual-audit/retained/source/catalogue.py b/research/interleaved-basis-residual-audit/retained/source/catalogue.py new file mode 100644 index 0000000000..980987646e --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/catalogue.py @@ -0,0 +1,90 @@ +"""Check signed pairs and main contacts. Adapted from PR7713 catalogue.py. + +See CREDITS.md for the source authors and retained engines. +""" +from copy import deepcopy +from functools import cache +from pathlib import Path +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from common import HERE, digest, inputs, jobs, need, read, receipt +from binding16 import contact_phase +from upstream_application import boundary + +sys.path.insert(0, str(HERE.parents[1] / "research/shared-wire-split-composition/frozen")) +import clifford_exact as producer +import native_verify as checker + + +def verify(shard): + candidate, layout, moves, _, interface = inputs() + _, _, pairs = jobs(candidate, interface[0], moves) + basis, keep = layout["frames"], layout["source_labels"] + dense_pairs = [] + + @cache + def chart(i): + return producer.canonical_frame(9, tuple(basis[i])) + @cache + def frame(i): + return checker.frame(basis[i], 9) + + records = [] + for a, b in sorted(pairs)[shard::3]: + recipe, _ = producer.lower_child(chart(a).adjoint().then(chart(b))) + need(recipe["rank"] == abs(len(basis[a]) - len(basis[b])) > 0, "physical rank") + target = checker.adjoint(frame(a)) + frame(b) + actual = checker.recipe(recipe) + checker.equal(actual, target, "signed Pauli action and absolute phase") + if not records or (a, b) in {(3, 288), (767, 127)}: + dense_pairs.append([a, b]) + for op, ref in ((actual, target), (checker.adjoint(actual), checker.adjoint(target))): + for column in range(512): + need(checker.state(op, column) == checker.state(ref, column), "literal Gaussian column") + bad = deepcopy(recipe) + bad["left"]["phase"] = (bad["left"]["phase"] + 1) % 4 + try: + checker.equal(checker.recipe(bad), target, "phase fault") + except ValueError: + pass + else: + raise ValueError("altered global phase accepted") + records.append([a, b, recipe]) + contacts, ports = [], 0 + by_q = read("data/CALLER-PHASE-BASES.json")["by_q"] + rejected = False + for x, q in list(zip(layout["live"], layout["ports"], strict=True))[shard::3]: + a, b = candidate["initial"][x], candidate["final"][x + 112] + need(keep[x + 112] == keep[x] + 112 and not basis[candidate["initial"][x + 112]], "first-plane partners") + first, _ = producer.lower_child(producer.cgate(9, q, 1).adjoint().then(chart(a))) + last, _ = producer.lower_child(chart(b).adjoint().then(producer.cgate(9, q, -1).then(producer.fourier(9)))) + need(first["rank"] == last["rank"] == 0, "ordinary main adapters") + checker.equal(checker.recipe(first), (("C", q, -1),) + frame(a), "main entrance phase") + checker.equal(checker.recipe(last), checker.adjoint(frame(b)) + (("C", q, -1),) + checker.fourier(9), + "main exit phase") + checker.equal(frame(candidate["final"][x]), checker.fourier(9), "main Fourier exit") + ports += 1 + for stage in range(1, 17): + shifts, fault = contact_phase(q, by_q[str(q)], stage, 137) + contacts.append([q, stage, shifts]) + if fault and not rejected: + transform, (before, after) = fault + try: + boundary(before, after, transform, omit_translation=True) + except ValueError as exc: + need(str(exc) == "forward contact includes its phase", "wrong contact rejection") + rejected = True + need(rejected, "missing contact phase control") + return dict(shard=shard, total_pairs=len(pairs), checked_pairs=len(records), dense_pairs=dense_pairs, + forward_and_adjoint_columns=1024 * len(dense_pairs), ports=ports, contacts=len(contacts), + recipes_sha256=digest(records), contacts_sha256=digest(contacts)) + + +if __name__ == "__main__": + need(sys.flags.optimize == 0, "source compiler assertions enabled") + shard = int(sys.argv[1]) + need(0 <= shard < 3, "invalid shard") + result = verify(shard) + receipt(f"catalogue-{shard}", result) + print("PASS_INTERLEAVED_CHARTS", shard, result["checked_pairs"], result["contacts"]) diff --git a/research/interleaved-basis-residual-audit/retained/source/common.py b/research/interleaved-basis-residual-audit/retained/source/common.py new file mode 100644 index 0000000000..60de844858 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/common.py @@ -0,0 +1,101 @@ +"""Bind the compact graph to its main and helper owners. Adapted from PR 7717.""" +from collections import Counter +from hashlib import sha1, sha256 +from pathlib import Path +import gzip +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / "vendor")) +import physical + +from construction import build, digest, need, receipt + + +def read(name): + raw = (HERE / name).read_bytes() + return json.loads(gzip.decompress(raw) if str(name).endswith(".gz") else raw) + + +def inputs(): + graph, layout, net = build() + n, first = len(graph["initial"]), graph["first_output"] + need(n == layout["public"] == len(graph["final"]) and first == 154768, "complete public namespace") + need(layout["frames"] == graph["frames"] and len(layout["live"]) == len(layout["ports"]) == 104, + "port inventory") + h = layout["hosted"] + hosted, planes = set(h["Dports"]), list(zip(h["X2"], h["Y2"], strict=True)) + need(len(hosted) == len(planes) == 96, "hosted ports") + mains = set(layout["live"]) | {x + 112 for x in layout["live"]} | set(h["X2"]) | set(h["Y2"]) + need(len(mains) == 400 and mains <= set(range(n)), "main labels") + frames, initial, final = graph["frames"], graph["initial"], graph["final"] + for x, q in zip(layout["live"], layout["ports"], strict=True): + y = x + 112 + need(frames[initial[x]] == [q] and frames[initial[y]] == [] + and frames[final[x]] == [1 << j for j in range(9)] and len(frames[final[y]]) == 8 + and all((v & q).bit_count() % 2 == 0 for v in frames[final[y]]), "main frames") + for i, pair in zip(h["Dports"], planes, strict=True): + need(all(graph[boundary][a] == graph[boundary][b] for boundary in ("initial", "final") + for a, b in zip((layout["live"][i], layout["live"][i] + 112), pair, strict=True)), + "hosted frames") + labels = layout["source_labels"] + need(len(labels) == len(set(labels)) == n, "distinct source owners") + moves = net.moves + rows = {k: sorted(row.items()) for k, row in net.forms.items()} + need(all(0 <= k < first for k in moves), "paid namespace") + terminals = set(range(first, first + n)) + need(rows.keys() == moves.keys() | terminals and + len(graph["schedule"]) == len(rows) and set(graph["schedule"]) == set(rows), "complete physical rows") + return graph, layout, moves, rows, (mains, hosted, planes) + + +def jobs(graph, mains, moves): + frames = graph["frames"] + helpers = [(a, b) for r, (a, b) in enumerate(zip(graph["initial"], graph["final"], strict=True)) + if r not in mains] + pairs = set(moves.values()) | set(helpers) + spans = {i: physical.chart_span(frames[i]) for i in {j for pair in pairs for j in pair}} + need(all(spans[a] < spans[b] for a, b in helpers), "positive helper orientation") + need(all(spans[a] < spans[b] or spans[b] < spans[a] for a, b in pairs), "nested paid routes") + def rank(pair): + a, b = pair + return abs(len(frames[a]) - len(frames[b])) + return Counter(map(rank, moves.values())), Counter(map(rank, helpers)), pairs + + +def owner_stages(layout, mains, caller): + h = layout["hosted"] + second = dict(zip(h["Dports"], zip(h["X2"], h["Y2"], strict=True), strict=True)) + seen, stages = set(), [] + for event in caller["events"]: + if event[0] != "J": + continue + _, stage, group_a, group_b = event + bound = {} + for i, x in enumerate(layout["live"]): + for slot, role in zip((x, x + 112) + second.get(i, ()), + group_a if i in second else group_b[:2], strict=True): + need(slot not in bound, "main owner alias") + bound[slot] = (i, role) + need(bound.keys() == mains and len(set(bound.values())) == 400, "signed main owners") + fresh = {(stage, layout["source_labels"][r]) for r in range(layout["public"]) if r not in mains} + need(len(fresh) == layout["public"] - len(mains) and fresh.isdisjoint(seen), "distinct stage helper owners") + seen.update(fresh) + stages.append([stage, len(bound), len(fresh)]) + need([s[0] for s in stages] == list(range(1, 17)), "complete stages") + return stages + + +def provenance(): + pins = read("SOURCE-PINS.json") + for pin in pins: + raw = (HERE / pin["path"]).read_bytes() + git_bytes = b"blob " + str(len(raw)).encode() + b"\0" + raw + need(sha256(raw).hexdigest() == pin["sha256"] and sha1(git_bytes).hexdigest() == pin["git_blob"], + "source bytes: " + pin["path"]) + for pin in read("SOURCES.json")["files"]: + if pin["usage"] == "input": + need(sha256((HERE.parents[1] / pin["path"]).read_bytes()).hexdigest() == pin["sha256"], + "external input: " + pin["path"]) + return len(pins) diff --git a/research/interleaved-basis-residual-audit/retained/source/construction.py b/research/interleaved-basis-residual-audit/retained/source/construction.py new file mode 100644 index 0000000000..694b11b198 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/construction.py @@ -0,0 +1,152 @@ +"""Construct the compact P104 network from its published parent and an edit journal.""" +from fractions import Fraction +from functools import cache +from hashlib import sha256 +from pathlib import Path +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path[:0] = [str(HERE), str(HERE / "vendor")] +from network import Network, add_scaled, coefficients, encoded, main_roles, need, pivot, read +from recoding import check_bank, hub, layout as serialize +from split import apply_split + +BASE_HASH = "16e99893a2c669467ce74f214e8eb5150402f0267aaa8d67aad5d870aa4d5c18" + + +def digest(value): + return sha256(encoded(value)).hexdigest() + + +def receipt(name, value): + need(json.loads(json.dumps(value)) == read(HERE / "results" / (name + ".json")), + "receipt mismatch for " + name) + + +def source(): + graph = read(HERE / "data/BASE-GRAPH.json.gz") + interface = read(HERE / "data/BASE-INTERFACE.json") + keep, first = interface["keep"], graph["first_output"] + need(digest(graph) == BASE_HASH and len(keep) == len(set(keep)) == 1468, "PR 7713 graph") + need(keep == sorted(keep) and keep[0] >= 0 and keep[-1] < 1501, "stable parent labels") + # The published source uses compact labels. Restore the old labels for the edit journal. + initial, final = [3] * 1501, [3] * 1501 + for i, old in enumerate(keep): + initial[old], final[old] = graph["initial"][i], graph["final"][i] + forms = {first + r: {~r: Fraction(1)} for r in set(range(1501)) - set(keep)} + for key, row in graph["forms"]: + node = key if key < first else first + keep[key - first] + forms[node] = {j if j >= 0 else ~keep[~j]: value for j, value in coefficients(row).items()} + moves = {k: (a, b) for k, a, b in graph["moves"]} + live = [keep[i] for i in interface["live"]] + hosted = dict(interface["hosted"]) + for axis in ("X2", "Y2"): + hosted[axis] = [keep[i] for i in hosted[axis]] + frames = graph["frames"] + ports = [frames[initial[i]][0] for i in live] + old_layout = dict(frames=frames, ports=ports, live=live, hosted=hosted) + net = Network(first, initial, final, moves, forms) + need(main_roles(old_layout) == {keep[i] for i in interface["main_roles"]}, "all original main labels") + return net, old_layout + + +def restrict(net, edit): + """Solve the entrance and receiver equations, then remove their pivots.""" + role = edit["role"] + forms, moves = net.forms, dict(net.moves) + need(net.initial[role] != net.final[role], "active helper") + equations = [(~role, net.initial[role], coefficients(edit["source"]))] + for bank in edit["banks"]: + key, chart = bank["remove"], bank["chart"] + need(moves[key][1] == chart, "receiver chart") + equations.append((key, chart, coefficients(bank["relation"]))) + for key, chart, row in equations: + check_bank(net, row, chart) + scale = -1 / row[key] + replacement = {k: scale * v for k, v in row.items() if k != key} + updated = {} + for node, form in forms.items(): + if node == key: + continue + if key in form: + form = dict(form) + add_scaled(form, replacement, form.pop(key)) + updated[node] = form + forms = updated + if key >= 0: + del moves[key] + final = list(net.final) + final[role] = net.initial[role] + forms[net.first_output + role] = {~role: Fraction(1)} + return Network(net.first_output, net.initial, final, moves, forms) + + +def compact(net, template): + first = net.first_output + mains = main_roles(template) + live = {r for r, (a, b) in enumerate(zip(net.initial, net.final, strict=True)) if a != b or r in mains} + # Keep each first-plane pair exactly 112 labels apart in the public interface. + spare = sorted(r for r in live - mains if r >= 224) + prefix = [r if r in live else spare.pop() for r in range(224)] + keep = prefix + sorted(live - set(prefix)) + index = {old: new for new, old in enumerate(keep)} + need(len(keep) == len(index) and set(index) == live, "one label per physical owner") + forms = {} + for key, row in net.forms.items(): + if key >= first and key - first not in live: + need(row == {~(key - first): 1}, "isolated retired terminal") + continue + need(all(j >= 0 or ~j in index for j in row), "retired input has a reader") + node = key if key < first else first + index[key - first] + forms[node] = {j if j >= 0 else ~index[~j]: v for j, v in row.items()} + new = Network(first, [net.initial[i] for i in keep], [net.final[i] for i in keep], net.moves, forms) + hosted = dict(template["hosted"]) + for axis in ("X2", "Y2"): + hosted[axis] = [index[r] for r in hosted[axis]] + layout = dict(template, hosted=hosted, public=len(keep), live=[index[r] for r in template["live"]], + source_labels=keep) + need(all(index[x + 112] == index[x] + 112 for x in template["live"]), "preserved main partners") + return new, layout + + +def apply_edits(events, observer=None): + net, template = source() + mains = main_roles(template) + orientation = "forward" + for edit in events: + side, kind = edit["direction"], edit["event"] + need(side in ("forward", "transpose"), "edit orientation") + if side != orientation: + net = net.transpose() + orientation = side + if observer is not None: + observer(net, edit) + if kind in ("restrict", "split"): + need(0 <= edit["role"] < len(net.initial) and edit["role"] not in mains, "helper owner") + if kind == "restrict": + net = restrict(net, edit) + elif kind == "split": + check_bank(net, coefficients(edit["readout"]), edit["split_chart"]) + check_bank(net, coefficients(edit["calibration"]), edit["split_chart"]) + net = apply_split(net, edit) + elif kind == "pivot": + check_bank(net, coefficients(edit["sender"]), edit["source_chart"]) + check_bank(net, coefficients(edit["receiver"]), net.moves[edit["pivot"]][1]) + net = pivot(net, edit) + else: + need(kind == "hub", "known graph edit") + net = hub(net, edit) + if orientation == "transpose": + net = net.transpose() + return net, template + + +@cache +def build(observer=None): + net, layout = compact(*apply_edits(read(HERE / "EDITS.json"), observer)) + return serialize(layout, net), layout, net + + +if __name__ == "__main__": + sys.stdout.buffer.write(encoded(build()[0])) diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/7658-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/7658-NOTICE new file mode 100644 index 0000000000..2baa2a719e --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/7658-NOTICE @@ -0,0 +1,21 @@ +Apache-2.0. DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. + +The base word (data/base-7641-word.json.gz, unmodified bytes, sha256 de43ed04f58133eaef8f8d12a9dae1e6e8aa7f9721044200cc839673d86fd7c1) +is the word of our #7641 (20 swap-then-delete composites on SYLforge's #7637), vendored as data only. #7641's own base is SYLforge's +#7637 candidate word, whose notices read: + + "Apache-2.0. Local H5B + E1/E4 combination experiment, prepared with OpenAI assistance. + All earlier contributors and notices in hydrogen-bounded-verification-20261117/NOTICE remain credited. In particular: Ali Romman + (#7605), SYLforge, Clear1nsight, DreamingOfClouds, and all upstream contributors listed there." + +#7637's recorded technique credits: DreamingOfClouds #7630 (E1 rebirth/canceller, E4 existing-co-presence reroute), Clear1nsight +#7631/#7633 (efficient E4 integration, E1 prefix/tail settlement), and SYLforge's H5B literal-frame-restored archive. Its lineage +also carries Clear1nsight's #7626/#7314/#7274, Rohan Arun's #7277 and signed #7113 caller, and the contributors named in the +retained sources. #7641, #7637 and their code are not run by this package; only their words are read as data. + +This package adds five edits found by a large-neighbourhood search (one SWAP-NULL relabel of two helpers with a stay deletion, one main +stop removal, three helper stay deletions with re-placed contacts) and one hub re-settle. The helper-stay deletion with re-charted +contacts (E3) is of the type introduced by Clear1nsight's #7612 and ToikY's #7643. check.py is our own code: its replay, crossing and +column-test sections come from our #7630-on-#7623, swap-composite and #7641 packages; its column tests follow the description of the +affected-pair tests in #7620's README and native runner. The CLEAR certificate check implements the acceptance rule of #7620's +verify_certificates (read, not run). No other author's code was run; their words are read as data. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/7700-CITATION.cff b/research/interleaved-basis-residual-audit/retained/source/credits/7700-CITATION.cff new file mode 100644 index 0000000000..d80f6b8660 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/7700-CITATION.cff @@ -0,0 +1,55 @@ +cff-version: 1.2.0 +message: >- + Please cite the selected composition and its constituent contributions, + this project and the upstream manuscript. The selected checkpoint is PR4470 on the cumulative productive-helper framework; consult certificates/selected-result.json for publication status. + Project-level authorship identifies the maintainer, not sole authorship of + the community result. See CONTRIBUTORS.md and the frozen source notices. +title: "A sharper exponent for integer multiplication" +authors: + - family-names: Colkitt + given-names: Douglas +license: Apache-2.0 +type: software +version: "community-joint4470-2026-10-22" +date-released: 2026-10-22 +repository-code: "https://github.com/CrocSwap/integer-mult-bounds" +url: "https://github.com/CrocSwap/integer-mult-bounds" +abstract: >- + Community research on integer multiplication. The selected maintainer-reviewed + conditional construction has kappa = 60403/20000000 = 0.00302015. + Cinna Davis's PR4470 joint helper frames and query-thinned controller build on + her preceding constructions, zxv's native/productive-helper and compiler work, + Jacob Alan Sussman's mixed-target recursion, and the cumulative community + framework. Exact finite replays and independent audits retain explicit + all-column/native, owned-erasure, compiler, precision/tape, analytic, prime + and recovery assumptions. This is not a complete formal multiplication proof. +preferred-citation: + type: software + title: "A sharper exponent for integer multiplication: community research repository" + authors: + - family-names: Colkitt + given-names: Douglas + year: 2026 + url: "https://github.com/CrocSwap/integer-mult-bounds" + notes: >- + Maintainer citation only, not sole authorship of the mathematical result. + Credit Cinna Davis (PR4470/4447/4441/4440/4416), zxv (PR4359/4433), + Jacob Alan Sussman (PR4268), independent auditors Mihir Srivastava and + Ryanson Jonathan, Mark/Matarener for the commutation question, and the full + geometry, binary, native, precision and outer lineage, including Rohan Arun, + Jeremy Kothe, Chafik Boukhalfa and the contributors listed in CONTRIBUTORS.md + and docs/research/community-joint4470-contributors.md. Cite constituent PRs + where their results are used; preserve their licenses and assistance disclosures. +keywords: + - integer multiplication + - computational complexity + - exact arithmetic + - parameter optimization + - reproducible research +references: + - type: unpublished + title: "Integer multiplication below n log n" + authors: + - name: OpenAI + year: 2026 + url: "https://github.com/openai/math/tree/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026" diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/7700-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/7700-NOTICE new file mode 100644 index 0000000000..59d8e0cf31 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/7700-NOTICE @@ -0,0 +1,415 @@ +A sharper exponent for integer multiplication +Copyright 2026 Douglas Colkitt + +This project includes unmodified source files from OpenAI's manuscript +"Integer multiplication below n log n" and its accompanying repository: +https://github.com/openai/math +Commit: adc7f1241b42e322a6451854ab7e4b4c146bf78a + +The original manuscript identifies OpenAI as its author. Its Apache-2.0 +license is retained at upstream/LICENSE. The exact source URLs and hashes +are recorded in upstream/manifest.json. Proposed modifications are supplied +as separate files under patches/; upstream source files remain unchanged. + +The original local research note, scripts, certificates, patches, and +documentation were prepared by Douglas Colkitt with assistance from OpenAI +Codex. The community release incorporates work by the contributors identified +in the notices below; it is not solely Douglas Colkitt's work. +This project is not an official OpenAI release or an OpenAI endorsement. + +Related contributions (not imported in this checkpoint): +Zhihao Chen (jacklightChen), PR #7, supplied an earlier ternary five-subset +motif, finite-alphabet transfer and a different compressed producer: +https://github.com/CrocSwap/integer-mult-bounds/pull/7 +The present checkpoint claims no priority for that motif. Related compressed +complex-network work was submitted by eumemic in PR #3: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +The pending contributions and their stronger bounds require their own review; +this notice does not represent adoption or verification of their claims. + +Additional community work, including parallel and superseded submissions, is +acknowledged in CONTRIBUTORS.md, with pinned submission metadata in +docs/research/contribution-snapshot.json. These acknowledgements do not imply +joint authorship of the checkpoint, incorporation of pending code, or verification +of submitted mathematical claims. Original source-specific notices remain in force. + +Community release (accepted by conditional maintainer audit): +The following original contributor notices apply to the imported PR #39 chain. +The preceding non-import statements describe the preserved 2^-30 checkpoint. + +Ternary five-subset construction and common-four-point resynthesis +Copyright 2026 Zhihao Chen (jacklightChen) + +This is Zhihao Chen's first submission of this specific construction to this +repository. Research, proof development, code and verification were prepared +with substantial assistance from GPT-6 Astra (OpenAI Codex), as identified by +the contributor. This is not independent review or an OpenAI endorsement. +Future research building on this contribution should explicitly acknowledge +Zhihao Chen (jacklightChen), cite the accompanying note and pull request, and +retain the preceding contributors' attribution. This notice records research +provenance; the repository's Apache-2.0 license remains unchanged. + +Dependencies retained from eumemic's Claude-assisted PRs #3 and #5: +https://github.com/CrocSwap/integer-mult-bounds/pull/3 +https://github.com/CrocSwap/integer-mult-bounds/pull/5 +PR #5 commit: d3d370c34937503bd3fa63c83d505a05e8e50893 +These include complex_circuit.py, complex_network.py, fast_gaussian.py, +their generators, construction notes and certificates. The Gaussian input +scaling proof is corrected in this derivative; see the modification notice below. +Aligned pairing also appears in Bortlesboat's PR #2. Retained totals and bank +sharing appear in dleen's PR #4 and cheaper retained centers in eumemic's PR #6. +Their results and ideas are credited separately from this new construction. + +Bulk recursion and controlled tensor basis, 8 October 2026 +Copyright 2026 icekylinx + +The new projector batching, controlled simultaneous basis, mixed-width tape +recursions, whole-residual complex recursion, and dependency-path precision +guard in the batched-23 proof package are contributed by icekylinx, developed +with substantial OpenAI GPT-6 Astra assistance. Review corrections and +repository integration were prepared with OpenAI Codex assistance. They build on the retained +PR #7 finite producers and the preceding contributions credited above. +The new package retains the repository's Apache-2.0 license and the original +authors' attribution. It is not an official OpenAI release or endorsement. + +Modification notice, 8 October 2026 (icekylinx): the retained fast Gaussian +proof now bounds shifted approximation error by F=2^ceil(1.14 alpha^2). +The P=34p precision budget and asymptotic exponent are unchanged. New batching +checks are integrated into make verify. Existing attribution and licenses +are retained. + +Partial-swap extension, 8 October 2026 +Copyright 2026 icekylinx + +The partial-swap framing, binary retained-total triple construction, +dependency-preserving positive labels and carrier reuse, unequal (25,23,57) +common basis, improved complex batching, and exact assembly are contributed +by icekylinx with substantial OpenAI GPT-6 Astra and Codex assistance. +This extension directly inherits PR #10, commit +62691e395a0458ce089a1c7b5d89e74291e95e29. The portable producer adapters +modify the retained paired-exclusion and shared-point implementations credited +above. The original licenses, attribution, and Gaussian correction are retained. + +Endpoint-gauge extension, 8 October 2026 +Copyright 2026 icekylinx + +The complementary auxiliary endpoint gauges, (32,30,40) controlled basis, +general nondegenerate binary phase residuals, retained-center complex producer, +updated path guard and exact assembly are contributed by icekylinx with +substantial OpenAI GPT-6 Astra and Codex assistance. This extension inherits +f2ab41aebad47861caf6316282c1793e5513845e and its PR #10 ancestry. New portable +adapters retain the paired-exclusion and shared-point contributions credited +above. Original licenses, notices and the Gaussian correction are retained. + +Structured-basis and semantic-bulk extension, 8 October 2026 +Copyright 2026 icekylinx + +The selected (32,30,36) bit construction, A1/A5 block refinements, fixed +middle-axis I+J profiles with bounded-minor CRT certificates, mixed dyadic +complex centers, complete data-front batching and circuit-specific assembly +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. The immediate parent is ed90fd940279c336ebc45968631bdebfb087b505. + +The semantic/bulk compatibility argument, literal scalar charge, product row +stock and parameterization adapt Zhihao Chen (jacklightChen)'s PR #23, +commit 661ebabc1076c9f525d7ce4967c876b203fa9827. Translated complex endpoints +are adopted from the same contributor's PR #21, +commit 5ba6cf0bfb68f2be8d15610e7972207c50254d6a, following eumemic's source-frame +work and the earlier nested-basis contributions. + +Completed-child semantic precision, arbitrary-coordinate routing, phase-cell +Gaussian inversion and bulk tape transfer are credited to the RaD project +(hipotures), commit 45d9b60355872041f9275f77c057514def0d45bc, exposed through +PR #20 at 4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e. Their selected proof +sources retain their separate CC0 license and original NOTICE under +references/semantic-bulk/rad20. The PR #23 source retains its recorded OpenAI +Codex assistance; RaD retains its recorded Codex and GPT-6.1-Sol Ultra +assistance. These are source attributions, not claims about this session's +runtime model. Related contributions by Rohan Arun and Aurel Prosz remain +acknowledged in the imported notices. No exclusive priority or additional +license condition is asserted. + +Copied retained-center extension, 8 October 2026 +Copyright 2026 icekylinx + +The copied retained-center schedule in both orientations, its complex-phase +transfer, the Wm-N+L rank budget, and the selected (25,23)/(28,28) composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance. This extension inherits PR #32 at +0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52 and the preceding PR #10/#18/#24 work. + +The two-stage topology and paid copied-stream endpoint correction are due +to Aurel Prosz (Paureel), c82d09eb4781b68435e3fa3eb6beea72fa900fab, +through Zhihao Chen (jacklightChen)'s PR #29 unequal-axis composition, +9d963275075fa98f1da821e27757b238dafd6b3c. That source also credits Swapnil +Jain's two-stage development at ae405eb474d1486b2d8aef90139869f927f4836a. + +The contiguous corner method, incidence factorization and exact partition +certificates are due to Rohan Arun (PR #31), method commit +02f68f95369c39955c5ffcfddbd75cd83e26b305. The selected (25,23) certificate +specializes Dominik Scholz's parameterization (PR #33), +a499a345c040aa15b68e984a0904eadc485c7a7e. Their source notices and proof +snapshots are preserved in references/copied-centers. Historical OpenAI +Codex, GPT-6 Astra and Anthropic Claude Opus 5.5 assistance is credited to +the respective imported sources. Existing PR #21/#23 and RaD attribution, +licenses and the Gaussian correction remain in force. + +Copied centers with reversed (23,25) data corners, 2026-10-08 +Rohan Arun with substantial OpenAI Codex assistance supplies the composition, +exact dimension23 controls and cost/assembly integration. James Chang's PR34 +supplies the reversed boundary family; icekylinx's PR36 supplies copied retained +centers and the selected complex graph. The balanced assembly remains attributed +to RaD/hipotures and its PR34 specialization. Retain Dominik Scholz PR33, Rohan +Arun PR31, Zhihao Chen PR29/21/23, Paureel/Aurel Prosz, Swapnil Jain, icekylinx, +eumemic, Douglas Colkitt, OpenAI and all earlier notices and hypotheses. +This is not a claim of formal verification, new foundational rank identities, +global optimality or measured runtime speedup. + +Fixed middle basis with copied reversed corners (2026-10-08): +Rohan Arun, with substantial OpenAI Codex assistance. Composition and +simultaneous-basis proof retain icekylinx PR32/36, James Chang PR34, +Dominik Scholz PR35/38, Zhihao Chen, Paureel, Swapnil Jain, RaD/hipotures, +eumemic and all preceding attribution and licenses. See research/copied-fixed-reversed. + +Changed-graph composition with copied centers and fixed bases, 8 October 2026 +Prepared with OpenAI Codex assistance. +The new composition uses icekylinx PR36 copied centers and PR32 fixed-I+J +projectors/profiler, Dominik Scholz PR35 two fixed factors and CRT argument, +Zhihao Chen (jacklightChen) PR29/23 interfaces, Aurel Prosz (Paureel) and +Swapnil Jain's two-stage development, Rohan Arun PR25/31 corner methods, +Dominik Scholz PR33/38 dimension/composition work; James Chang (jamesyc) +PR34 reversed geometry and balanced transfer; Rohan Arun PR37/39/40 +reversed integration, modular data tests and both-fixed baseline; +RaD (hipotures) PR41 changed scalar DAGs, alternating point order and +independent role compiler; RaD balanced routing/bulk interfaces, and all +retained predecessors. +Complete attribution and the conditional proof boundary are recorded in +research/copied-fixed/PROOF.md; imported originals and source pins are retained. +Original Apache-2.0 and CC0 notices remain applicable. + +Community follow-up integration (PRs #49, #45 and #26), 8 October 2026: +Rohan Arun contributes weighted carrier matching and climbed summand/leave-one-out +orders (PRs #44/#47/#49), with Anthropic Claude assistance. The final construction +composes Chafik Boukhalfa's changed-graph checks, exact rational data recovery and +reordered exclusion sums (PRs #43/#46/#48, OpenAI Codex assistance) with RaD / +hipotures's alternating pair order and independent physical role compiler (#41). +All predecessor attribution and conditional proof interfaces remain in force. + +Alejandro Zarzuelo Urdiales contributes Gaussian parity and canonical arithmetic +proofs, finite tensor execution, profile precision accounting and mixed-center +reference checks (#45), with substantial OpenAI Codex assistance. See +research/gaussian-parity-synthesis/PROVENANCE.md for his full attribution. +Ryan S / princezuda contributes historical Lean certificate arithmetic, algebraic +frame/movement/guard lemmas and independent paired-circuit checks (#26). Original +source notices and historical snapshots are preserved. Neither formal package +claims a full formal proof of the multiplication algorithm or a new kappa. + +Joint frame compilation of skip-prefix strips + +The local compiler and exact finite witnesses were prepared by eumemic with +substantial OpenAI Codex assistance. Avi Eisenberg / ikeboy with Anthropic +Claude assistance supplied the unmodified PR #53 skip-prefix producer. +The pinned PR #48 pipeline is Chafik Boukhalfa's contribution, incorporating +Rohan Arun, RaD / hipotures, icekylinx, Dominik Scholz, James Chang, +Zhihao Chen, Aurel Prosz / Paureel, Swapnil Jain, eumemic, Douglas Colkitt, +OpenAI, David Harvey, Joris van der Hoeven and the earlier contributors +credited in the retained sources. See references/frame-compiler/pr48/NOTICE +and references/frame-compiler/pr53/NOTICE for their original attribution. +No authorship or review by those predecessors is claimed for this compiler. + +Joint dual-skip/frame-compiler composition (2026-10-08) +--------------------------------------------------- +Rohan Gupta / gupt1156 with Anthropic Claude assistance: PR55 dual-skip +scalar graph; original LICENSE and NOTICE are retained under +references/frame-compiler/pr55. eumemic with substantial OpenAI Codex +assistance: PR57 joint reversible frame compiler, serialized physical-word +replay and profile reconstruction. Chafik Boukhalfa with OpenAI Codex +assistance: this composition, independent integration and exact certificate. +Avi Eisenberg / ikeboy, Rohan Arun, RaD / hipotures, icekylinx, and all +predecessor authors retain the notices above and in pinned source files. +No original copyright or Apache-2.0 notice is removed. + +Ranked reclamation after the PR58 joint-dual composition (2026-10-08) +---------------------------------------------------------------- +Chafik Boukhalfa with OpenAI Codex assistance: prioritize retired physical +slots by descending current frame rank, retaining slot ID as the tie-breaker; +complete replay, exact profiles, comparison and adversarial controls. +The dedicated joint_dual_reclaim_compiler.py is derived from eumemic's PR57 +compiler. Its original shared compiler remains byte-identical. The PR55 +producer and all preceding attribution remain unchanged. The complete PR58 +comparison certificate and its original source/proof provenance are retained +under references/frame-compiler/pr58. + +Skip-prefix strip producer, 8 October 2026 +By Avi Eisenberg (ikeboy), with Anthropic Claude (Claude Opus 5.5) +assistance. The skip-prefix leave-one-out strip layout in +research/skip-strips/skip_graph.py is new. Everything else reuses Chafik +Boukhalfa's PR #43/#46/#48 research/copied-fixed pipeline, its verification +code, exact data recovery and support-order sorting, together with: +- Rohan Arun's PR #44 weighted carrier matching optimizer; +- RaD (hipotures) PR #41 alternating point order; +- every predecessor credited above. +Complete attribution and the conditional proof boundary are recorded in +research/skip-strips/PROOF.md. Original Apache-2.0 and CC0 notices remain +applicable. + +Local split-pair skip-prefix research continuation (2026-10-08) +Prepared with substantial OpenAI Codex assistance at the user's request. +New contribution: singleton/pair recursive partition refinement, finite summand +order and moment search, and verified composition with inherited paid clones. +Avi Eisenberg/ikeboy with Anthropic Claude assistance: PR53 skip-prefix strips. +Chafik Boukhalfa with OpenAI Codex assistance: PR54 original-envelope clone +specialization and PR43/46/48 checking interfaces. RaD/hipotures: PR51 +whole-chain/source-partition cloning and earlier producer/interfaces. +Rohan Arun: PR44 weighted matching and earlier fixed/reversed work, with all +stated historical AI assistance. All predecessor notices remain applicable. + +Original-envelope whole-chain clones on skip-prefix strips (research/skip-clones): +Chafik Boukhalfa, prepared with OpenAI Codex assistance. The complete-chain +source-partition clone operation is adapted from RaD / hipotures, PR #51, +with original envelopes retained here. The scalar base is Avi Eisenberg's +PR #53 skip-prefix layout, prepared with Anthropic Claude assistance. +All credited PR #43/#46/#48, PR #44 and earlier code/proof notices remain +in force. This extension is provided under the repository's Apache-2.0 terms. + +Community review checkpoint #50–#61, 8 October 2026 +Maintainer integration and independent arithmetic: Douglas Colkitt, with OpenAI Codex. +Avi Eisenberg / ikeboy: skip-prefix strip framework (#53), with Anthropic Claude. +Rohan Gupta / gupt1156: parallel order search (#50, stated Antigravity assistance) +and dual-suffix strips (#55, Anthropic Claude assistance). +Eumemic: equal-frame joint compilation and paid signal reclamation (#57), with Codex. +Chafik Boukhalfa: original-envelope paid clones (#54), composition (#58) and ranked +reclamation (#60), with Codex. Rohan Arun: order search (#52) and positive-frame +composition (#56), with Anthropic Claude and stated Codex validation assistance. +RaD / hipotures: enlarged frames, source partitions and paid whole-chain clones +(#51), with Codex. Rohan Garg / rohangar1: singleton/pair recursion and paid-clone +composition (#59), with Codex. Alejandro Zarzuelo Urdiales: exact parameter +refinement, scoped Lean arithmetic, matrix/parity and search tools (#61), with +his disclosed multi-tool and Codex assistance. +Parallel #50/#52 records are reviewed and credited without replacing the earlier +climbed-48 implementation; their exact commit history is retained. The separate +#51 witness is retained as research; its source-graph/negative-basis data proof +has not received the same full replay as #56's consumed compiler machinery. +See docs/research/community-round2-review.md for precise validation boundaries. +All earlier licenses, contributions and notices remain applicable. + +Interval strips and core-aware pair assembly + +The interval leave-one-out strips and the core-aware group-pair assembly in +research/pair-assembly were prepared by Avi Eisenberg / ikeboy with Anthropic +Claude assistance. They build on PR #53's skip-prefix pipeline and its +inherited PR #48 sources. The stacked witness in research/pair-assembly/frame +uses eumemic's PR #57 joint frame compiler unchanged; its driver and verifier +are adaptations of PR #57's skip_frame_compiler.py, skip_frame_compose.py and +verify_skip_frame.py. Original notices are retained. + +Stopped product-ring extension, 9 October 2026 +Copyright 2026 icekylinx + +The opposite-bank generic projector factorization, componentwise atom-ring +adapters, stopped recurrence and outer ordinary-interchange conversion, +aligned pair-star producer with rational centers, exact denominator-21 +grid and selected (23,23)/(24,24) composition are contributed by icekylinx +with substantial OpenAI GPT-6 Astra and Codex assistance. This extension +builds on merged PR #36, 11817ccacb564bb7f98789c20dc11d3fece207e3, and is +integrated on upstream main 56b66d58297deca1d7dd130247d720e960f77a37. + +The retained ordinary leaf uses the preceding projector, corner and +copied-center proofs. The selected two-stage topology retains Aurel Prosz +(Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly +retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching, +original source notices and each imported license remain unchanged. + +Partial-gauge extension, 9 October 2026 +Copyright 2026 icekylinx + +The pair-first cube assembly, compatible backward frame enlargement, +partial source-gauge schedule and stopped whole-projector composition are +contributed by icekylinx with substantial OpenAI GPT-6 Astra and Codex +assistance, extending PR #104 at 948ce1510df750f4c18b96bdaef436a86f8bf834. + +The physical deferred bit word, reflected event accounting, fan-order +clarification and signed two-stage endpoint are adopted from Zhihao Chen +(jacklightChen), PR #97, e15350b66e4bf796153a68c240a6cc1b788abe3e, with +Codex assistance. Its deferred readouts, V leaves, lifted frames and frozen +witness originate in Swapnil Jain's 741e7aa078392553815df7926ee17ac5e25a8c38, +with the original Claude disclosure retained. Cyclic interval and core-aware +pair primitives build on Avi Eisenberg (ikeboy), PR #62, +ad0f25ff7b23cff7f08ad237c2254e6ecf74257e, with Anthropic Claude assistance. +Prior two-stage, copied-center, ordinary-leaf, semantic/bulk, routing and +precision credits remain in force. Imported source notices and licenses +are preserved under references/partial-gauge/; see SOURCES.json. + +Three-stage cover extension, 9 October 2026 +Copyright 2026 icekylinx + +The arbitrary-subspace Clifford frame theorem, three-stage Cayley geometry, +weighted q-adic GL cover, unit-lower weighted compiler, charged local-ring +fallback, uniform batching, internal row borrowing and exact composition +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. This +repository integration uses Codex assistance and extends +PR #115, cf60442983c153a3a0f5272ea4713f99eba13c86. + +The selected local complex DAG and support/label replay are adopted from +Copyright 2026 eumemic, PR #117, cbb05ce504d571546d9b7794c186a613c659c3bf, +with its original Apache-2.0 terms and Claude assistance disclosure. +The unchanged bit physical word retains Zhihao Chen (jacklightChen), +PR #97, and Swapnil Jain's underlying witness and assistance notices. +The prior opposite-bank, stopped ordinary-leaf, copied-center, topology, +semantic/bulk, precision and analytic credits remain applicable. +Original source notices and license bytes are preserved in +references/three-stage-cover/pr117/ and references/partial-gauge/. + +Paired-cube and shared-core extension, 9 October 2026 +Copyright 2026 icekylinx + +The paired-coordinate triple-cube identity, signed overlap channels, +original-source involution, coordinate-star centers, concrete frame/carrier +compiler, chronological source gauges, PR97 gauge-subset selection, +orthogonal cross-stage routing and exact supplier/assembly integration +are contributed by icekylinx with substantial OpenAI GPT-6 Astra assistance. +Repository integration uses Codex assistance and extends PR #130 at +6a9970a530119174507904e23592fd59ede19a5d. + +The substantial completed-core workspace-sharing principle is credited to +an664, PR #128, 530588a019b4a74f09180680c9e3961bf649ec89, with its reported +OpenAI Codex assistance. No source code, partition or serialized witness +from that PR is imported. The new routing and paired-motif integration +are described separately and claim no exclusive priority for broad sharing, +paired-coordinate, Fourier or carrier-matching ideas. + +Selected coarse queries restrict the retained eumemic PR #117 positive DAG; +its original Apache-2.0 and Claude assistance notices remain unchanged. +The bit word and original frames retain Zhihao Chen's PR #97 and Swapnil +Jain's frozen witness, notices and historical assistance disclosures. +Earlier generalized Clifford, three-stage, uniform weighted recursion, +ordinary-leaf, semantic/bulk, precision and analytic credits remain in force. +Source-specific license bytes are preserved under references/. + +October 9 recycled-bit integration: +DaysSky (#150), William Porter/hpst3r (#147), Thomas Marchand/Th0rgal (#146), +Rohan Gupta/gupt1156 (#148), James Chang/jamesyc (#124), SovereignSteak (#122). +The original notices and assistance disclosures are retained under research/, +including research/recycled-bit-integration/NOTICE. Andrew Barnes/Bortlesboat +(#101) repairs shared verifiers using rfu08's #64 counterexample. rfu08's +scoped finite and formal-transfer packages are included separately; they do +not establish the full multiplication theorem. Earlier and parallel credits +remain applicable. Douglas Colkitt integrated these with OpenAI Codex assistance. + +SovereignSteak PR151 independently supplies the matching gauge/recycling +composition and the selected 473/10^6 atom refinement; its original package +and assistance disclosure are retained under research/gauge-recycling/. + +October 9 coordinated-frame and completed-entrance-bank integration: +Dugongue PR186, 166a34d75e853e933855f0f7e940fe77c4bb6b8d, builds on +Chafik Boukhalfa/chafreaky's PR181, 7fb2194801e3a10f54772c7f0d5505035a4fc0ad, +and eumemic's PR168 v4, 4a3c769e5c5430e7114c4d3e099ff34664677f17. +The frozen package and prerequisite archive preserve all author, source-license +and assistance notices, including PR175's compiler optimization. DaysSky's +carrier closure, James Chang's terminal substitution and balanced assembly, +geckods' stopping refinements and all preceding framework credits remain. +Rohan Arun's PR185 bootstrap and chafreaky's PR182 bit refinement are reviewed +parallel contributions; their gains are not added to the selected witness. +Douglas Colkitt integrated the package and supplied the bank scheduling +supplement with OpenAI Codex assistance, under Apache-2.0. The all-size +interfaces remain conditional; finite verification is not full formalization. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/OUTER-GATE-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/OUTER-GATE-NOTICE new file mode 100644 index 0000000000..1bc9b4da2b --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/OUTER-GATE-NOTICE @@ -0,0 +1,13 @@ +# Attribution and source reuse + +New independent operator/invoice verification and fixed-grid interval implementation: OpenAI Codex-assisted research session, 2026-11-10. Apache-2.0. + +DreamingOfClouds supplied the #6936 native predecessor and #6937 shared-wire backup/E-free root. CubeJerry supplied #6912 caller blocks, #6980's QUERY-only caller and #6970/#6985 precision methods. Preserve Ali Romman's #5599 helper-split attribution, icekylinx's #104 odd-grid attribution and unpaidmoon's #6930 width-phase attribution in the parent construction. + +Three unchanged source files are authenticated by exact SHA256 and source commit/path in `INDEPENDENT-SOURCES.json`: + +- #6970 `independent_bounds.py`: fixed integer-grid and positive caller-transfer engine. +- #6985 `envelopes.py`: positive forward envelopes and backward covector witnesses. +- #6985 `source_binding.py`: retained helper functions for the envelope engine. + +The adapter applies only two literal helper-census substitutions in memory and records them. It does not call that adaptation an independent mathematical implementation. The new reverse native operator, formal caller ring and elementary interval engine do not import the source authors' operator or invoice checkers. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7663-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7663-NOTICE new file mode 100644 index 0000000000..6ce1bc49a3 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7663-NOTICE @@ -0,0 +1,7 @@ +Apache-2.0. Ali Romman with substantial OpenAI Codex assistance. + +The new material is the joint chart assignment, its source-bound operator and caller checks, and the fresh-cost complete-root scalar and private-bank specialization. The parent data are from Clear1nsight's PR #7660 on DreamingOfClouds' PRs #7658 and #7641 and SYLforge's PR #7637. The contributors credited in those sources retain their credit. Original notices are in source/parent-NOTICE, source/physical-NOTICE and source/word-NOTICE. + +Rohan Arun supplied the 17-stage signed caller in PR #7113. The unmodified interval gate and the exact caller data come from its pinned source. See source/caller-NOTICE and source/independent-NOTICE, and the source file inventory for all consumed bytes. The two operator engines and integer power evaluator come from the declared current-main inputs. + +Jerry Chen (CubeJerry) supplied selected PRs #7000 and #7001. The selected application and its phase, common-root, finite-cost and compiler arguments, the odd-native common-grid package, the prior typed six-Gamma reset of PR #7586 and the contributors credited in those records provided the foundations used here. PR #7661 independently derives the fixed caller residuals. PR #7662 supplies a rounded parent-clock alternative. This package uses neither implementation. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7669-PROVENANCE.md b/research/interleaved-basis-residual-audit/retained/source/credits/PR7669-PROVENANCE.md new file mode 100644 index 0000000000..bbee2437f0 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7669-PROVENANCE.md @@ -0,0 +1,43 @@ +# Provenance, credit and scope + +This is a cumulative contribution. Thank you to everyone who has made their constructions, exact inputs, failure cases and careful reviews available. Those contributions made this composition possible; the small increment here should not obscure the much larger body of work it rests on. We aim to leave equally inspectable material for the next researcher. + +## Direct lineage and reused methods + +- **SYLforge, #7637:** the H5B frame-restored233-CLEAR construction is the published ancestor of this research. The present K372-2 source retains its descendants rather than starting a new independent construction. [PR7637](https://github.com/CrocSwap/integer-mult-bounds/pull/7637). +- **DreamingOfClouds, #7641 and #7658:** #7641 combines20 edits over #7637. #7658 supplies the large-neighbourhood construction and its exact joint hub reconstruction: helper360/537 SWAP-NULL relabel, main176 bypass, helper236 contact re-chart, helper370 last-stay removal and helper461 first-stay removal. The source explicitly credits its #7630/#7636 relabel lineage and #7634 swap law. Our source descends from this word; those gains are not claimed as new work here. [PR7641](https://github.com/CrocSwap/integer-mult-bounds/pull/7641), [PR7658](https://github.com/CrocSwap/integer-mult-bounds/pull/7658). +- **Clear1nsight:** the contact re-chart type from #7612 and the24-bit coefficient-splitting report are part of the construction's lineage. #7626 contributed source isolation/portable materialization, and #7631/#7633 are credited by the parent lineage. #7660 separately published the role379 shortcut already present in our source; we do not count its rediscovery as another improvement. [PR7612](https://github.com/CrocSwap/integer-mult-bounds/pull/7612), [coefficient report](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19691406), [PR7660](https://github.com/CrocSwap/integer-mult-bounds/pull/7660). +- **ToikY, #7643:** the contact re-chart work is explicitly credited by #7658 alongside Clear1nsight's #7612. Its74-erasure contract and κ are not added to this candidate. No shared CI repair is copied by this PR. [PR7643](https://github.com/CrocSwap/integer-mult-bounds/pull/7643). +- **Rohan Arun, #7113:** the signed caller/accounting lineage underlies the actual16-call composition. Its original source commit is07a76c5e2738882c0cb322278e56f6cae3c9885d. We recount the literal16-call input here; we do not substitute historical17-call constants. [PR7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113). +- **Ali Romman and upstream contributors:** #7605 supplies an earlier exact protected/application checkpoint cited by the #7637 lineage. The two unmodified directed invoice comparison files are copied from canonical upstream base e54523517d0f03e58352e647c403a5af3e525a57, retaining their attribution and Apache-2.0 headers. Their arithmetic is not a full scientific acceptance gate. [PR7605](https://github.com/CrocSwap/integer-mult-bounds/pull/7605). +- **CubeJerry, Douglas Colkitt and the earlier source contributors:** the retained framework, primitive/service work and repository infrastructure form part of the inherited basis. This package does not claim that their open supplier obligations are resolved by a successful finite replay. + +## What this contribution adds + +The predecessor K372-2 supplies five EARLY edits (1188,1013,940,1141,1195, with940/1141 sharing one ADD). This construction recomputes the1517/770 bypass on that actual source and combined it with a three-field triangle repair. The new contribution is their compatible composition, exact12-block edit, final235 CLEAR witnesses and a small reproducible publication package. Substantial OpenAI Codex assistance was used for research and packaging. New work is Apache-2.0. + +Exact source canonical:3dd1199d95291ee96e6c0aeb6f55f86244a569b1d4975840bf0207e2dcf9c025. Exact candidate canonical:ee251f6005d2a92b887c5b804bd7aac05989d278b2c9ccb3c3091b50d533b08d. Byte hashes are in MANIFEST.json. The12 edit blocks specify every changed event and leave all other fields unchanged. The parent research generators are not silently imported; this publication uses the transparent exact edit as its deterministic reconstruction recipe. + +## Related work, not automatically incorporated + +Ali Romman's #7662 studies one half-ADD rounding-error propagation with CubeJerry's service contract. Nick Petalas's #7654 provides a scoped minimal-rank interpolation result used as background when assessing structural repairs. Neither is a substitute for this candidate's entire rounded caller or physical supply proof. Their actual domains and assumptions must be checked before application. [PR7662](https://github.com/CrocSwap/integer-mult-bounds/pull/7662), [PR7654](https://github.com/CrocSwap/integer-mult-bounds/pull/7654). + +At the publication checkpoint, upstream main remained e54523517d0f03e58352e647c403a5af3e525a57. Ali Romman's #7663 uses a separate17-call full-private-bank model and changed helper endpoints; Clear1nsight's #7664 concerns180erasures/17calls; #7666 charges bank selection and return without claiming a new κ. K372-4 is later, separate research with changed helper-boundary conditions. None is silently folded into ee251f60 or used to assert identical physical assumptions. This is not a claim to the greatest bound across all models. + +## Fresh versus reused evidence + +Publication replay freshly reconstructs the whole word, runs exact rows/CLEAR, recounts native/caller histograms and checks the four directed price points. Normal, optimized Python and a Git-free committed-byte export were tested. The recorded ordinary/precision/native-phase/owner evidence retains its narrower scope and original source identifiers; it is not advertised as freshly rerun. No selected record, frozen predecessor package or common verifier is changed. + +## Editorial normalization of publication labels + +The follow-up editorial commit replaces workstation labels with construction terminology. It changes no candidate, edit, certificate, invoice, numeric result, executable code or contributor attribution. The original recorded bytes remain retrievable at commit `95d476623f1468822057554475dc8badb19bfa44`. Evidence JSON field labels and descriptive scopes are normalized, not recomputed scientific results. In NATIVE-EVIDENCE-REUSE.json, `predecessor-receipt:K372-2/NATIVE-NEW.json` is a historical receipt identifier, not a packaged file path. In PRICE-SUMMARY.json, recorded command invoice arguments now use the equivalent packaged `data/INVOICE.json` path; this is a portability transcription, not the verbatim original command. The fresh replay constructs and runs its own package-relative command. MANIFEST.json authenticates the edited publication bytes. + +Evidence byte-custody mapping (original -> editorially normalized SHA-256): + +- `evidence/BUILD.json`: `4744201691120223ded62a3e0d55ea1029203f3ea996305163e7db8d9e3679a4` -> `a0bafbb3f44920ed6ac1ed3d83385f025f5bbbcf5e9c8013ab1ca55ccf23c32d`. + +- `evidence/NATIVE-EVIDENCE-REUSE.json`: `6615b8a051ac9e4d8c73b5decf8a70d2a33d14da0c4c369574dec946984aa351` -> `84bab14d5c584aa8853b8e1025b562541ac6657e458d120ec803f2bc149c3eb8`. + +- `evidence/ROLE770-BUILD.json`: `c4ee72317678791d4b801479df0af052f3a50662c11ce3f3393b2151368fc92d` -> `1c400f16efbc427c40c811a57dc656fe97c2c84f94c71529e2c5c0598b146369`. + +- `evidence/PRICE-SUMMARY.json`: `c2777382c677634f7017b68c55dbd831a40945b77057f26b738f857c17ee8759` -> `d13741fe3217a01edd0b79b40dad037e644e441fbbc300838df99c0b050a5f42`. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7674-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7674-NOTICE new file mode 100644 index 0000000000..951f081717 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7674-NOTICE @@ -0,0 +1,7 @@ +Apache License 2.0. Research prepared for Ali Romman with substantial OpenAI Codex assistance. + +New work includes the fifteen certified sender/receiver pivots, the forward and transposed communication construction, the complete native row checker, and the finite stock and precision application for this 16-call program. + +SYLforge supplied the composition, native word reconstruction, published invoice and exact 16-stage caller bytes from PR #7669. Their original PROVENANCE.md is preserved in source/7669-CREDITS.md. It credits the H5B work of SYLforge, DreamingOfClouds' joint native reconstructions, Clear1nsight's coefficient splitting, role-379 and helper work, Rohan Arun's signed caller lineage, and prior contributions from CubeJerry, Douglas Colkitt and others. The source/ directory holds the exact file bytes identified in SOURCE-PINS.json. + +The group-ring caller checker, independent operator checks, bit service, finite-cost method and field guide adapt the corresponding code and arguments of Ali Romman's PR #7663. That package in turn builds on the contributors named in its preserved source/7663-NOTICE. The unchanged directed log/exp gate retains its listed sources in source/gate-NOTICE. Earlier paid-transfer and bank-support constructions include PRs #7434 and #7576. Jerry Chen (CubeJerry) supplied the selected PRs #7000 and #7001 and the typed initializer in PR #7586. The per-call odd-grid induction and the selected application review provide the complete-root realization and finite-cost substitution. Douglas Colkitt and the credited repository authors supplied the pinned operator engines, price evaluator and research workflow. The license accompanies this package. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7682-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7682-NOTICE new file mode 100644 index 0000000000..4654631de0 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7682-NOTICE @@ -0,0 +1,9 @@ +Apache License 2.0. Research prepared for Clear1nsight with substantial OpenAI Codex assistance. + +Ali Romman supplied the fifteen exact banked pivots and the frozen #7674 baseline, along with the complete signed 16-call graph and application method. The original notices remain at peer/NOTICE, peer/source/7663-NOTICE and peer/source/gate-NOTICE. Read peer/SOURCE-PINS.json for each ancestry binding and ASSETS.json for the exact vendored bytes at scientific commit 26b6c469aa6c4aa04322ce25a22150f90e5fb14e and refreshed head 28b2af322a1fab01b3734365988930920f9dda48. + +SYLforge supplied the #7669 composition, native source pins and literal caller. Its preserved parent provenance is peer/source/7669-CREDITS.md. Retain DreamingOfClouds' #7641/#7658 lineage, Clear1nsight's integer scalar/contact work including #7612, ToikY's #7643 contact-rechart precedent, Rohan Arun's #7113 signed-caller lineage, 5080's helper work, and all other contributors named in the original records. Ali Romman's #7663 exact-grid and extent proof and #7666/#7670 selection and guide work supply relevant implementation precedents. Jerry Chen (CubeJerry) supplied the selected #7000/#7001 applications and #7586 typed initialization. Douglas Colkitt and the authors in the original notices supplied the frozen native compiler, independent checker, price evaluator and package infrastructure. + +The release base reuses ToikY's exact shared CI and historical replay sync 0eabc624a9bc9ed2847719efd63390db4d297df4 above canonical e54523517d0f03e58352e647c403a5af3e525a57. This workflow provenance is separate from the banked construction and its mathematical comparison. + +This package credits the original role-230 splice and its same-contract transfer to the unchanged fifteen-pivot graph, the independent exact wire and price replays, matched complete resource accounting and source-bound native and caller verification. The original works retain their authorships and licenses. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7704-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7704-NOTICE new file mode 100644 index 0000000000..7d2dfec60a --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7704-NOTICE @@ -0,0 +1,5 @@ +Apache License 2.0. Prepared for Clear1nsight with substantial OpenAI Codex and ChatGPT Pro assistance. + +SYLforge supplied the cf6a nine-swap word and its normalized verification in #7700. DreamingOfClouds contributed the #7641 and #7658 swap searches. Ali Romman supplied the changed helper contract in #7663 and the charged bank construction in #7674. Rohan Arun and the #7113 lineage supplied the signed caller. The bank, native, physical and directed price methods reuse work by Ali Romman, SYLforge, Clear1nsight and the contributors credited in #7669, #7682 and #7697. Jerry Chen (CubeJerry) supplied the selected #7000 and #7001 application. Douglas Colkitt and the recorded authors supplied the selected framework, compiler, checker and package infrastructure. + +This contribution identifies and contracts the two paid transfers on helper 1256, reconstructs the banked graph from the supplied source, and checks the resulting physical application and complete signed price. The separate investigation and technical review were performed with Codex agents. Preserve the original notices and citations in credits/ when redistributing the source data or derived engines. See SOURCES.json for pinned upstream inputs and ASSETS.json for file-level custody. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7705-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7705-NOTICE new file mode 100644 index 0000000000..2a92a9df69 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7705-NOTICE @@ -0,0 +1,7 @@ +Apache License 2.0. Research prepared by DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. + +The contribution is the hub-reroute construction: its search, the exact builder, the 21 reroutes and the checks in this package. All code here is newly written, and predecessor packages were read as data only. + +Clear1nsight supplied the chart-595 helper split (PR #7697) and the role-230 rechart (PR #7682), which is the first hub reroute. Ali Romman supplied the banked-transfer circuit and its fifteen pivots (PR #7674). SYLforge supplied the #7669 word and the signed sixteen-call caller. DreamingOfClouds, Rohan Arun, Jerry Chen (CubeJerry), Douglas Colkitt and the authors credited in the inherited notices supplied predecessor constructions, the selected framework and the repository infrastructure. + +The exact predecessor notices are in `credits/`. `source/` holds the K372-2 word, the twelve #7669 edits and the 16-call caller as published with #7669. `ASSETS.json` binds every package file. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7708-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7708-NOTICE new file mode 100644 index 0000000000..4a24e9bcb7 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7708-NOTICE @@ -0,0 +1,7 @@ +Apache License 2.0. Prepared for Ali Romman with substantial OpenAI Codex assistance in research, implementation, verification and writing. + +This contribution supplies the ordered 46-cut certificate on the exact #7704 graph, the source and receiver recoding with scalar feedback, its 3 witnesses, the composition checks and the signed application. + +SYLforge supplied the nine-swap source word in #7700. DreamingOfClouds and SYLforge supplied the preceding native searches. Clear1nsight supplied the #7704 role-1256 contraction and the open pivot-combination question, the #7682 role-230 reroute and the #7697 chart-595 split. DreamingOfClouds supplied the grouped hub mechanism in #7705 on a different graph. Ali Romman supplied the banked transfer pivots and catalogue method in #7674 and the predecessor common-grid construction in #7663. Rohan Arun supplied the signed caller lineage. Jerry Chen (CubeJerry) supplied the selected complex application and BIT input. Douglas Colkitt and the credited repository contributors supplied the source framework, compiler, operator engines, comparison tools and research infrastructure. + +The files under vendor/ and data/ retain their published bytes. SOURCE-PINS.json identifies each original file and commit. The catalogue checker adapts the #7674 checker to the new graph and adds signed contact checks. The independent operator producer and checker and the directed invoice tools come from the canonical source files in SOURCES.json. The original supplier notices, including those for the outer gate, are under credits/. Preserve these notices with the reused material. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7713-NOTICE b/research/interleaved-basis-residual-audit/retained/source/credits/PR7713-NOTICE new file mode 100644 index 0000000000..8fa17b3fd6 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7713-NOTICE @@ -0,0 +1,7 @@ +Apache License 2.0. Ali Romman prepared this work with substantial OpenAI Codex assistance in research, implementation, verification and writing. + +New work includes the coupled helper and paid-bank restriction, its 33 witnesses, the compact interface, the independent checks of 67 receiver identities and the signed application on 1,468 public fields. + +The exact application starts from Ali Romman's 46-cut graph in PR #7708. SYLforge supplied the nine-swap word in #7700. Clear1nsight supplied the role-1256 relay and banked physical schedule in #7704. DreamingOfClouds supplied the related grouped-hub method on the separate chart-595 graph in #7705. Ali Romman supplied the preceding pivot, common-grid and signed-bill checks. Rohan Arun supplied the signed caller lineage. Jerry Chen (CubeJerry) supplied the selected complex application and BIT input. Douglas Colkitt and the credited repository contributors supplied the research framework, compiler, exact operator engines and comparison tools. The concave comparison retains mightyOil's method credit. + +The files under vendor/ and data/ retain their source bytes. SOURCE-PINS.json gives original commits, paths, Git blobs and SHA-256 values. SOURCES.json pins the canonical repository inputs. The catalogue and reverse sweep adapt the corresponding #7708 checks to the compact graph. The supplier notices are under credits/. Preserve them with the reused work. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7716-CREDITS.md b/research/interleaved-basis-residual-audit/retained/source/credits/PR7716-CREDITS.md new file mode 100644 index 0000000000..baa9d2f16c --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7716-CREDITS.md @@ -0,0 +1,58 @@ +# Attribution and exact source pins + +Ali Romman prepared the fixed-graph composition, its constructive +checker and scoped evidence with substantial OpenAI Codex assistance. +New work is Apache-2.0. Source proofs and code were read; this is +author checking, not blind, human or formal-kernel review. + +DreamingOfClouds supplied the two literal readouts and injections in +[PR #7712](https://github.com/CrocSwap/integer-mult-bounds/pull/7712), +head `5001d95a5c1decfb2b0d64d13c130300797e722a`. +The [causal split proof](https://github.com/DreamingOfClouds/integer-mult-bounds/blob/5001d95a5c1decfb2b0d64d13c130300797e722a/research/p104-banked-cf6a-splits/PROOF.md), +[literal circuit](https://github.com/DreamingOfClouds/integer-mult-bounds/blob/5001d95a5c1decfb2b0d64d13c130300797e722a/research/p104-banked-cf6a-splits/data/CIRCUIT.json.gz) +and [source notice](https://github.com/DreamingOfClouds/integer-mult-bounds/blob/5001d95a5c1decfb2b0d64d13c130300797e722a/research/p104-banked-cf6a-splits/NOTICE) +identify the original construction and Claude Opus 5.5 assistance. +That source's charts, witnesses and split identity are prior work. +The new result transports the two surviving witnesses to the changed +quotient graph and verifies their joint compatibility. The third +source split is excluded; its known collision is not claimed as new. + +Ali Romman's separate workstream supplied all 33 restrictions in +[PR #7713](https://github.com/CrocSwap/integer-mult-bounds/pull/7713), +scientific commit `06b75fde21f4231a2bd0725542c3ba60a908d83b`, published +head `52e7eb424b9ae9f2e6002eb17e475bce6195d848`. +Its [constructor](https://github.com/aliromman/integer-mult-bounds/blob/06b75fde21f4231a2bd0725542c3ba60a908d83b/research/p104-helper-quotients/quotient.py) +exports the frozen compact input. Its +[application receipt](https://github.com/aliromman/integer-mult-bounds/blob/06b75fde21f4231a2bd0725542c3ba60a908d83b/research/p104-helper-quotients/results/application.json) +supplies the unchanged fixed caller and root rows. +The [compatibility handoff](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19711980) +asks for a separate construction before the source gains can combine. + +Ali Romman's [PR #7715](https://github.com/CrocSwap/integer-mult-bounds/pull/7715), +head `4517ad2a3e9f06ca369a2625f652de4f57be2fb9`, supplies the +[exact basis engine](https://github.com/aliromman/integer-mult-bounds/blob/4517ad2a3e9f06ca369a2625f652de4f57be2fb9/research/helper-quotient-basis-audit/verify.py), +copied unchanged as basis_engine.py. That package checked the compact +endpoint and complete restriction debits. Its result is not repeated +as a new contribution here. The earlier unsplit positive-control graph +is from [PR #7708](https://github.com/CrocSwap/integer-mult-bounds/pull/7708), +scientific commit `f0e2db5b5b46b139da17d2b32fab6633164443a9`. + +The retained notices credit Clear1nsight for the causal split method +in [PR #7697](https://github.com/CrocSwap/integer-mult-bounds/pull/7697), +role-1256 relay in [PR #7704](https://github.com/CrocSwap/integer-mult-bounds/pull/7704), +and role-230 reroute; SYLforge for the word and signed caller in +[PR #7700](https://github.com/CrocSwap/integer-mult-bounds/pull/7700); +Ali Romman for the banked circuit and recodings; Rohan Arun, Jerry +Chen / CubeJerry, Douglas Colkitt and repository contributors for +predecessor constructions and the selected framework; and mightyOil +for concave comparison. The source notices under credits/splits and +credits/quotients, and the PR #7715 credit, retain their exact bytes. + +[SOURCE-PINS.json](SOURCE-PINS.json) records all retained bytes and +original Git blobs where applicable. The parent and compact graphs +are explicit source-constructor exports. No source constructor or +source split checker is imported by the replay. Copies are committed +in this package, so no unmerged predecessor history is needed. +[SOURCES.json](SOURCES.json) pins the base catalogue and selected +record as provenance; it does not claim that pending source commits +are ancestors of this branch. diff --git a/research/interleaved-basis-residual-audit/retained/source/credits/PR7717-CREDITS.md b/research/interleaved-basis-residual-audit/retained/source/credits/PR7717-CREDITS.md new file mode 100644 index 0000000000..538263114c --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/credits/PR7717-CREDITS.md @@ -0,0 +1,50 @@ +# Credit and source custody + +Ali Romman prepared this application with substantial OpenAI Codex +assistance in research, implementation, verification and writing. +New work is Apache-2.0. This is author checking with source engines. +It is not blind, independent human or formal-kernel review. + +The fixed normalized composition is prior work in +[PR #7716](https://github.com/CrocSwap/integer-mult-bounds/pull/7716), +head `1636b3c9b922d23b222b60dd52e005e60c592491`. +Its [construction proof](https://github.com/aliromman/integer-mult-bounds/blob/1636b3c9b922d23b222b60dd52e005e60c592491/research/quotient-causal-split-composition/PROOF.md) +and [constructor](https://github.com/aliromman/integer-mult-bounds/blob/1636b3c9b922d23b222b60dd52e005e60c592491/research/quotient-causal-split-composition/verify.py) +supply the graph. Its source credit is retained in credits/PR7716-CREDITS.md. + +Ali Romman's [PR #7713](https://github.com/CrocSwap/integer-mult-bounds/pull/7713), +scientific commit `06b75fde21f4231a2bd0725542c3ba60a908d83b`, supplies the +[application](https://github.com/aliromman/integer-mult-bounds/blob/06b75fde21f4231a2bd0725542c3ba60a908d83b/research/p104-helper-quotients/application.py), +[catalogue check](https://github.com/aliromman/integer-mult-bounds/blob/06b75fde21f4231a2bd0725542c3ba60a908d83b/research/p104-helper-quotients/catalogue.py) +and unchanged vendor files. The new wrappers adapt those checks to the +1470-field graph, its two fresh helper owners, new grid and complete bill. +The [source notice](https://github.com/aliromman/integer-mult-bounds/blob/06b75fde21f4231a2bd0725542c3ba60a908d83b/research/p104-helper-quotients/NOTICE) +identifies the authors and retained lineage. + +Clear1nsight supplied the banked execution and relay in +[PR #7704](https://github.com/CrocSwap/integer-mult-bounds/pull/7704), +commit `e29a5ae8591243c1178067727f12ce4abefa0b93`. +The [physical argument](https://github.com/CrocSwap/integer-mult-bounds/blob/e29a5ae8591243c1178067727f12ce4abefa0b93/research/cf6a-banked-role1256-relay/PHYSICAL.md) +and [physical engine](https://github.com/CrocSwap/integer-mult-bounds/blob/e29a5ae8591243c1178067727f12ce4abefa0b93/research/cf6a-banked-role1256-relay/physical.py) +are material dependencies. The engine is copied unchanged through PR #7713. +The original hard-coded 1501-field reader is not called. common.py checks +the actual 1470-field namespace before it calls the generic engine functions. +No frozen source check is patched or disabled. + +DreamingOfClouds supplied the literal split witnesses in +[PR #7712](https://github.com/CrocSwap/integer-mult-bounds/pull/7712), +head `5001d95a5c1decfb2b0d64d13c130300797e722a`, with Claude Opus 5.5 assistance. +Clear1nsight supplied the causal split method. SYLforge supplied the word +and caller in [PR #7700](https://github.com/CrocSwap/integer-mult-bounds/pull/7700). +Rohan Arun supplied the caller lineage. Jerry Chen / CubeJerry supplied the +selected complex and BIT application. Douglas Colkitt and the credited +contributors supplied the framework, compiler and exact comparison tools. +Retain mightyOil's concave comparison credit. + +The base [shared-wire notice](https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/shared-wire-split-composition/NOTICE) +credits DreamingOfClouds, Ali Romman and Jerry Chen / CubeJerry for the +retained operator engines and their extensions. It also credits unpaidmoon +for the phase convention and icekylinx for the odd-grid precedent. +All copied notices retain their source bytes. SOURCE-PINS.json gives their +Git blobs and SHA-256 values. SOURCES.json pins the four base inputs and +the selected record; it does not claim that pending dependencies are ancestors. diff --git a/research/interleaved-basis-residual-audit/retained/source/data/BASE-GRAPH.json.gz b/research/interleaved-basis-residual-audit/retained/source/data/BASE-GRAPH.json.gz new file mode 100644 index 0000000000..9b797d5100 Binary files /dev/null and b/research/interleaved-basis-residual-audit/retained/source/data/BASE-GRAPH.json.gz differ diff --git a/research/interleaved-basis-residual-audit/retained/source/data/BASE-INTERFACE.json b/research/interleaved-basis-residual-audit/retained/source/data/BASE-INTERFACE.json new file mode 100644 index 0000000000..aae538bb9d --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/data/BASE-INTERFACE.json @@ -0,0 +1,2282 @@ +{ + "keep": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 260, + 261, + 262, + 263, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 309, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 325, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 407, + 408, + 409, + 410, + 411, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 455, + 456, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 556, + 557, + 558, + 560, + 561, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591, + 592, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607, + 608, + 609, + 610, + 611, + 612, + 613, + 614, + 615, + 616, + 617, + 618, + 619, + 620, + 621, + 622, + 623, + 624, + 625, + 626, + 627, + 628, + 629, + 630, + 631, + 632, + 633, + 634, + 635, + 636, + 637, + 638, + 639, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 648, + 649, + 650, + 653, + 654, + 655, + 656, + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670, + 671, + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718, + 719, + 720, + 721, + 722, + 723, + 724, + 725, + 726, + 727, + 728, + 729, + 730, + 731, + 732, + 733, + 734, + 735, + 736, + 737, + 738, + 739, + 740, + 741, + 742, + 743, + 744, + 745, + 746, + 747, + 748, + 749, + 750, + 751, + 752, + 753, + 754, + 755, + 756, + 757, + 758, + 759, + 760, + 761, + 762, + 763, + 764, + 765, + 766, + 767, + 768, + 769, + 770, + 771, + 772, + 773, + 774, + 775, + 776, + 777, + 778, + 779, + 780, + 781, + 782, + 783, + 784, + 785, + 786, + 787, + 788, + 789, + 790, + 791, + 792, + 793, + 794, + 795, + 796, + 797, + 798, + 799, + 800, + 801, + 802, + 803, + 804, + 805, + 806, + 807, + 808, + 809, + 810, + 811, + 812, + 813, + 814, + 815, + 816, + 817, + 818, + 819, + 820, + 821, + 822, + 823, + 824, + 825, + 826, + 827, + 828, + 829, + 830, + 832, + 833, + 834, + 835, + 836, + 837, + 838, + 839, + 840, + 841, + 842, + 843, + 844, + 845, + 846, + 847, + 848, + 849, + 850, + 851, + 852, + 853, + 854, + 855, + 856, + 857, + 858, + 859, + 860, + 861, + 862, + 863, + 864, + 865, + 866, + 867, + 868, + 869, + 870, + 871, + 872, + 873, + 874, + 875, + 876, + 877, + 878, + 879, + 880, + 881, + 882, + 883, + 884, + 885, + 886, + 887, + 888, + 889, + 890, + 891, + 892, + 893, + 894, + 895, + 896, + 897, + 898, + 899, + 900, + 901, + 902, + 903, + 904, + 905, + 906, + 907, + 908, + 909, + 910, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 918, + 919, + 920, + 921, + 922, + 923, + 924, + 925, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 933, + 934, + 935, + 936, + 937, + 938, + 939, + 940, + 941, + 942, + 943, + 944, + 945, + 946, + 947, + 948, + 949, + 950, + 951, + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967, + 968, + 969, + 970, + 971, + 972, + 973, + 974, + 975, + 976, + 977, + 978, + 979, + 980, + 981, + 982, + 983, + 984, + 985, + 986, + 987, + 988, + 989, + 990, + 991, + 992, + 993, + 994, + 995, + 996, + 997, + 998, + 999, + 1000, + 1001, + 1002, + 1003, + 1004, + 1005, + 1006, + 1007, + 1008, + 1009, + 1010, + 1011, + 1012, + 1013, + 1014, + 1015, + 1016, + 1017, + 1018, + 1019, + 1020, + 1021, + 1022, + 1023, + 1024, + 1025, + 1026, + 1027, + 1028, + 1029, + 1030, + 1031, + 1032, + 1033, + 1034, + 1035, + 1036, + 1037, + 1038, + 1039, + 1040, + 1041, + 1042, + 1043, + 1044, + 1045, + 1046, + 1047, + 1048, + 1049, + 1050, + 1051, + 1052, + 1053, + 1054, + 1055, + 1056, + 1057, + 1058, + 1059, + 1060, + 1061, + 1062, + 1063, + 1064, + 1065, + 1066, + 1067, + 1068, + 1069, + 1070, + 1071, + 1072, + 1073, + 1074, + 1075, + 1076, + 1077, + 1078, + 1079, + 1080, + 1081, + 1082, + 1083, + 1084, + 1085, + 1086, + 1087, + 1088, + 1089, + 1090, + 1091, + 1092, + 1093, + 1094, + 1095, + 1096, + 1097, + 1098, + 1099, + 1100, + 1101, + 1102, + 1103, + 1104, + 1105, + 1106, + 1107, + 1108, + 1109, + 1110, + 1111, + 1112, + 1113, + 1114, + 1115, + 1116, + 1117, + 1118, + 1119, + 1120, + 1121, + 1122, + 1123, + 1124, + 1125, + 1126, + 1127, + 1128, + 1129, + 1130, + 1131, + 1132, + 1133, + 1134, + 1135, + 1136, + 1137, + 1138, + 1139, + 1140, + 1141, + 1142, + 1143, + 1144, + 1145, + 1146, + 1147, + 1148, + 1149, + 1150, + 1151, + 1152, + 1153, + 1154, + 1155, + 1156, + 1157, + 1158, + 1159, + 1160, + 1161, + 1162, + 1163, + 1164, + 1165, + 1166, + 1167, + 1168, + 1169, + 1170, + 1171, + 1172, + 1173, + 1174, + 1175, + 1176, + 1177, + 1178, + 1179, + 1180, + 1181, + 1182, + 1183, + 1184, + 1185, + 1186, + 1187, + 1188, + 1189, + 1190, + 1191, + 1192, + 1193, + 1194, + 1195, + 1196, + 1197, + 1198, + 1199, + 1200, + 1201, + 1202, + 1203, + 1204, + 1205, + 1206, + 1207, + 1208, + 1209, + 1210, + 1211, + 1212, + 1213, + 1214, + 1215, + 1216, + 1217, + 1218, + 1219, + 1220, + 1221, + 1222, + 1223, + 1224, + 1225, + 1226, + 1227, + 1228, + 1229, + 1230, + 1231, + 1232, + 1233, + 1234, + 1235, + 1236, + 1237, + 1238, + 1239, + 1240, + 1241, + 1242, + 1243, + 1244, + 1245, + 1246, + 1247, + 1248, + 1249, + 1250, + 1251, + 1252, + 1253, + 1254, + 1255, + 1256, + 1257, + 1258, + 1259, + 1260, + 1261, + 1262, + 1263, + 1264, + 1265, + 1266, + 1267, + 1268, + 1269, + 1270, + 1271, + 1272, + 1273, + 1274, + 1275, + 1276, + 1277, + 1278, + 1279, + 1280, + 1281, + 1282, + 1283, + 1284, + 1285, + 1286, + 1287, + 1288, + 1289, + 1290, + 1291, + 1292, + 1293, + 1294, + 1295, + 1296, + 1297, + 1298, + 1299, + 1300, + 1301, + 1302, + 1303, + 1304, + 1305, + 1306, + 1307, + 1308, + 1309, + 1310, + 1311, + 1312, + 1313, + 1314, + 1315, + 1316, + 1317, + 1318, + 1319, + 1320, + 1321, + 1322, + 1323, + 1324, + 1325, + 1326, + 1327, + 1328, + 1329, + 1330, + 1331, + 1332, + 1333, + 1334, + 1335, + 1336, + 1337, + 1338, + 1339, + 1340, + 1341, + 1342, + 1343, + 1344, + 1345, + 1346, + 1347, + 1348, + 1349, + 1350, + 1351, + 1352, + 1353, + 1354, + 1355, + 1356, + 1357, + 1358, + 1359, + 1362, + 1363, + 1364, + 1365, + 1366, + 1367, + 1368, + 1369, + 1370, + 1371, + 1372, + 1373, + 1374, + 1375, + 1376, + 1377, + 1378, + 1379, + 1380, + 1381, + 1382, + 1383, + 1384, + 1385, + 1386, + 1387, + 1388, + 1389, + 1390, + 1391, + 1392, + 1393, + 1394, + 1396, + 1397, + 1400, + 1401, + 1403, + 1406, + 1408, + 1409, + 1411, + 1412, + 1413, + 1414, + 1415, + 1416, + 1417, + 1418, + 1419, + 1420, + 1421, + 1422, + 1423, + 1424, + 1425, + 1426, + 1427, + 1428, + 1429, + 1430, + 1431, + 1432, + 1437, + 1438, + 1439, + 1440, + 1441, + 1442, + 1443, + 1444, + 1445, + 1446, + 1447, + 1448, + 1449, + 1450, + 1451, + 1452, + 1453, + 1454, + 1455, + 1456, + 1457, + 1458, + 1459, + 1460, + 1461, + 1462, + 1463, + 1464, + 1465, + 1466, + 1467, + 1468, + 1469, + 1470, + 1471, + 1472, + 1473, + 1474, + 1475, + 1476, + 1477, + 1478, + 1479, + 1480, + 1481, + 1482, + 1483, + 1484, + 1485, + 1486, + 1487, + 1488, + 1489, + 1490, + 1491, + 1492, + 1493, + 1494, + 1495, + 1496, + 1497, + 1498, + 1499, + 1500 + ], + "main_roles": [ + 0, + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 15, + 16, + 17, + 18, + 19, + 20, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 35, + 36, + 37, + 38, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 127, + 128, + 129, + 130, + 131, + 132, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 147, + 148, + 149, + 150, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 754, + 755, + 756, + 758, + 759, + 760, + 761, + 762, + 763, + 764, + 765, + 766, + 767, + 769, + 770, + 772, + 774, + 776, + 777, + 778, + 779, + 780, + 781, + 782, + 783, + 785, + 786, + 787, + 789, + 790, + 791, + 795, + 796, + 797, + 798, + 799, + 800, + 801, + 802, + 803, + 804, + 805, + 806, + 807, + 808, + 809, + 810, + 811, + 813, + 814, + 815, + 816, + 817, + 818, + 819, + 820, + 821, + 822, + 823, + 824, + 825, + 826, + 828, + 829, + 830, + 831, + 832, + 833, + 834, + 835, + 836, + 837, + 838, + 839, + 840, + 841, + 842, + 843, + 845, + 846, + 847, + 848, + 849, + 850, + 851, + 852, + 853, + 854, + 855, + 856, + 857, + 858, + 859, + 860, + 861, + 862, + 863, + 864, + 865, + 867, + 868, + 869, + 870, + 871, + 872, + 873, + 874, + 875, + 876, + 878, + 879, + 880, + 881, + 883, + 884, + 885, + 886, + 887, + 888, + 889, + 890, + 891, + 892, + 893, + 895, + 896, + 897, + 899, + 900, + 901, + 902, + 903, + 904, + 906, + 907, + 908, + 909, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 919, + 920, + 921, + 922, + 923, + 924, + 925, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 934, + 935, + 936, + 937, + 938, + 939, + 940, + 941, + 942, + 943, + 944, + 945, + 946, + 947, + 948, + 949, + 951, + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967, + 968 + ], + "live": [ + 0, + 1, + 2, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 15, + 16, + 17, + 18, + 19, + 20, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 35, + 36, + 37, + 38, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111 + ], + "hosted": { + "Dports": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 16, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 28, + 29, + 30, + 31, + 32, + 33, + 36, + 37, + 38, + 39, + 40, + 41, + 43, + 44, + 45, + 46, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103 + ], + "X2": [ + 754, + 755, + 756, + 758, + 759, + 760, + 761, + 762, + 763, + 764, + 765, + 766, + 767, + 769, + 770, + 772, + 774, + 776, + 777, + 778, + 779, + 780, + 781, + 782, + 783, + 785, + 786, + 787, + 789, + 790, + 791, + 795, + 796, + 797, + 798, + 799, + 800, + 801, + 802, + 803, + 804, + 805, + 806, + 807, + 808, + 809, + 810, + 811, + 813, + 814, + 815, + 816, + 817, + 818, + 819, + 820, + 821, + 822, + 823, + 824, + 825, + 826, + 828, + 829, + 830, + 831, + 832, + 833, + 834, + 835, + 836, + 837, + 838, + 839, + 840, + 841, + 842, + 843, + 845, + 846, + 847, + 848, + 849, + 850, + 851, + 852, + 853, + 854, + 855, + 856, + 857, + 858, + 859, + 860, + 861, + 862 + ], + "Y2": [ + 863, + 864, + 865, + 867, + 868, + 869, + 870, + 871, + 872, + 873, + 874, + 875, + 876, + 878, + 879, + 880, + 881, + 883, + 884, + 885, + 886, + 887, + 888, + 889, + 890, + 891, + 892, + 893, + 895, + 896, + 897, + 899, + 900, + 901, + 902, + 903, + 904, + 906, + 907, + 908, + 909, + 911, + 912, + 913, + 914, + 915, + 916, + 917, + 919, + 920, + 921, + 922, + 923, + 924, + 925, + 926, + 927, + 928, + 929, + 930, + 931, + 932, + 934, + 935, + 936, + 937, + 938, + 939, + 940, + 941, + 942, + 943, + 944, + 945, + 946, + 947, + 948, + 949, + 951, + 952, + 953, + 954, + 955, + 956, + 957, + 958, + 959, + 960, + 961, + 962, + 963, + 964, + 965, + 966, + 967, + 968 + ], + "alpha": "-1", + "alpha2": "-1", + "beta": "1/2", + "beta2": "0", + "mode": "mix-t0" + }, + "public": 1468 +} diff --git a/research/interleaved-basis-residual-audit/retained/source/data/CALLER-PHASE-BASES.json b/research/interleaved-basis-residual-audit/retained/source/data/CALLER-PHASE-BASES.json new file mode 100644 index 0000000000..3e4aa383a5 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/data/CALLER-PHASE-BASES.json @@ -0,0 +1 @@ +{"by_q":{"100":[2,97,8,16,69,37,128,256],"11":[13,14,7,16,32,64,128,256],"112":[2,4,8,97,81,49,128,256],"13":[14,11,7,16,32,64,128,256],"131":[133,134,8,16,32,64,7,256],"133":[134,131,8,16,32,64,7,256],"134":[133,131,8,16,32,64,7,256],"138":[137,4,131,16,32,64,11,256],"14":[13,11,7,16,32,64,128,256],"140":[2,137,133,16,32,64,13,256],"145":[146,4,8,131,32,64,19,256],"146":[145,4,8,131,32,64,19,256],"148":[2,145,8,133,32,64,21,256],"152":[2,4,145,137,32,64,25,256],"161":[162,4,8,16,131,64,35,256],"164":[2,161,8,16,133,64,37,256],"168":[2,4,161,16,137,64,41,256],"176":[2,4,8,161,145,64,49,256],"19":[21,22,8,7,32,64,128,256],"191":[253,251,247,239,223,254,127,256],"193":[194,4,8,16,32,131,67,256],"194":[193,4,8,16,32,131,67,256],"196":[2,193,8,16,32,133,69,256],"200":[2,4,193,16,32,137,73,256],"208":[2,4,8,193,32,145,81,256],"21":[22,19,8,7,32,64,128,256],"22":[21,19,8,7,32,64,128,256],"223":[253,251,247,239,254,191,127,256],"224":[2,4,8,16,193,161,97,256],"239":[253,251,247,254,223,191,127,256],"247":[253,251,254,239,223,191,127,256],"251":[253,254,247,239,223,191,127,256],"253":[254,251,247,239,223,191,127,256],"254":[253,251,247,239,223,191,127,256],"259":[261,262,8,16,32,64,128,7],"26":[25,4,19,11,32,64,128,256],"261":[262,259,8,16,32,64,128,7],"262":[261,259,8,16,32,64,128,7],"265":[266,4,259,16,32,64,128,11],"268":[2,265,261,16,32,64,128,13],"273":[274,4,8,259,32,64,128,19],"274":[273,4,8,259,32,64,128,19],"276":[2,273,8,261,32,64,128,21],"28":[2,25,21,13,32,64,128,256],"280":[2,4,273,265,32,64,128,25],"290":[289,4,8,16,259,64,128,35],"292":[2,289,8,16,261,64,128,37],"296":[2,4,289,16,265,64,128,41],"304":[2,4,8,289,273,64,128,49],"319":[381,379,375,367,351,382,128,127],"321":[322,4,8,16,32,259,128,67],"322":[321,4,8,16,32,259,128,67],"324":[2,321,8,16,32,261,128,69],"328":[2,4,321,16,32,265,128,73],"336":[2,4,8,321,32,273,128,81],"35":[37,38,8,16,7,64,128,256],"351":[381,379,375,367,382,319,128,127],"352":[2,4,8,16,321,289,128,97],"367":[381,379,375,382,351,319,128,127],"37":[38,35,8,16,7,64,128,256],"375":[381,379,382,367,351,319,128,127],"379":[381,382,375,367,351,319,128,127],"38":[37,35,8,16,7,64,128,256],"381":[382,379,375,367,351,319,128,127],"382":[381,379,375,367,351,319,128,127],"385":[386,4,8,16,32,64,259,131],"386":[385,4,8,16,32,64,259,131],"388":[2,385,8,16,32,64,261,133],"392":[2,4,385,16,32,64,265,137],"400":[2,4,8,385,32,64,273,145],"41":[42,4,35,16,11,64,128,256],"415":[445,443,439,431,446,64,319,191],"416":[2,4,8,16,385,64,289,161],"431":[445,443,439,446,415,64,319,191],"439":[445,443,446,431,415,64,319,191],"44":[2,41,37,16,13,64,128,256],"443":[445,446,439,431,415,64,319,191],"445":[446,443,439,431,415,64,319,191],"446":[445,443,439,431,415,64,319,191],"463":[477,475,471,478,32,415,351,223],"471":[477,475,478,463,32,415,351,223],"475":[477,478,471,463,32,415,351,223],"477":[478,475,471,463,32,415,351,223],"478":[477,475,471,463,32,415,351,223],"487":[493,491,494,16,463,431,367,239],"49":[50,4,8,35,19,64,128,256],"493":[494,491,487,16,463,431,367,239],"494":[493,491,487,16,463,431,367,239],"499":[501,502,8,487,471,439,375,247],"50":[49,4,8,35,19,64,128,256],"501":[502,499,8,487,471,439,375,247],"502":[501,499,8,487,471,439,375,247],"505":[506,4,499,491,475,443,379,251],"506":[505,4,499,491,475,443,379,251],"508":[2,505,501,493,477,445,381,253],"56":[2,4,49,41,25,64,128,256],"69":[70,67,8,16,32,7,128,256],"70":[69,67,8,16,32,7,128,256],"73":[74,4,67,16,32,11,128,256],"74":[73,4,67,16,32,11,128,256],"81":[82,4,8,67,32,19,128,256],"84":[2,81,8,69,32,21,128,256],"88":[2,4,81,73,32,25,128,256],"98":[97,4,8,16,67,35,128,256]},"full_phase_table_sha256":"c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa"} diff --git a/research/interleaved-basis-residual-audit/retained/source/data/CALLER.json.gz b/research/interleaved-basis-residual-audit/retained/source/data/CALLER.json.gz new file mode 100644 index 0000000000..26a75a1ae3 Binary files /dev/null and b/research/interleaved-basis-residual-audit/retained/source/data/CALLER.json.gz differ diff --git a/research/interleaved-basis-residual-audit/retained/source/data/COMPARATOR-APPLICATION.json b/research/interleaved-basis-residual-audit/retained/source/data/COMPARATOR-APPLICATION.json new file mode 100644 index 0000000000..197c3a8a09 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/data/COMPARATOR-APPLICATION.json @@ -0,0 +1,662 @@ +{ + "claim": "0.00376313686053", + "probe": "0.00376313686060", + "bracket": [ + "0.00376313686061", + "0.00376313686062" + ], + "previous_upper": "0.00376154487712", + "gain_over_previous_upper": "159198341/100000000000000", + "graph_sha256": "5183479ecac34a1cb5c046f202e19d7161679265fe121b4a0af922fe344d8fc1", + "stages": [ + [ + 1, + 400, + 1070 + ], + [ + 2, + 400, + 1070 + ], + [ + 3, + 400, + 1070 + ], + [ + 4, + 400, + 1070 + ], + [ + 5, + 400, + 1070 + ], + [ + 6, + 400, + 1070 + ], + [ + 7, + 400, + 1070 + ], + [ + 8, + 400, + 1070 + ], + [ + 9, + 400, + 1070 + ], + [ + 10, + 400, + 1070 + ], + [ + 11, + 400, + 1070 + ], + [ + 12, + 400, + 1070 + ], + [ + 13, + 400, + 1070 + ], + [ + 14, + 400, + 1070 + ], + [ + 15, + 400, + 1070 + ], + [ + 16, + 400, + 1070 + ] + ], + "owner_alias_rejected": true, + "caller": { + "fixed_caller_paid": { + "8": 640, + "9": 32, + "56": 416, + "48": 416, + "40": 416, + "32": 416, + "24": 416, + "16": 416, + "1": 384 + }, + "fixed_root_targets": { + "129": 208, + "65": 416, + "57": 416, + "49": 416, + "41": 416, + "33": 416, + "25": 416, + "17": 416, + "9": 416 + }, + "uses": { + "ADD": 92400, + "SCALE": 11728, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "IDLE_ODD": 32, + "SWAP": 240, + "QUERY": 384 + }, + "calls": 16, + "roles": 68, + "root_owners": 3536, + "dyadic_height": 9, + "odd_scale": 2025, + "peak_scaled_mass": "495734175/2", + "peak_witness": [ + 1196, + "stored sum" + ], + "exact_preproduct_divisions": 153295 + }, + "paid": 100416, + "productive": 20656, + "invoice": { + "schema": "integer-mult-recursive-invoice/v1", + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "paid": { + "1": 63328, + "2": 13552, + "3": 9024, + "4": 3568, + "5": 5904, + "6": 1536, + "7": 160, + "8": 752, + "9": 96, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416 + }, + "targets": { + "1": 304, + "2": 336, + "3": 752, + "4": 3616, + "5": 1184, + "6": 400, + "7": 256, + "8": 528, + "9": 10160, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "129": 208 + } + }, + "comparison": { + "schema": "integer-mult-recursive-invoice-comparison/v1", + "classification": "uniformly_better", + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "delta_paid": {}, + "delta_targets": { + "1": 16, + "4": 16, + "5": 16, + "8": 16, + "9": -32 + }, + "signed_net_delta": { + "1": -16, + "4": -16, + "5": -16, + "8": -16, + "9": 32 + }, + "hinges": [ + { + "rank": 0, + "value": 0 + }, + { + "rank": 1, + "value": -32 + }, + { + "rank": 4, + "value": -80 + }, + { + "rank": 5, + "value": -80 + }, + { + "rank": 8, + "value": -32 + }, + { + "rank": 9, + "value": 0 + } + ], + "rank_mass": { + "old": { + "paid": 268368, + "targets": 269696, + "paid_minus_targets": -1328 + }, + "new": { + "paid": 268368, + "targets": 269696, + "paid_minus_targets": -1328 + }, + "delta": { + "paid": 0, + "targets": 0, + "paid_minus_targets": 0 + } + }, + "quantity": "(new paid - new targets) - (old paid - old targets)", + "tariff_class": "increasing concave f on nonnegative ranks, with f(0)=0", + "uniform_order": "weak; some concave tariffs can give equality", + "power_moment": { + "tariff": "r^t", + "exponent": "0 < t < 1", + "new_minus_old_sign": "strictly_negative" + }, + "assurance": { + "contract": "Exact matching user declarations; mathematical applicability is not verified.", + "input_binding": "SHA-256 identifies the exact input bytes read, when loaded by this CLI.", + "scope": "Histogram arithmetic only. Histogram correctness, circuit legality, ownership, phases, precision, supplier admission and compiler endpoints are not validated.", + "inconclusive": "Mixed hinge signs do not establish a power-moment crossing or failure." + }, + "method_credit": "Classical concave order/majorization; mightyOil's t16-moment-order-audit and its retained predecessors. No new theorem claim." + }, + "powers": [ + { + "graph": "parent", + "kappa": "0.00376154487712", + "paid_minus_productive": { + "lower": "23790951429644132432384771249536720596097410269015464642295605017809/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "11895475714822066216192385624768360298048705134507732321147806445843/3618502788666131106986593281521497120414687020801267626233049500247285301248" + } + }, + { + "graph": "candidate", + "kappa": "0.00376154487712", + "paid_minus_productive": { + "lower": "-2017236434193873650985584391338189761824009530847244098431260572729477644953/3618502788666131106986593281521497120414687020801267626233049500247285301248", + "upper": "-4034472868387747301971168782676379523648019061694488196862521145458947424359/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00376313686053", + "paid_minus_productive": { + "lower": "-207542879684415947245599103135760542034904404612128611395239845978385/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-1621428747534499587856242993248129234647690661032254776525311244531/56539106072908298546665520023773392506479484700019806659891398441363832832" + } + }, + { + "graph": "candidate", + "kappa": "0.00376313686060", + "paid_minus_productive": { + "lower": "-15073228127183160486989542033465530395749927754763834164794178190015/3618502788666131106986593281521497120414687020801267626233049500247285301248", + "upper": "-15073228127183160486989542033465530395749927754763834164794174531331/3618502788666131106986593281521497120414687020801267626233049500247285301248" + } + }, + { + "graph": "candidate", + "kappa": "0.00376313686061", + "paid_minus_productive": { + "lower": "-4804110050077680095326468320601703804309777403442510524505347802565/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-600513756259710011915808540075212975538722175430313815563167633745/904625697166532776746648320380374280103671755200316906558262375061821325312" + } + }, + { + "graph": "candidate", + "kappa": "0.00376313686062", + "paid_minus_productive": { + "lower": "20538236154209920064717157952839541301037251126476494157232824160121/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "20538236154209920064717157952839541301037251126476494157232830247213/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + } + ], + "compiler": { + "claim": "376313686053/100000000000000", + "tested": "18815684303/5000000000000", + "raw_bracket": [ + "376313686061/100000000000000", + "188156843031/50000000000000" + ], + "moment_margins": { + "376313686061/100000000000000": [ + "2074455207484702926030112137700139910023177074797145346620054202804213/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "4148910414969405852060224275400279820046354149594290693240108407808079/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "188156843031/50000000000000": [ + "-8868583462604578427582733417494336221187339122320071674345030899756089/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "-17737166925209156855165466834988672442374678244640143348690061797302833/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "18815684303/5000000000000": [ + "26034987755148867341418481037425381630793778515043517569472138750598191/6250000000000000000000000000000000000000000000000000000000000000000000000000000", + "26034987755148867341418481037425381630793778515043517569472138752812859/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "moment_margin_float": { + "376313686061/100000000000000": [ + 6.638256663951049e-10, + 6.638256663951049e-10 + ], + "188156843031/50000000000000": [ + -2.837946708033465e-09, + -2.837946708033465e-09 + ], + "18815684303/5000000000000": [ + 4.165598040823819e-09, + 4.165598040823819e-09 + ] + }, + "derivative_upper": -345126.2373073017, + "alpha": [ + 0.9999999999999843, + 0.9999999999999843 + ], + "gamma": [ + 0.9350934678096133, + 0.9350934678096133 + ], + "delta": [ + 0.9214681586687725, + 0.9214681586687725 + ], + "minimum_log_power": 2309, + "written_log_power": 2310, + "compiler_gap": "1/100000000000000", + "H": "14708600000000000000", + "BIT_pin": "376669/100000000", + "BIT_margin": "17765697/5000000000000", + "outer": { + "strict_count": 54, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "BIT_just_below_effective_rejected": true + }, + "input_lift": { + "margins": { + "376313686053/100000000000000": [ + "128212819437215132785375491472764766869508245223834092678152280014785772545853/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "128212819437215132785375491472764766869508245223834092678152280014785772547813/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "18815684303/5000000000000": [ + "64106409719747457611963813428072613555135046186112831880468485065975180592871/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1001662651871054025186934584813634586798985096658012998132320079155862196779/781250000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "interval_kappa_cap": "376669/100000000", + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + } + }, + "conditional_interfaces": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "physical": { + "native": { + "public": 1470, + "slots": 6054, + "terms": 178845, + "path_grid": 2184944025600, + "path_grid_odd": 2083725, + "path_grid_height": 20, + "positive_path_mass_bound_unscaled": "164863744927/4608", + "positive_path_mass_peak_node": 156119, + "paid_native_ranks": { + "1": 3934, + "2": 847, + "4": 223, + "3": 564, + "5": 369, + "6": 96, + "9": 4, + "7": 10, + "8": 7 + }, + "positive_helper_ranks": { + "9": 609, + "2": 21, + "4": 226, + "8": 33, + "7": 16, + "3": 47, + "1": 19, + "6": 25, + "5": 74 + }, + "coefficient_products": 9966426, + "checked_nontrivial_divisions": 5312755, + "checked_nontrivial_divisions_by_denominator": { + "3": 71276, + "4": 1775911, + "12": 4443, + "2": 2530408, + "8": 439428, + "21": 15307, + "256": 22, + "16": 144485, + "32": 45118, + "64": 20651, + "128": 732, + "10": 6742, + "5": 50696, + "20": 15512, + "7": 102347, + "96": 172, + "48": 439, + "24": 6804, + "384": 6, + "6": 25853, + "192": 58, + "14": 29488, + "9": 17, + "40": 660, + "28": 14857, + "56": 6793, + "63": 394, + "42": 1203, + "112": 2124, + "224": 809 + }, + "exact_all_public_rows": 1470, + "minimum_product_grid": 90316800, + "minimum_snapshot_grid": 322560, + "maximum_exact_row_prefix_mass_scaled": "465156710107425/256", + "missing_odd_factor_controls": { + "3": { + "row": 88440, + "donor": -1325, + "entrance_column": 1324, + "coefficient": "2/3", + "removed_factor": 243, + "numerator_without_factor": 17983078400, + "denominator": 3, + "positive_remainder": 2 + }, + "5": { + "row": 88808, + "donor": -1301, + "entrance_column": 1300, + "coefficient": "1/10", + "removed_factor": 25, + "numerator_without_factor": 87397761024, + "denominator": 10, + "positive_remainder": 4 + } + }, + "numerical_homes": 8999, + "guarded_dummy_slots": 1, + "separate_guide_tracks": 1, + "max_outstanding_native_senders": 1, + "declared_senders": 1, + "immutable_entry_banks": 1470, + "immutable_paid_return_banks": 6054, + "deferred_terminal_banks": 1470, + "native_scalar_scratch_homes": 4, + "additional_independent_guarded_streams": 4, + "trace_sha256": "7c0449f16fe3dfcfd78b14f3e7a58c43ea119241d522acc4f9b7e3cfc164b38e", + "selected_logical_operations": { + "initialize_complete_dirty_home": 8999, + "write_entrance": 1470, + "read_immutable_donor": 178845, + "initialize_empty_sender_before_departure": 6054, + "stage_full_sender": 6054, + "read_parked_sender": 6054, + "write_complete_return": 6054, + "clear_full_sender_after_return": 6054, + "write_terminal": 1470, + "read_terminal_for_same_owner_install": 1470, + "retire_complete_home": 8999 + }, + "fixture_addressed_cells_per_home": 4, + "fixture_addressed_cells_overwritten": { + "initialize_complete_dirty_home": 35996, + "initialize_empty_sender_before_departure": 24216, + "clear_full_sender_after_return": 24216, + "retire_complete_home": 35996 + }, + "tracked_stream_reset_visits": 544059, + "same_owner_complete_fixture_outputs": 1470, + "exact_odd_unscale_outputs": 1470, + "retired_and_guards_restored": true, + "live_sender_alias_control_rejected": true, + "all_public_inputs_preserved_until_final_installs": true + }, + "caller_envelope": { + "records": 4192, + "stages": 16, + "uses": { + "ADD": 92400, + "SCALE": 11728, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "IDLE_ODD": 32, + "SWAP": 240, + "QUERY": 384 + }, + "binary_height_at_all_completed_cuts_and_products": 325, + "binary_height_at_native_entrances": 318, + "scaled_mass_at_all_cuts_and_products": "422697641667541055184649383436611894902745135854144098178147008285122975926924780864462653005878076090749928607858304935653611344748944586891405006118422035825340979484130265226717/787320000000000", + "scaled_mass_at_native_entrances": "841540548201148271304709423731170105326708333407364819898222426096105903810343041288214438457604474421941928920227707368470121101079538458948446020268383922323667853993448395617/100776960000000", + "normalized_bound_uses_no_cancellation_or_commutation": true + }, + "common_root": { + "caller_odd": 2025, + "native_odd": { + "candidate": 2083725 + }, + "native_binary": { + "candidate": 20 + }, + "context_mass_bound": "47587657515536117050088106519258994580293747171033193792670305801720492655022147042355197832891493877471654969938199350475235561468207852602392400007694405834999596668034956636079496165240937/76441190400000", + "context_mass_bits": 588, + "context_binary_bits": 338, + "context_c": 1176, + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "exact_grid": "2^(-p-D)", + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "depth_guard": { + "compiler_H": 14708600000000000000, + "argument_bit_length": 14083, + "strict_guard_passed": true + }, + "ordinary": { + "native_numeric_homes": 8999, + "native_numeric_homes_plus_dummy": 9000, + "raw_numeric_homes": 143984, + "raw_numeric_homes_plus_dummy": 144000, + "separate_guarded_guide_tracks_per_native": 1, + "separate_guarded_guide_tracks_raw": 16, + "separate_guarded_streams_per_native": 4, + "separate_guarded_streams_raw": 64, + "odd_conversions": 54112, + "reset_services_per_native": 1526938, + "typed_selected_transfers_per_native": 414942, + "reset_services_by_kind_per_native": { + "dirty_home_initializations_and_retirements": 17998, + "term_and_row_stream_initializations_and_retirements": 1490952, + "owner_scale_unscale_stream_initializations_and_retirements": 5880, + "sender_reinitializations_and_retirements": 12108 + }, + "typed_transfer_legs_by_kind_per_native": { + "complete_scalar_donor_staging_legs": 357690, + "complete_sender_and_terminal_staging_legs": 15048, + "paid_parked_sender_return_and_adapter_legs": 36324, + "immutable_entrance_and_public_terminal_install_legs": 5880 + }, + "reset_services_all_native_stages": 24431008, + "typed_selected_transfer_legs_all_native_stages": 6639072, + "selector_steps_per_selected_service_L_and_constant": [ + 125995, + 567325 + ], + "additional_full_overwrite_steps_per_reset_L_and_constant": [ + 2, + 3 + ], + "selected_total_steps_per_native_L_and_constant": [ + 244723337052, + 1101814433254 + ], + "selected_total_steps_raw_L_and_constant": [ + 3915573392832, + 17629030932064 + ], + "scalar_services": 124816384, + "scalar_step_rate": 536870912, + "raw_scalar_incidence_allowance_before_factor_32": { + "literal_native_products_and_accumulations": 2861520, + "width_padded_native_row_lifecycles": 481536, + "public_boundary_installations_and_scale_preparations": 47040, + "private_home_flags_and_cleanup": 143984, + "serial_sender_initialization_and_retirement": 193728, + "weighted_signed_caller_operation_slots": 118592, + "complete_array_odd_conversions": 54112 + }, + "ordinary_map_slots": 276672, + "ordinary_elementary_record_upper": 26246212608, + "raw_paid_positions": 100416, + "raw_productive_targets": 20656, + "root_negative_q_translations": 3536, + "native_paid_wrappers": 96864, + "native_productive_wrappers": 17120, + "ordinary_main_pair_slots": 6400, + "compiled_ordinary_work": "Full-view resets, selects, copies, guide and layout setup and return, exact scalar and odd conversions, matchers, fixed descriptors, root normalization, and all native, caller and child adapters.", + "compiled_stock": "Disjoint occurrence-tagged bank tuples, dummy origins, guides and four guarded streams per stage; complete public owners, matching child views, compiler and BIT workspace, and every parked ancestor.", + "layout": { + "padded_payload": "L'=N_c(2(W+26)+3)", + "per_stage_selector_and_stream_tracks": 11, + "guide_setup_and_retirement": "q(N_c)+q(W')+22N_cW'+36N_c+7W'+36+7L'+10; q(x)=24x-7popcount(x)+15ell(x)+12; W'=W+26", + "aggregate_owned_tuple_M": "sum_stage[(homes+6)(L'+2)+ell(N_c)+ell(W+26)+max(ell(N_c),ell(W+26),ell(homes))+max(N_c,homes)+max(W+26,ell(homes))+10]", + "shadow_cells_upper": "M+352", + "complete_view_step_bound": "34*(256(M+352)+128) plus fixed-degree descriptor work" + } + }, + "scalars": { + "distinct_scalar_and_conversion_factors": 796, + "signed_bit_transducer_cases": 4776, + "coefficient_bits": 21, + "rejected_one_tick_denominators": [ + 2, + 3, + 5, + 7 + ], + "retained_max_bits": 24, + "component_padding": 26 + }, + "missing_seven_rejected": true, + "partial_clear_control": { + "dirty_unaddressed_last_cell_rejected": true, + "neighbor_unchanged": true + } + } +} diff --git a/research/interleaved-basis-residual-audit/retained/source/data/QUOTIENT-APPLICATION.json b/research/interleaved-basis-residual-audit/retained/source/data/QUOTIENT-APPLICATION.json new file mode 100644 index 0000000000..9a304f165e --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/data/QUOTIENT-APPLICATION.json @@ -0,0 +1,692 @@ +{ + "bracket": [ + "0.00376154487711", + "0.00376154487712" + ], + "caller": { + "calls": 16, + "dyadic_height": 9, + "exact_preproduct_divisions": 153295, + "fixed_caller_paid": { + "1": 384, + "8": 640, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416 + }, + "fixed_root_targets": { + "9": 416, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "129": 208 + }, + "odd_scale": 2025, + "peak_scaled_mass": "495734175/2", + "peak_witness": [ + 1196, + "stored sum" + ], + "roles": 68, + "root_owners": 3536, + "uses": { + "ADD": 92400, + "IDLE_ODD": 32, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "QUERY": 384, + "SCALE": 11728, + "SWAP": 240 + } + }, + "claim": "0.00376154487703", + "comparison": { + "assurance": { + "contract": "Exact matching user declarations; mathematical applicability is not verified.", + "inconclusive": "Mixed hinge signs do not establish a power-moment crossing or failure.", + "input_binding": "SHA-256 identifies the exact input bytes read, when loaded by this CLI.", + "scope": "Histogram arithmetic only. Histogram correctness, circuit legality, ownership, phases, precision, supplier admission and compiler endpoints are not validated." + }, + "classification": "uniformly_better", + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "delta_paid": { + "1": -112, + "2": -400, + "3": -128, + "4": -368, + "6": -32, + "7": -16, + "8": -16 + }, + "delta_targets": { + "4": -64, + "5": -48, + "6": -336, + "7": -16, + "9": -64 + }, + "hinges": [ + { + "rank": 0, + "value": 0 + }, + { + "rank": 1, + "value": -544 + }, + { + "rank": 2, + "value": -976 + }, + { + "rank": 3, + "value": -1008 + }, + { + "rank": 4, + "value": -912 + }, + { + "rank": 5, + "value": -512 + }, + { + "rank": 6, + "value": -160 + }, + { + "rank": 8, + "value": -64 + }, + { + "rank": 9, + "value": 0 + } + ], + "method_credit": "Classical concave order/majorization; mightyOil's t16-moment-order-audit and its retained predecessors. No new theorem claim.", + "power_moment": { + "exponent": "0 < t < 1", + "new_minus_old_sign": "strictly_negative", + "tariff": "r^t" + }, + "quantity": "(new paid - new targets) - (old paid - old targets)", + "rank_mass": { + "delta": { + "paid": -3200, + "paid_minus_targets": 0, + "targets": -3200 + }, + "new": { + "paid": 268368, + "paid_minus_targets": -1328, + "targets": 269696 + }, + "old": { + "paid": 271568, + "paid_minus_targets": -1328, + "targets": 272896 + } + }, + "schema": "integer-mult-recursive-invoice-comparison/v1", + "signed_net_delta": { + "1": -112, + "2": -400, + "3": -128, + "4": -304, + "5": 48, + "6": 304, + "8": -16, + "9": 64 + }, + "tariff_class": "increasing concave f on nonnegative ranks, with f(0)=0", + "uniform_order": "weak; some concave tariffs can give equality" + }, + "compiler": { + "BIT_margin": "51451229/10000000000000", + "BIT_pin": "376669/100000000", + "H": "14702100000000000000", + "alpha": [ + 0.999999999999986, + 0.999999999999986 + ], + "claim": "376154487703/100000000000000", + "compiler_gap": "1/100000000000000", + "delta": [ + 0.9200415493228975, + 0.9200415493228975 + ], + "derivative_upper": -345270.6380636385, + "gamma": [ + 0.9350939354047383, + 0.9350939354047383 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "376154487703/100000000000000": [ + "64080485100555962792983621226274629495298406755783729583670864753877551109189/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "64080485100555962792983621226274629495298406755783729583670864753877551110159/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "37615448771/10000000000000": [ + "2563219404067835931903868746571349042518071830893290743327267150766051326309/2000000000000000000000000000000000000000000000000000000000000000000000000000000", + "25632194040678359319038687465713490425180718308932907433272671507660513263483/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2308, + "moment_margin_float": { + "11754827741/3125000000000": [ + -3.28740266611955e-09, + -3.28740266611955e-09 + ], + "37615448771/10000000000000": [ + 3.7191330334130723e-09, + 3.7191330334130723e-09 + ], + "376154487711/100000000000000": [ + 2.1586518364668925e-10, + 2.1586518364668925e-10 + ] + }, + "moment_margins": { + "11754827741/3125000000000": [ + "-1284141666452949242801091609373630263684786200456304799855949521867033/390625000000000000000000000000000000000000000000000000000000000000000000000000", + "-20546266663247187884817465749978084218956579207300876797695192347691687/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "37615448771/10000000000000": [ + "2324458145883170267549424926837528184125912209298836002315932667143233/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "23244581458831702675494249268375281841259122092988360023159326673641929/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "376154487711/100000000000000": [ + "10793259182334462756927045727188218747153335241112558496112349382829/50000000000000000000000000000000000000000000000000000000000000000000000000000", + "1349157397791807844615880715898527343394166905139069812014043675020283/6250000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "376154487711/100000000000000", + "11754827741/3125000000000" + ], + "tested": "37615448771/10000000000000", + "written_log_power": 2309 + }, + "conditional_interfaces": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "graph_sha256": "16e99893a2c669467ce74f214e8eb5150402f0267aaa8d67aad5d870aa4d5c18", + "invoice": { + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "paid": { + "1": 63328, + "16": 416, + "2": 13552, + "24": 416, + "3": 9024, + "32": 416, + "4": 3568, + "40": 416, + "48": 416, + "5": 5904, + "56": 416, + "6": 1536, + "7": 160, + "8": 752, + "9": 96 + }, + "schema": "integer-mult-recursive-invoice/v1", + "targets": { + "1": 288, + "129": 208, + "17": 416, + "2": 336, + "25": 416, + "3": 752, + "33": 416, + "4": 3600, + "41": 416, + "49": 416, + "5": 1168, + "57": 416, + "6": 400, + "65": 416, + "7": 256, + "8": 512, + "9": 10192 + } + }, + "paid": 100416, + "physical": { + "caller_envelope": { + "binary_height_at_all_completed_cuts_and_products": 325, + "binary_height_at_native_entrances": 318, + "normalized_bound_uses_no_cancellation_or_commutation": true, + "records": 4192, + "scaled_mass_at_all_cuts_and_products": "422697641667541055184649383436611894902745135854144098178147008285122975926924780864462653005878076090749928607858304935653611344748944586891405006118422035825340979484130265226717/787320000000000", + "scaled_mass_at_native_entrances": "841540548201148271304709423731170105326708333407364819898222426096105903810343041288214438457604474421941928920227707368470121101079538458948446020268383922323667853993448395617/100776960000000", + "stages": 16, + "uses": { + "ADD": 92400, + "IDLE_ODD": 32, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "QUERY": 384, + "SCALE": 11728, + "SWAP": 240 + } + }, + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 338, + "context_c": 1156, + "context_mass_bits": 578, + "context_mass_bound": "416715380036824315219915040298752943399161477078092070307084491794718042593361226125944385604717877581940866507651668746128714124462466602310739864261338974719190990312648547518509658974041/687970713600000", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 20 + }, + "native_odd": { + "candidate": 2025 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "depth_guard": { + "argument_bit_length": 14083, + "compiler_H": 14702100000000000000, + "strict_guard_passed": true + }, + "native": { + "additional_independent_guarded_streams": 4, + "all_public_inputs_preserved_until_final_installs": true, + "checked_nontrivial_divisions": 5060996, + "checked_nontrivial_divisions_by_denominator": { + "2": 2495158, + "3": 70007, + "4": 1753529, + "5": 49268, + "6": 25468, + "8": 429044, + "9": 19, + "10": 6541, + "12": 4364, + "16": 141270, + "20": 15192, + "24": 6706, + "32": 43186, + "40": 640, + "48": 435, + "64": 19769, + "96": 172, + "128": 160, + "192": 58, + "256": 4, + "384": 6 + }, + "coefficient_products": 9657314, + "declared_senders": 1, + "deferred_terminal_banks": 1468, + "exact_all_public_rows": 1468, + "exact_odd_unscale_outputs": 1468, + "fixture_addressed_cells_overwritten": { + "clear_full_sender_after_return": 24216, + "initialize_complete_dirty_home": 35980, + "initialize_empty_sender_before_departure": 24216, + "retire_complete_home": 35980 + }, + "fixture_addressed_cells_per_home": 4, + "guarded_dummy_slots": 1, + "immutable_entry_banks": 1468, + "immutable_paid_return_banks": 6054, + "live_sender_alias_control_rejected": true, + "max_outstanding_native_senders": 1, + "maximum_exact_row_prefix_mass_scaled": "14153739525/8", + "minimum_product_grid": 921600, + "minimum_snapshot_grid": 23040, + "missing_odd_factor_controls": { + "3": { + "coefficient": "-2/3", + "denominator": 3, + "donor": -1441, + "entrance_column": 1440, + "numerator_without_factor": -52428800, + "positive_remainder": 1, + "removed_factor": 81, + "row": 88440 + }, + "5": { + "coefficient": "1/10", + "denominator": 10, + "donor": -1301, + "entrance_column": 1300, + "numerator_without_factor": 84934656, + "positive_remainder": 6, + "removed_factor": 25, + "row": 88808 + } + }, + "native_scalar_scratch_homes": 4, + "numerical_homes": 8995, + "paid_native_ranks": { + "1": 3934, + "2": 847, + "3": 564, + "4": 223, + "5": 369, + "6": 96, + "7": 10, + "8": 7, + "9": 4 + }, + "path_grid": 2123366400, + "path_grid_height": 20, + "path_grid_odd": 2025, + "positive_helper_ranks": { + "1": 18, + "2": 21, + "3": 47, + "4": 225, + "5": 73, + "6": 25, + "7": 16, + "8": 32, + "9": 611 + }, + "positive_path_mass_bound_unscaled": "495181582073/13824", + "positive_path_mass_peak_node": 156119, + "public": 1468, + "retired_and_guards_restored": true, + "same_owner_complete_fixture_outputs": 1468, + "selected_logical_operations": { + "clear_full_sender_after_return": 6054, + "initialize_complete_dirty_home": 8995, + "initialize_empty_sender_before_departure": 6054, + "read_immutable_donor": 175927, + "read_parked_sender": 6054, + "read_terminal_for_same_owner_install": 1468, + "retire_complete_home": 8995, + "stage_full_sender": 6054, + "write_complete_return": 6054, + "write_entrance": 1468, + "write_terminal": 1468 + }, + "separate_guide_tracks": 1, + "slots": 6054, + "terms": 175927, + "trace_sha256": "7492aa20328bfbd960b69ec8ab61ad493ef44fd544bc1cacd8efc863cf43423e", + "tracked_stream_reset_visits": 535303 + }, + "ordinary": { + "additional_full_overwrite_steps_per_reset_L_and_constant": [ + 2, + 3 + ], + "compiled_ordinary_work": "Full-view resets, selects, copies, guide and layout setup and return, exact scalar and odd conversions, matchers, fixed descriptors, root normalization, and all native, caller and child adapters.", + "compiled_stock": "Disjoint occurrence-tagged bank tuples, dummy origins, guides and four guarded streams per stage; complete public owners, matching child views, compiler and BIT workspace, and every parked ancestor.", + "layout": { + "aggregate_owned_tuple_M": "sum_stage[(homes+6)(L'+2)+ell(N_c)+ell(W+26)+max(ell(N_c),ell(W+26),ell(homes))+max(N_c,homes)+max(W+26,ell(homes))+10]", + "complete_view_step_bound": "34*(256(M+352)+128) plus fixed-degree descriptor work", + "guide_setup_and_retirement": "q(N_c)+q(W')+22N_cW'+36N_c+7W'+36+7L'+10; q(x)=24x-7popcount(x)+15ell(x)+12; W'=W+26", + "padded_payload": "L'=N_c(2(W+26)+3)", + "per_stage_selector_and_stream_tracks": 11, + "shadow_cells_upper": "M+352" + }, + "native_numeric_homes": 8995, + "native_numeric_homes_plus_dummy": 8996, + "native_paid_wrappers": 96864, + "native_productive_wrappers": 17088, + "odd_conversions": 54048, + "ordinary_elementary_record_upper": 26240141312, + "ordinary_main_pair_slots": 6400, + "ordinary_map_slots": 276608, + "raw_numeric_homes": 143920, + "raw_numeric_homes_plus_dummy": 143936, + "raw_paid_positions": 100416, + "raw_productive_targets": 20624, + "raw_scalar_incidence_allowance_before_factor_32": { + "complete_array_odd_conversions": 54048, + "literal_native_products_and_accumulations": 2814832, + "private_home_flags_and_cleanup": 143920, + "public_boundary_installations_and_scale_preparations": 46976, + "serial_sender_initialization_and_retirement": 193728, + "weighted_signed_caller_operation_slots": 118592, + "width_padded_native_row_lifecycles": 481408 + }, + "reset_services_all_native_stages": 24056992, + "reset_services_by_kind_per_native": { + "dirty_home_initializations_and_retirements": 17990, + "owner_scale_unscale_stream_initializations_and_retirements": 5872, + "sender_reinitializations_and_retirements": 12108, + "term_and_row_stream_initializations_and_retirements": 1467592 + }, + "reset_services_per_native": 1503562, + "root_negative_q_translations": 3536, + "scalar_services": 123312128, + "scalar_step_rate": 2097152, + "selected_total_steps_per_native_L_and_constant": [ + 240933355140, + 1084764385246 + ], + "selected_total_steps_raw_L_and_constant": [ + 3854933682240, + 17356230163936 + ], + "selector_steps_per_selected_service_L_and_constant": [ + 125939, + 567080 + ], + "separate_guarded_guide_tracks_per_native": 1, + "separate_guarded_guide_tracks_raw": 16, + "separate_guarded_streams_per_native": 4, + "separate_guarded_streams_raw": 64, + "typed_selected_transfer_legs_all_native_stages": 6545504, + "typed_selected_transfers_per_native": 409094, + "typed_transfer_legs_by_kind_per_native": { + "complete_scalar_donor_staging_legs": 351854, + "complete_sender_and_terminal_staging_legs": 15044, + "immutable_entrance_and_public_terminal_install_legs": 5872, + "paid_parked_sender_return_and_adapter_legs": 36324 + } + }, + "partial_clear_control": { + "dirty_unaddressed_last_cell_rejected": true, + "neighbor_unchanged": true + }, + "scalars": { + "coefficient_bits": 13, + "component_padding": 26, + "distinct_scalar_and_conversion_factors": 701, + "rejected_one_tick_denominators": [ + 2, + 3, + 5, + 7 + ], + "retained_max_bits": 24, + "signed_bit_transducer_cases": 4206 + } + }, + "powers": [ + { + "graph": "parent", + "kappa": "0.00374039009048", + "paid_minus_productive": { + "lower": "21056569940474835912050381350317462609887671491455495468646402762269/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "21056569940474835912050381350317462609887671491455495468646409735773/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00374039009048", + "paid_minus_productive": { + "lower": "-3352276101566529344104978482430578045392549966786535908230507249454445016561/452312848583266388373324160190187140051835877600158453279131187530910662656", + "upper": "-53636417625064469505679655718889248726280799468584574531688115991271113308169/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00376154487703", + "paid_minus_productive": { + "lower": "-204387569279217027267346082521694874638907706589082198950096824643285/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-25548446159902128408418260315211859329863463323635274868762102171229/904625697166532776746648320380374280103671755200316906558262375061821325312" + } + }, + { + "graph": "candidate", + "kappa": "0.00376154487710", + "paid_minus_productive": { + "lower": "-26915386505651059882455873192235385344039082069475359334769310662759/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-26915386505651059882455873192235385344039082069475359334769303380621/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00376154487711", + "paid_minus_productive": { + "lower": "-195277192250367897607721748048165337515492171394211024496008681885/904625697166532776746648320380374280103671755200316906558262375061821325312", + "upper": "-24409649031295987200965218506020667189436521424276378062000973951/113078212145816597093331040047546785012958969400039613319782796882727665664" + } + }, + { + "graph": "candidate", + "kappa": "0.00376154487712", + "paid_minus_productive": { + "lower": "23790951429644132432384771249536720596097410269015464642295605017809/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "11895475714822066216192385624768360298048705134507732321147806445843/3618502788666131106986593281521497120414687020801267626233049500247285301248" + } + } + ], + "previous_upper": "0.00374039009048", + "probe": "0.00376154487710", + "productive": 20624, + "removed": { + "paid": { + "1": 112, + "2": 400, + "3": 128, + "4": 368, + "6": 32, + "7": 16, + "8": 16 + }, + "targets": { + "4": 64, + "5": 48, + "6": 336, + "7": 16, + "9": 64 + } + }, + "retained_labels_sha256": "13b52c03ecfd1f90793bcf914d61a774b2837c783c502d2b655aca1956a3a027", + "stages": [ + [ + 1, + 400, + 1068 + ], + [ + 2, + 400, + 1068 + ], + [ + 3, + 400, + 1068 + ], + [ + 4, + 400, + 1068 + ], + [ + 5, + 400, + 1068 + ], + [ + 6, + 400, + 1068 + ], + [ + 7, + 400, + 1068 + ], + [ + 8, + 400, + 1068 + ], + [ + 9, + 400, + 1068 + ], + [ + 10, + 400, + 1068 + ], + [ + 11, + 400, + 1068 + ], + [ + 12, + 400, + 1068 + ], + [ + 13, + 400, + 1068 + ], + [ + 14, + 400, + 1068 + ], + [ + 15, + 400, + 1068 + ], + [ + 16, + 400, + 1068 + ] + ] +} diff --git a/research/interleaved-basis-residual-audit/retained/source/data/RESTRICTION-CONTROLS.json b/research/interleaved-basis-residual-audit/retained/source/data/RESTRICTION-CONTROLS.json new file mode 100644 index 0000000000..cf49556bef --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/data/RESTRICTION-CONTROLS.json @@ -0,0 +1,98 @@ +[ + { + "alternative": { + "event": "restrict", + "direction": "forward", + "role": 1400, + "source": [ + [ + -1401, + "1" + ] + ], + "banks": [ + { + "chart": 127, + "remove": 98393, + "relation": [ + [ + 98393, + "-1" + ], + [ + 98395, + "1" + ] + ] + } + ] + }, + "split_role": 294, + "split_chart": 288, + "direction": "forward" + }, + { + "alternative": { + "event": "restrict", + "direction": "transpose", + "role": 1401, + "source": [ + [ + -1402, + "1" + ] + ], + "banks": [ + { + "chart": 282, + "remove": 91108, + "relation": [ + [ + 91108, + "-1/2" + ], + [ + 91110, + "1/2" + ] + ] + } + ] + }, + "split_role": 288, + "split_chart": 288, + "direction": "transpose" + }, + { + "alternative": { + "event": "restrict", + "direction": "transpose", + "role": 1409, + "source": [ + [ + -1410, + "1" + ] + ], + "banks": [ + { + "chart": 301, + "remove": 96030, + "relation": [ + [ + 96030, + "-1/2" + ], + [ + 96032, + "1/2" + ] + ] + } + ] + }, + "split_role": 302, + "split_chart": 306, + "direction": "transpose" + } +] diff --git a/research/interleaved-basis-residual-audit/retained/source/results/application.json b/research/interleaved-basis-residual-audit/retained/source/results/application.json new file mode 100644 index 0000000000..59ffda8621 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/results/application.json @@ -0,0 +1,724 @@ +{ + "authenticated_package_sources": 32, + "bracket": [ + "0.00378751509486", + "0.00378751509487" + ], + "caller": { + "calls": 16, + "dyadic_height": 9, + "exact_preproduct_divisions": 153295, + "fixed_caller_paid": { + "1": 384, + "8": 640, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416 + }, + "fixed_root_targets": { + "9": 416, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "129": 208 + }, + "odd_scale": 2025, + "peak_scaled_mass": "495734175/2", + "peak_witness": [ + 1196, + "stored sum" + ], + "roles": 68, + "root_owners": 3536, + "uses": { + "ADD": 92400, + "IDLE_ODD": 32, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "QUERY": 384, + "SCALE": 11728, + "SWAP": 240 + } + }, + "claim": "0.00378751509478", + "comparison": { + "assurance": { + "contract": "Exact matching user declarations; mathematical applicability is not verified.", + "inconclusive": "Mixed hinge signs do not establish a power-moment crossing or failure.", + "input_binding": "SHA-256 identifies the exact input bytes read, when loaded by this CLI.", + "scope": "Histogram arithmetic only. Histogram correctness, circuit legality, ownership, phases, precision, supplier admission and compiler endpoints are not validated." + }, + "classification": "uniformly_better", + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "delta_paid": { + "1": -432, + "2": -416, + "3": -1248, + "4": -32, + "5": -1104, + "6": -384, + "7": -128, + "8": -96, + "9": -64 + }, + "delta_targets": { + "1": -288, + "2": -304, + "3": -752, + "4": -48, + "5": -1056, + "6": -400, + "7": -160, + "8": -112, + "9": -240 + }, + "hinges": [ + { + "rank": 0, + "value": 0 + }, + { + "rank": 1, + "value": -544 + }, + { + "rank": 2, + "value": -944 + }, + { + "rank": 3, + "value": -1232 + }, + { + "rank": 4, + "value": -1024 + }, + { + "rank": 5, + "value": -832 + }, + { + "rank": 6, + "value": -592 + }, + { + "rank": 7, + "value": -368 + }, + { + "rank": 8, + "value": -176 + }, + { + "rank": 9, + "value": 0 + } + ], + "method_credit": "Classical concave order/majorization; mightyOil's t16-moment-order-audit and its retained predecessors. No new theorem claim.", + "power_moment": { + "exponent": "0 < t < 1", + "new_minus_old_sign": "strictly_negative", + "tariff": "r^t" + }, + "quantity": "(new paid - new targets) - (old paid - old targets)", + "rank_mass": { + "delta": { + "paid": -15200, + "paid_minus_targets": 0, + "targets": -15200 + }, + "new": { + "paid": 253168, + "paid_minus_targets": -1328, + "targets": 254496 + }, + "old": { + "paid": 268368, + "paid_minus_targets": -1328, + "targets": 269696 + } + }, + "schema": "integer-mult-recursive-invoice-comparison/v1", + "signed_net_delta": { + "1": -144, + "2": -112, + "3": -496, + "4": 16, + "5": -48, + "6": 16, + "7": 32, + "8": 16, + "9": 176 + }, + "tariff_class": "increasing concave f on nonnegative ranks, with f(0)=0", + "uniform_order": "weak; some concave tariffs can give equality" + }, + "compiler": { + "BIT_margin": "1299298103/20000000000000", + "BIT_pin": "12039/3125000", + "H": "14806300000000000000", + "alpha": [ + 0.9999999999999737, + 0.9999999999999737 + ], + "claim": "189375754739/50000000000000", + "compiler_gap": "1/100000000000000", + "delta": [ + 0.8179456083732319, + 0.8179456083732319 + ], + "derivative_upper": -342654.8808080589, + "gamma": [ + 0.9384751777672592, + 0.9384751777672592 + ], + "input_lift": { + "absolute_curvature_upper": "2355391845541459904210316251401050062978110588940190425603051116764979485783867649/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "derivative_upper_on_required_interval": "-620294205229352133144983085368887569874188896085649908017953470200079507073243424339/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "12039/3125000", + "margins": { + "189375754739/50000000000000": [ + "64503270710416314575980540789739084131854221599754015130364604418683950749853/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "16125817677604078643995135197434771032963555399938503782591151104670987687707/12500000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "75750301897/20000000000000": [ + "129006541423111055362311478949165858306059457157563704284508218246771048445961/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "129006541423111055362311478949165858306059457157563704284508218246771048447903/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "signed_curvature_upper": "31960881757465108748156055549877382773720954815102950527044995237546502905778087/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "signed_derivative_ceiling": "17790058447175641876263482763505090461437978190383344010344228678780469811693673/2556870540597208699852484443990190621897676385208236042163599619003720232462246960" + }, + "minimum_log_power": 2324, + "moment_margin_float": { + "189375754743/50000000000000": [ + 3.1288243958880464e-09, + 3.1288243958880464e-09 + ], + "378751509487/100000000000000": [ + -3.501903782702142e-10, + -3.501903782702142e-10 + ], + "75750301897/20000000000000": [ + 6.6078391700464495e-09, + 6.6078391700464495e-09 + ] + }, + "moment_margins": { + "189375754743/50000000000000": [ + "391103049486005776542055384852226711023725036050046811245440647349343/125000000000000000000000000000000000000000000000000000000000000000000000000000", + "9777576237150144413551384621305667775593125901251170281136016184762257/3125000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "378751509487/100000000000000": [ + "-273586233023604871783147866943157638519982425078774377185164265945879/781250000000000000000000000000000000000000000000000000000000000000000000000000", + "-68396558255901217945786966735789409629995606269693594296291066422259/195312500000000000000000000000000000000000000000000000000000000000000000000000" + ], + "75750301897/20000000000000": [ + "4129899481279031101422038666326094746164568866975819263126529952083417/625000000000000000000000000000000000000000000000000000000000000000000000000000", + "1290593587899697219194387083226904608176427770929943519727040610090449/195312500000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "189375754743/50000000000000", + "378751509487/100000000000000" + ], + "tested": "75750301897/20000000000000", + "written_log_power": 2325 + }, + "conditional_interfaces": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "gain_over_previous_upper": "304727927/12500000000000", + "graph_sha256": "ba59d5db17c40185c8608a734ced10135d8c041e432c3840e9034868781c31a2", + "invoice": { + "contract": { + "ambient_rank": 137, + "boundary": "actual signed caller research candidate with 16 native calls", + "model": "mixed-target-unnormalized-power-v1", + "rank_semantics": "H_r costs r^(1-C); debit surrendered productive fields" + }, + "paid": { + "1": 62896, + "16": 416, + "2": 13136, + "24": 416, + "3": 7776, + "32": 416, + "4": 3536, + "40": 416, + "48": 416, + "5": 4800, + "56": 416, + "6": 1152, + "7": 32, + "8": 656, + "9": 32 + }, + "schema": "integer-mult-recursive-invoice/v1", + "targets": { + "1": 16, + "129": 208, + "17": 416, + "2": 32, + "25": 416, + "33": 416, + "4": 3568, + "41": 416, + "49": 416, + "5": 128, + "57": 416, + "65": 416, + "7": 96, + "8": 416, + "9": 9920 + } + }, + "owner_alias_rejected": true, + "paid": 96512, + "physical": { + "caller_envelope": { + "binary_height_at_all_completed_cuts_and_products": 325, + "binary_height_at_native_entrances": 318, + "normalized_bound_uses_no_cancellation_or_commutation": true, + "records": 4192, + "scaled_mass_at_all_cuts_and_products": "422697641667541055184649383436611894902745135854144098178147008285122975926924780864462653005878076090749928607858304935653611344748944586891405006118422035825340979484130265226717/787320000000000", + "scaled_mass_at_native_entrances": "841540548201148271304709423731170105326708333407364819898222426096105903810343041288214438457604474421941928920227707368470121101079538458948446020268383922323667853993448395617/100776960000000", + "stages": 16, + "uses": { + "ADD": 92400, + "IDLE_ODD": 32, + "IDLE_ONE": 3136, + "LAMBDA": 10672, + "QUERY": 384, + "SCALE": 11728, + "SWAP": 240 + } + }, + "common_root": { + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "caller_odd": 2025, + "context_binary_bits": 339, + "context_c": 1174, + "context_mass_bits": 587, + "context_mass_bound": "410557092389428099296767700295182431488903709076312877595788805991477426089871481145556000450556605313380826110267778127616849830596638334292337534865387289495800169678851505870897242002024113/859963392000000", + "exact_grid": "2^(-p-D)", + "native_binary": { + "candidate": 21 + }, + "native_odd": { + "candidate": 2650725 + }, + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26" + }, + "depth_guard": { + "argument_bit_length": 14083, + "compiler_H": 14806300000000000000, + "strict_guard_passed": true + }, + "extra_prime_rejections": [ + 7, + 17 + ], + "native": { + "additional_independent_guarded_streams": 4, + "all_public_inputs_preserved_until_final_installs": true, + "checked_nontrivial_divisions": 5586926, + "checked_nontrivial_divisions_by_denominator": { + "2": 2728539, + "3": 86344, + "4": 1968039, + "5": 25010, + "6": 29977, + "7": 1557, + "8": 501968, + "9": 1140, + "10": 5805, + "11": 608, + "12": 4973, + "16": 142879, + "17": 252, + "18": 157, + "20": 16203, + "22": 268, + "24": 6463, + "27": 57, + "32": 43182, + "33": 14, + "34": 202, + "36": 60, + "40": 651, + "44": 333, + "48": 92, + "51": 20, + "54": 4, + "64": 20585, + "66": 1, + "68": 327, + "72": 35, + "88": 87, + "96": 42, + "99": 41, + "108": 2, + "128": 144, + "132": 1, + "136": 205, + "144": 3, + "160": 3, + "176": 6, + "192": 9, + "198": 8, + "204": 34, + "256": 6, + "272": 78, + "384": 1, + "396": 4, + "408": 54, + "544": 95, + "792": 1, + "816": 74, + "1088": 115, + "1632": 57, + "2176": 54, + "3264": 37, + "6528": 20 + }, + "coefficient_products": 10483566, + "declared_senders": 1, + "deferred_terminal_banks": 1260, + "exact_all_public_rows": 1260, + "exact_odd_unscale_outputs": 1260, + "fixture_addressed_cells_overwritten": { + "clear_full_sender_after_return": 23240, + "initialize_complete_dirty_home": 33340, + "initialize_empty_sender_before_departure": 23240, + "retire_complete_home": 33340 + }, + "fixture_addressed_cells_per_home": 4, + "guarded_dummy_slots": 1, + "immutable_entry_banks": 1260, + "immutable_paid_return_banks": 5810, + "live_sender_alias_control_rejected": true, + "max_outstanding_native_senders": 1, + "maximum_exact_row_prefix_mass_scaled": "21637850423175/8", + "minimum_product_grid": 723824640, + "minimum_snapshot_grid": 5322240, + "missing_odd_factor_controls": { + "3": { + "coefficient": "1/6", + "denominator": 6, + "donor": -1146, + "entrance_column": 1145, + "numerator_without_factor": 68629299200, + "positive_remainder": 2, + "removed_factor": 81, + "row": 88457 + }, + "5": { + "coefficient": "1/10", + "denominator": 10, + "donor": -1176, + "entrance_column": 1175, + "numerator_without_factor": 222358929408, + "positive_remainder": 8, + "removed_factor": 25, + "row": 88808 + } + }, + "native_scalar_scratch_homes": 4, + "numerical_homes": 8335, + "paid_native_ranks": { + "1": 3907, + "2": 821, + "3": 486, + "4": 221, + "5": 300, + "6": 72, + "7": 2, + "8": 1 + }, + "path_grid": 5558973235200, + "path_grid_height": 21, + "path_grid_odd": 2650725, + "positive_helper_ranks": { + "1": 1, + "2": 2, + "4": 223, + "5": 8, + "7": 6, + "8": 26, + "9": 594 + }, + "positive_path_mass_bound_unscaled": "69694815447527/3231360", + "positive_path_mass_peak_node": 155987, + "public": 1260, + "retired_and_guards_restored": true, + "same_owner_complete_fixture_outputs": 1260, + "selected_logical_operations": { + "clear_full_sender_after_return": 5810, + "initialize_complete_dirty_home": 8335, + "initialize_empty_sender_before_departure": 5810, + "read_immutable_donor": 179175, + "read_parked_sender": 5810, + "read_terminal_for_same_owner_install": 1260, + "retire_complete_home": 8335, + "stage_full_sender": 5810, + "write_complete_return": 5810, + "write_entrance": 1260, + "write_terminal": 1260 + }, + "separate_guide_tracks": 1, + "slots": 5810, + "terms": 179175, + "trace_sha256": "899228ebed06b28d4a4a8a61e029e7df94f56fadf0332525ed75107c55902b6a", + "tracked_stream_reset_visits": 544595 + }, + "ordinary": { + "additional_full_overwrite_steps_per_reset_L_and_constant": [ + 2, + 3 + ], + "compiled_ordinary_work": "Full-view resets, selects, copies, guide and layout setup and return, exact scalar and odd conversions, matchers, fixed descriptors, root normalization, and all native, caller and child adapters.", + "compiled_stock": "Disjoint occurrence-tagged bank tuples, dummy origins, guides and four guarded streams per stage; complete public owners, matching child views, compiler and BIT workspace, and every parked ancestor.", + "layout": { + "aggregate_owned_tuple_M": "sum_stage[(homes+6)(L'+2)+ell(N_c)+ell(W+26)+max(ell(N_c),ell(W+26),ell(homes))+max(N_c,homes)+max(W+26,ell(homes))+10]", + "complete_view_step_bound": "34*(256(M+352)+128) plus fixed-degree descriptor work", + "guide_setup_and_retirement": "q(N_c)+q(W')+22N_cW'+36N_c+7W'+36+7L'+10; q(x)=24x-7popcount(x)+15ell(x)+12; W'=W+26", + "padded_payload": "L'=N_c(2(W+26)+3)", + "per_stage_selector_and_stream_tracks": 11, + "shadow_cells_upper": "M+352" + }, + "native_numeric_homes": 8335, + "native_numeric_homes_plus_dummy": 8336, + "native_paid_wrappers": 92960, + "native_productive_wrappers": 13760, + "odd_conversions": 47392, + "ordinary_elementary_record_upper": 24868028416, + "ordinary_main_pair_slots": 6400, + "ordinary_map_slots": 262144, + "raw_numeric_homes": 133360, + "raw_numeric_homes_plus_dummy": 133376, + "raw_paid_positions": 96512, + "raw_productive_targets": 17296, + "raw_scalar_incidence_allowance_before_factor_32": { + "complete_array_odd_conversions": 47392, + "literal_native_products_and_accumulations": 2866800, + "private_home_flags_and_cleanup": 133360, + "public_boundary_installations_and_scale_preparations": 40320, + "serial_sender_initialization_and_retirement": 185920, + "weighted_signed_caller_operation_slots": 118592, + "width_padded_native_row_lifecycles": 452480 + }, + "reset_services_all_native_stages": 24372640, + "reset_services_by_kind_per_native": { + "dirty_home_initializations_and_retirements": 16670, + "owner_scale_unscale_stream_initializations_and_retirements": 5040, + "sender_reinitializations_and_retirements": 11620, + "term_and_row_stream_initializations_and_retirements": 1489960 + }, + "reset_services_per_native": 1523290, + "root_negative_q_translations": 3536, + "scalar_services": 123035648, + "scalar_step_rate": 1073741824, + "selected_total_steps_per_native_L_and_constant": [ + 225947752820, + 1017336374670 + ], + "selected_total_steps_raw_L_and_constant": [ + 3615164045120, + 16277381994720 + ], + "selector_steps_per_selected_service_L_and_constant": [ + 116699, + 525500 + ], + "separate_guarded_guide_tracks_per_native": 1, + "separate_guarded_guide_tracks_raw": 16, + "separate_guarded_streams_per_native": 4, + "separate_guarded_streams_raw": 64, + "typed_selected_transfer_legs_all_native_stages": 6598240, + "typed_selected_transfers_per_native": 412390, + "typed_transfer_legs_by_kind_per_native": { + "complete_scalar_donor_staging_legs": 358350, + "complete_sender_and_terminal_staging_legs": 14140, + "immutable_entrance_and_public_terminal_install_legs": 5040, + "paid_parked_sender_return_and_adapter_legs": 34860 + } + }, + "partial_clear_control": { + "dirty_unaddressed_last_cell_rejected": true, + "neighbor_unchanged": true + }, + "scalars": { + "coefficient_bits": 22, + "component_padding": 26, + "distinct_scalar_and_conversion_factors": 1108, + "rejected_one_tick_denominators": [ + 2, + 3, + 5, + 7 + ], + "retained_max_bits": 24, + "signed_bit_transducer_cases": 6648 + } + }, + "powers": [ + { + "graph": "parent", + "kappa": "0.00376313686062", + "paid_minus_productive": { + "lower": "20538236154209920064717157952839541301037251126476494157232824160121/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "20538236154209920064717157952839541301037251126476494157232830247213/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00376313686062", + "paid_minus_productive": { + "lower": "-15345435192348118344342151455208196236938647545611875189622020542251464633693/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "upper": "-61381740769392473377368605820832784947754590182447500758488082169005852504629/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00378751509478", + "paid_minus_productive": { + "lower": "-224064514197209690998743249661416151085810356689136130624266186360255/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-224064514197209690998743249661416151085810356689136130624266180169563/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00378751509485", + "paid_minus_productive": { + "lower": "-47820968927740743550854771336103822091729115018544786240044360825219/7237005577332262213973186563042994240829374041602535252466099000494570602496", + "upper": "-47820968927740743550854771336103822091729115018544786240044354684055/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00378751509486", + "paid_minus_productive": { + "lower": "-2830414950441879553402955619588012895256445820964470433685755365875/904625697166532776746648320380374280103671755200316906558262375061821325312", + "upper": "-22643319603535036427223644956704103162051566567715763469486036520495/7237005577332262213973186563042994240829374041602535252466099000494570602496" + } + }, + { + "graph": "candidate", + "kappa": "0.00378751509487", + "paid_minus_productive": { + "lower": "1267164860334817534231051602836260796010842499649910524237450446925/3618502788666131106986593281521497120414687020801267626233049500247285301248", + "upper": "633582430167408767115525801418130398005421249824955262118726904687/1809251394333065553493296640760748560207343510400633813116524750123642650624" + } + } + ], + "previous_upper": "0.00376313686062", + "probe": "0.00378751509485", + "productive": 17296, + "stages": [ + [ + 1, + 400, + 860 + ], + [ + 2, + 400, + 860 + ], + [ + 3, + 400, + 860 + ], + [ + 4, + 400, + 860 + ], + [ + 5, + 400, + 860 + ], + [ + 6, + 400, + 860 + ], + [ + 7, + 400, + 860 + ], + [ + 8, + 400, + 860 + ], + [ + 9, + 400, + 860 + ], + [ + 10, + 400, + 860 + ], + [ + 11, + 400, + 860 + ], + [ + 12, + 400, + 860 + ], + [ + 13, + 400, + 860 + ], + [ + 14, + 400, + 860 + ], + [ + 15, + 400, + 860 + ], + [ + 16, + 400, + 860 + ] + ] +} diff --git a/research/interleaved-basis-residual-audit/retained/source/results/catalogue-0.json b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-0.json new file mode 100644 index 0000000000..316666c59c --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-0.json @@ -0,0 +1,16 @@ +{ + "checked_pairs": 980, + "contacts": 560, + "contacts_sha256": "48e85c514d93eb66a5690de05819acf9c6c0a6aa7906ff8eb7c55a2e8344f200", + "dense_pairs": [ + [ + 0, + 249 + ] + ], + "forward_and_adjoint_columns": 1024, + "ports": 35, + "recipes_sha256": "05400821ee480bc8267e352d9a1d667cf6bebd1940ad3a23db7831f4e3411e37", + "shard": 0, + "total_pairs": 2938 +} diff --git a/research/interleaved-basis-residual-audit/retained/source/results/catalogue-1.json b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-1.json new file mode 100644 index 0000000000..efdc2b0150 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-1.json @@ -0,0 +1,20 @@ +{ + "checked_pairs": 979, + "contacts": 560, + "contacts_sha256": "367465c30dcb2c26380faa45f3c25475e07853afb37032fe72516ea7ccb62f40", + "dense_pairs": [ + [ + 0, + 250 + ], + [ + 3, + 288 + ] + ], + "forward_and_adjoint_columns": 2048, + "ports": 35, + "recipes_sha256": "5138d9f98eca700238c6b653ba0b40a5d7bc4bb7890e519a637d15575e5eb711", + "shard": 1, + "total_pairs": 2938 +} diff --git a/research/interleaved-basis-residual-audit/retained/source/results/catalogue-2.json b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-2.json new file mode 100644 index 0000000000..7cd2928eea --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/results/catalogue-2.json @@ -0,0 +1,20 @@ +{ + "checked_pairs": 979, + "contacts": 544, + "contacts_sha256": "35d2dc786a977215dba2264b899ff1b4f77b8cbb9a88e4b0e30cc658edaf79a8", + "dense_pairs": [ + [ + 0, + 251 + ], + [ + 767, + 127 + ] + ], + "forward_and_adjoint_columns": 2048, + "ports": 34, + "recipes_sha256": "012b3b577b6d168aadd4c02d751059fc654033a342a8dbb509a2f8f9cd202457", + "shard": 2, + "total_pairs": 2938 +} diff --git a/research/interleaved-basis-residual-audit/retained/source/results/witness.json b/research/interleaved-basis-residual-audit/retained/source/results/witness.json new file mode 100644 index 0000000000..d9bd3e90dd --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/results/witness.json @@ -0,0 +1,84 @@ +{ + "alternate_restrictions": [ + { + "failures": { + "readout": { + "actual": "1", + "coordinates": 16, + "first_coordinate": 10, + "required": "0" + } + }, + "restriction": 1400, + "split": 294 + }, + { + "failures": { + "response": { + "actual": "-2", + "coordinates": 16, + "first_coordinate": 11, + "required": "0" + } + }, + "restriction": 1401, + "split": 288 + }, + { + "failures": { + "response": { + "actual": "1", + "coordinates": 27, + "first_coordinate": 25, + "required": "0" + } + }, + "restriction": 1409, + "split": 302 + } + ], + "chronological_edits": 255, + "events": { + "hub": 9, + "pivot": 14, + "receiver_equations": 230, + "rejected_pulse_mutations": 12, + "restrict": 220, + "split": 12 + }, + "graph_sha256": "ba59d5db17c40185c8608a734ced10135d8c041e432c3840e9034868781c31a2", + "native_change_from_7713": { + "paid": { + "1": -27, + "2": -26, + "3": -78, + "4": -2, + "5": -69, + "6": -24, + "7": -8, + "8": -6, + "9": -4 + }, + "targets": { + "1": -17, + "2": -19, + "3": -47, + "4": -2, + "5": -65, + "6": -25, + "7": -10, + "8": -6, + "9": -17 + } + }, + "rejected": [ + "forward", + "pulse", + "transpose" + ], + "reverse": { + "columns": 1260, + "exact_products": 10218280, + "scale": 5558973235200 + } +} diff --git a/research/interleaved-basis-residual-audit/retained/source/split.py b/research/interleaved-basis-residual-audit/retained/source/split.py new file mode 100644 index 0000000000..98a5033490 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/split.py @@ -0,0 +1,64 @@ +"""Apply one helper split to an oriented scalar communication network.""" + + +from network import add_scaled, coefficients + + +def apply_split(net, event): + """Use the direction specified in the event before this call.""" + first = net.first_output + role = event["role"] + chart = event["split_chart"] + if (net.initial[role], net.final[role]) != (event["source_chart"], event["return_chart"]): + raise ValueError("helper split boundary") + direction = coefficients(event["source_direction"]) + probe = coefficients(event["source_covector"]) + readout = coefficients(event["readout"]) + response = coefficients(event["return_direction"]) + decode = coefficients(event["return_covector"]) + calibration = coefficients(event["calibration"]) + pulse = coefficients(event["pulse"]) + input_scale = sum(probe.get(i, 0) * v for i, v in direction.items()) + output_scale = sum(decode.get(i, 0) * v for i, v in response.items()) + if not input_scale or not output_scale or not response.get(role): + raise ValueError("zero helper split pivot") + if not all(net.initial[i] == net.initial[role] for i in direction.keys() | probe.keys()): + raise ValueError("source vectors use different charts") + if not all(net.final[i] == net.final[role] for i in response.keys() | decode.keys()): + raise ValueError("return vectors use different charts") + fresh = len(net.initial) + # Set the old pivot coordinate to zero. Add the source direction to encode the new input. + multiplier = {~i: -v / input_scale for i, v in probe.items() if i != role} + multiplier[~role] = 1 / input_scale + + def change_inputs(row): + coefficient = sum(row.get(~i, 0) * value for i, value in direction.items()) + if not coefficient and ~role not in row: + return row + changed = dict(row) + changed.pop(~role, None) + add_scaled(changed, multiplier, coefficient) + return changed + + rows = {k: change_inputs(a) for k, a in net.forms.items()} + observed = change_inputs(readout) + excitation = {~fresh: 1 / output_scale} + add_scaled(excitation, change_inputs(calibration), -1 / output_scale) + for k, coefficient in pulse.items(): + row = dict(rows[k]) + add_scaled(row, excitation, coefficient) + rows[k] = row + returned = {} + for i, coefficient in decode.items(): + add_scaled(returned, rows[first + i], coefficient) + pivot = rows[first + role] + for i, coefficient in response.items(): + if i != role: + row = dict(rows[first + i]) + add_scaled(row, pivot, -coefficient / response[role]) + rows[first + i] = row + rows[first + role] = observed + rows[first + fresh] = returned + final = net.final + [net.final[role]] + final[role] = chart + return type(net)(first, net.initial + [chart], final, dict(net.moves), rows) diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/binding16.py b/research/interleaved-basis-residual-audit/retained/source/vendor/binding16.py new file mode 100644 index 0000000000..d07341b817 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/binding16.py @@ -0,0 +1,280 @@ +"""Complete occurrence and source-bound phase specialization of #7000/#7113. + +The degree-two phase polynomial and translation checks are reused unchanged +from Douglas Colkitt's retained upstream_application.py. See SOURCE-PINS.json. +""" + +from collections import Counter + +from caller16 import literal_layout, require +from upstream_application import boundary, digest, dot, polynomial, sub, terms, translation + + +def route(q, basis, stage, ambient): + native = [q, *basis] + require(len(native) == 9 and all(0 < v < 512 for v in native), + "nine central directions") + require(all(dot(a, b) == (i == j) for i, a in enumerate(native) + for j, b in enumerate(native)), "orthonormal central directions") + fresh = [1 << (9 + 8 * (stage - 1) + j) for j in range(8)] + mask = 511 | sum(fresh) + + def transform(value): + central = value & 511 + out = value & ~mask + if dot(central, q): + out ^= q + for basis_vector, axis in zip(basis, fresh, strict=True): + if dot(central, basis_vector): + out ^= axis + if value & axis: + out ^= basis_vector + return out + + axes = [1 << j for j in range(ambient)] + require(all(transform(transform(a)) == a for a in axes), "full route involution") + require(transform(q) == q, "preserved head direction") + require(all(transform(a) == a for a in axes if not mask & a), "complete spectators") + return transform + + +def contact_phase(q, basis, stage, ambient): + move = route(q, basis, stage, ambient) + before_axes = [1 << j for j in range(9 + 8 * (stage - 1))] + after_axes = [1 << j for j in range(9 + 8 * stage)] + spectator = [1 << j for j in range(9, 9 + 8 * stage)] + x0 = terms((a, 1) for a in before_axes) + y0 = terms([*x0.items(), (q, -1)]) + x1 = terms((a, 1) for a in after_axes) + y1 = terms([*x1.items(), (q, -1)]) + nx0 = terms([(a, 1) for a in spectator] + [(q, 1)]) + ny0 = terms((a, 1) for a in spectator) + nx1 = terms((a, 1) for a in [*spectator, *[1 << j for j in range(9)]]) + ny1 = terms([*nx1.items(), (q, -1)]) + pairs = ((x0, nx0), (y0, ny0), (nx1, x1), (ny1, y1)) + shifts = [boundary(a, b, move) for a, b in pairs] + body = terms((1 << j, 1) for j in range(9 + 8 * (stage - 1), 9 + 8 * stage)) + require(not polynomial(sub(sub(x1, x0), body)) + and not polynomial(sub(sub(y1, y0), body)) + and not polynomial(sub(sub(y1, x0), terms([*body.items(), (q, -1)]))) + and not polynomial(sub(sub(x1, y0), terms([*body.items(), (q, 1)]))), + "all four signed contact operators") + require(polynomial(sub(terms([(q, 1)]), terms([(q, -1)]))), + "query orientation discrimination") + # The two signed head corrections and the Q^2 term of LAMBDA. + require(translation(sub(terms([(q, 1)]), terms([(q, -1)]))) == q + and translation(terms([(q, 2)])) == q, "ordinary head translations") + first_shift = next((i for i, shift in enumerate(shifts) if shift), None) + return shifts, (move, pairs[first_shift]) if first_shift is not None else None + + +def native_inventory(word, helpers): + dimensions = [len(frame) for frame in word["frames"]] + public = word["public"] + owned = {} + lifetimes = [] + moves = [] + paid = Counter() + opcodes = Counter() + live_peak = 0 + for clock, event in enumerate(word["program"]): + op, role, *args = event + opcodes[op] += 1 + if op == "INIT": + require(public <= role < public + word["owned_fields"] and role not in owned, + "fresh owned lifetime") + owned[role] = len(lifetimes) + lifetimes.append([role, clock, args[0], None, None]) + live_peak = max(live_peak, len(owned)) + elif op == "CLEAR": + require(role in owned, "ordered owned retirement") + lifetime = lifetimes[owned.pop(role)] + lifetime[3:] = [clock, args[0]] + elif op == "MOVE": + first, last, is_owned = args + rank = abs(dimensions[last] - dimensions[first]) + require(rank > 0 and is_owned == (role >= public), "positive paid native rank") + require(not is_owned or role in owned, "current private MOVE owner") + moves.append((clock, role, first, last, rank, owned.get(role))) + paid[rank] += 1 + require(not owned and len(lifetimes) == 235 and live_peak == 51, "full 235-lifetime closure") + targets = Counter() + for role in helpers: + rank = dimensions[word["final"][role]] - dimensions[word["initial"][role]] + require(rank > 0, "positive independently owned helper target") + targets[rank] += 1 + return lifetimes, moves, paid, targets, opcodes + + +def complete_binding(word, caller, phases, signed): + stages, types, role_sets = literal_layout(caller, word) + ambient = caller["ambient_rank"] + public = word["public"] + require(public == 1501 and word["owned_fields"] == 68, "exact native public/private header") + ports = word["ports"] + live = word["live"] + h = word["hosted"] + second = dict(zip(h["Dports"], zip(h["X2"], h["Y2"], strict=True), strict=True)) + main = set(live) | {r + 112 for r in live} | set(h["X2"]) | set(h["Y2"]) + helpers = sorted(set(range(public)) - main) + require(len(live) == len(ports) == 104 and len(set(ports)) == 104 + and len(main) == 400 and len(helpers) == 1101, "actual native partition") + special_helpers = (325, 1087) + for role in special_helpers: + pair = [word["initial"][role], word["final"][role]] + require(role in helpers and pair == [3, 237] + and not word["frames"][pair[0]] + and word["frames"][pair[1]] == [30, 75, 138, 266], + "explicit arbitrary-input rank-four helper boundary") + by_q = {row["q"]: row["idle_children"][0]["orthogonal_axes"][:8] + for row in phases["recipes"]} + require(set(ports) <= set(by_q), "every actual port has a pinned phase basis") + for port, (first, q) in enumerate(zip(live, ports, strict=True)): + companion = first + 112 + fin = word["frames"][word["final"][companion]] + require(word["frames"][word["initial"][first]] == [q] + and not word["frames"][word["initial"][companion]] + and word["frames"][word["final"][first]] == [1 << j for j in range(9)] + and len(fin) == 8 and all(dot(q, axis) == 0 for axis in fin), + "actual main source and target charts") + if port in second: + x2, y2 = second[port] + require(all(word[key][a] == word[key][b] + for key in ("initial", "final") + for a, b in ((first, x2), (companion, y2))), + "separate second plane with identical charts") + + lifetime_plan, moves, native_paid, helper_targets, opcodes = native_inventory(word, helpers) + roots = {("main", port, role) for kind, spec in types.items() + for port in spec["ports"] for role in role_sets[kind]} + require(len(roots) == signed["root_owners"] == 3536, "distinct root owner count") + fresh_helpers = set() + paid = Counter() + targets = Counter() + phase_rows = [] + occurrences = [] + owner_maps = [] + phase_fault_rejected = False + signed_idles = 0 + special_owners = [] + for clock, event in enumerate(caller["events"]): + if event[0] == "J": + _, stage, a, b = event + owners = {} + for port, first in enumerate(live): + pair = a[:2] if port in second else b[:2] + first_pair = ((first, pair[0]), (first + 112, pair[1])) + if port in second: + first_pair += tuple(zip(second[port], a[2:], strict=True)) + for slot, role in first_pair: + tag = ("main", port, role) + require(tag in roots and slot not in owners, "injective main assignment") + owners[slot] = tag + shifts, fault = contact_phase(ports[port], by_q[ports[port]], stage, ambient) + phase_rows.append([clock, port, shifts, 2 if port in second else 1]) + if fault and not phase_fault_rejected: + transform, (before, after) = fault + try: + boundary(before, after, transform, omit_translation=True) + except ValueError as exc: + require(str(exc) == "forward contact includes its phase", + "phase control rejection reason") + phase_fault_rejected = True + else: + raise ValueError("omitted contact translation escaped") + require(set(owners) == main and len(set(owners.values())) == 400, + "all source main slots have different physical owners") + for role in helpers: + tag = ("helper", stage, role) + require(tag not in fresh_helpers and tag not in roots, "fresh arbitrary helper") + fresh_helpers.add(tag) + owners[role] = tag + if role in special_helpers: + special_owners.append({ + "tag": tag, "stage": stage, "caller_clock": clock, + "initial_chart": 3, "final_chart": 237, "target_rank": 4, + "exit_ordered_basis": word["frames"][237], + }) + require(set(owners) == set(range(public)) and len(set(owners.values())) == public, + "full public-field injection") + owner_maps.append([stage, sorted(owners.items())]) + for native_clock, role, first, last, rank, owned in moves: + tag = owners[role] if owned is None else ("owned", stage, owned) + require(tag not in roots or owned is None, "private owner separation") + paid[rank] += 1 + occurrences.append([clock, native_clock, tag, rank, first, last]) + targets.update(helper_targets) + continue + + kind, op, role, *args = event + if op not in {"QUERY", "IDLE_ONE", "IDLE_ODD"}: + continue + if op == "QUERY": + rank = 1 + else: + rank = 8 * len(args[0]) + int(op == "IDLE_ODD") + for port in types[kind]["ports"]: + tag = ("query_scratch", clock, port) if op == "QUERY" else ("main", port, role) + require((tag not in roots) if op == "QUERY" else tag in roots, "caller paid owner") + occurrences.append([clock, op, tag, rank]) + paid[rank] += 1 + signed_idles += int(op == "IDLE_ODD") + require(len(owner_maps) == stages and len(fresh_helpers) == 17616 and phase_fault_rejected, + "complete 16-call owners and phase control") + require(len(special_owners) == len({row["tag"] for row in special_owners}) == 32, + "distinct stage-tagged arbitrary helper 325 and 1087 ingress/egress") + root_targets = Counter() + root_negative = 0 + for kind, spec in types.items(): + for phase, coeff_phase, *selection in spec["diagonal"]: + require(coeff_phase == 0 and any(selection), "whole positive target endpoint") + for port in spec["ports"]: + q = ports[port] + axes = [1 << (9 + 8 * j + offset) for j, yes in enumerate(selection) + if yes for offset in range(8)] + require(len(axes) == len(set(axes)) and all(a < 1 << ambient for a in axes), + "positive target complete distinct axes") + actual = terms([(q, phase)] + [(axis, 1) for axis in axes]) + positive = terms((a, 1) for a in ([q] if phase else []) + axes) + require(translation(sub(positive, actual)) == (q if phase == -1 else 0), + "exact negative root translation") + root_targets[len(axes) + int(bool(phase))] += 1 + root_negative += int(phase < 0) + targets.update(root_targets) + references = Counter({rank: stages * count for rank, count in native_paid.items()}) + references.update(signed["fixed_caller_paid"]) + require(paid == references and root_targets == Counter(signed["fixed_root_targets"]), + "independent decomposition and occurrence invoices agree") + require(len(occurrences) == sum(paid.values()) and sum(targets.values()) == 21152, + "complete paid and productive owner count") + contacts = sum(4 * row[3] for row in phase_rows) + nonzero = sum(row[3] * sum(bool(v) for v in row[2]) for row in phase_rows) + require(contacts == nonzero == 12800, "all 12,800 absolute phase translations charged") + return { + "ambient": ambient, + "calls": stages, + "native_public": public, + "main_per_native": len(main), + "fresh_helpers": len(fresh_helpers), + "role_325_and_1087_helper_owners": special_owners, + "root_owners": len(roots), + "productive_fields": sum(targets.values()), + "paid_positions": len(occurrences), + "native_paid": dict(native_paid), + "native_targets": dict(helper_targets), + "paid": dict(paid), + "targets": dict(targets), + "phase_digest": digest(phase_rows), + "owner_map_digest": digest(owner_maps), + "ordered_paid_digest": digest(occurrences), + "contacts": contacts, + "nonzero_contact_translations": nonzero, + "phase_omission_rejected": phase_fault_rejected, + "signed_idle_ordinary_corrections": signed_idles, + "negative_root_ordinary_corrections": root_negative, + "owned_lifetimes_per_native": len(lifetime_plan), + "owned_lifetime_plan_digest": digest(lifetime_plan), + "owned_fresh_homes_per_raw_caller": stages * len(lifetime_plan), + "owned_resets_per_raw_caller": 2 * stages * len(lifetime_plan), + "native_opcodes": dict(opcodes), + } diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/caller16.py b/research/interleaved-basis-residual-audit/retained/source/vendor/caller16.py new file mode 100644 index 0000000000..2865530b78 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/caller16.py @@ -0,0 +1,182 @@ +"""Exact signed caller replay, adapted from Ali Romman's #7663 caller.py. + +See SOURCE-PINS.json for Rohan Arun's literal #7113-derived caller and +the attributed reference engines. Apache-2.0. +""" + +from collections import Counter +from fractions import Fraction +from functools import cache + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def exact_div(numerator, denominator): + quotient, remainder = divmod(numerator, denominator) + require(remainder == 0, "inexact caller pre-product") + return quotient + + +def literal_layout(caller, word): + stages = caller["stages"] + require(stages == 16 and caller["ambient_rank"] == 9 + 8 * stages == 137, + "literal 16-call, 137-axis layout") + require(len(caller["events"]) == 4192, "literal caller event count") + types = caller["types"] + require(set(types) == {"A", "B"}, "literal type partition") + require(all(spec["roles"] == 34 for spec in types.values()), "literal 34+34 roles") + require(types["A"]["ports"] == word["hosted"]["Dports"], "hosted port assignment") + require((len(types["A"]["ports"]), len(types["B"]["ports"])) == (96, 8), + "literal 96+8 ports") + require(sorted(types["A"]["ports"] + types["B"]["ports"]) == list(range(104)), + "disjoint complete 104-port assignment") + role_sets = { + kind: set(range(spec["offset"], spec["offset"] + spec["roles"])) + for kind, spec in types.items() + } + require(role_sets["A"].isdisjoint(role_sets["B"]) + and role_sets["A"] | role_sets["B"] == set(range(caller["roles"])), + "disjoint complete root role ranges") + h = word["hosted"] + coefficients = tuple(Fraction(h[k]) for k in ("alpha", "beta", "alpha2", "beta2")) + require(coefficients == (-1, Fraction(1, 2), -1, 0), "joint normalized source coefficients") + require(Fraction(types["A"]["alpha2"]) == coefficients[2], "A second-plane coefficient") + return stages, types, role_sets + + +def signed_caller(caller, word, odd_scale, dyadic_height): + stages, types, role_sets = literal_layout(caller, word) + unit = odd_scale << dyadic_height + zero = (0,) * stages + rows = [{(r, 0, zero): (unit, 0)} for r in range(caller["roles"])] + paid = Counter() + targets = Counter() + uses = Counter() + calls = [] + checks = 0 + peak = unit + peak_at = (-1, "entrance") + clock = -1 + + def observe(row, site): + nonlocal peak, peak_at + mass = sum(abs(real) + abs(imag) for real, imag in row.values()) + if mass > peak: + peak, peak_at = mass, (clock, site) + + @cache + def shifted(exponents, shift): + result = list(exponents) + for stage in shift: + result[stage - 1] += 1 + return tuple(result) + + def term(row, ar=1, ai=0, denominator=1, phase=0, shift=()): + nonlocal checks + out = {} + for (role, q, powers), (x, y) in row.items(): + real, imag = ar * x - ai * y, ar * y + ai * x + if denominator != 1: + real, imag = exact_div(real, denominator), exact_div(imag, denominator) + checks += 1 + if real or imag: + key = (role, (q + phase) % 4, shifted(powers, shift) if shift else powers) + out[key] = (real, imag) + observe(out, "scaled separate term") + return out + + def add(a, b): + out = a.copy() + for key, (u, v) in b.items(): + x, y = out.get(key, (0, 0)) + if x + u or y + v: + out[key] = (x + u, y + v) + else: + out.pop(key, None) + observe(out, "stored sum") + return out + + for clock, event in enumerate(caller["events"]): + kind = event[0] + if kind == "J": + _, stage, (x, y, u, v), (a, b, alpha, beta) = event + require(stage == len(calls) + 1, "chronological joint occurrences") + require(Fraction(alpha) == -1 and Fraction(beta) == Fraction(1, 2), + "literal joint coefficients") + require(len({x, y, u, v}) == 4 and {x, y, u, v} <= role_sets["A"] + and a != b and {a, b} <= role_sets["B"], "joint owner alias") + calls.append(stage) + rows[y] = add(rows[y], term(rows[x], phase=-1)) + rows[u] = add(rows[u], term(rows[v], -1, phase=1)) + first, second = rows[a], rows[b] + rows[a] = add(first, term(second, -1, phase=1)) + rows[b] = add(term(second, denominator=2), + term(first, denominator=2, phase=-1)) + for role in (x, y, u, v, a, b): + rows[role] = term(rows[role], shift=(stage,)) + continue + + _, op, role, *args = event + require(kind in role_sets and role in role_sets[kind], "caller target owner") + replicas = len(types[kind]["ports"]) + uses[op] += replicas + if op in {"ADD", "SWAP", "QUERY"}: + require(args[0] in role_sets[kind] and args[0] != role, "caller donor owner") + if op == "SWAP": + other, = args + rows[role], rows[other] = rows[other], rows[role] + elif op == "QUERY": + donor, sign = args + require(sign in (-1, 1), "caller query orientation") + rows[role] = add(rows[role], term(rows[donor], phase=sign)) + paid[1] += replicas + elif op in {"ADD", "SCALE"}: + factor = Fraction(args[-1]) + donor = args[0] if op == "ADD" else role + contribution = term(rows[donor], factor.numerator, denominator=factor.denominator) + rows[role] = add(rows[role], contribution) if op == "ADD" else contribution + elif op == "LAMBDA": + sign, = args + require(sign in (-1, 1), "caller LAMBDA sign") + old = rows[role] + rows[role] = add(term(old, 1, sign, 2), term(old, 1, -sign, 2, phase=2)) + else: + require(op in {"IDLE_ONE", "IDLE_ODD"}, "known caller operation") + block = tuple(args[0]) + require(block and len(block) == len(set(block)) + and all(1 <= k <= stages for k in block), "whole idle stage subset") + if op == "IDLE_ODD": + require(len(args) == 2 and len(block) == 1 and args[1] == -1, + "literal signed rank-nine child") + else: + require(len(args) == 1, "literal unit idle") + phase = args[1] if op == "IDLE_ODD" else 0 + rows[role] = term(rows[role], phase=phase, shift=block) + paid[8 * len(block) + phase % 2] += replicas + + require(calls == list(range(1, stages + 1)), "all 16 native invocations") + for spec in types.values(): + require(len(spec["diagonal"]) == spec["roles"], "complete diagonal") + for off, (phase, coefficient_phase, *powers) in enumerate(spec["diagonal"]): + role = spec["offset"] + off + require(phase in (-1, 0, 1) and coefficient_phase == 0 and len(powers) == stages + and set(powers) <= {0, 1} and any(powers), "positive whole root target") + require(rows[role] == {(role, phase % 4, tuple(powers)): (unit, 0)}, + "exact signed root endpoint") + targets[8 * sum(powers) + phase % 2] += len(spec["ports"]) + return { + "fixed_caller_paid": dict(paid), + "fixed_root_targets": dict(targets), + "uses": dict(uses), + "calls": stages, + "roles": len(rows), + "root_owners": sum(targets.values()), + "dyadic_height": dyadic_height, + "odd_scale": odd_scale, + "peak_scaled_mass": str(Fraction(peak, 1 << dyadic_height)), + "peak_witness": peak_at, + "exact_preproduct_divisions": checks, + } diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/construct.py b/research/interleaved-basis-residual-audit/retained/source/vendor/construct.py new file mode 100644 index 0000000000..25115bba74 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/construct.py @@ -0,0 +1,277 @@ +#!/usr/bin/env python3 +"""Rebuild the exact banked #7700 graph and its role-1256 relay contraction.""" + +import argparse +from dataclasses import dataclass +from fractions import Fraction +from functools import cache +from graphlib import TopologicalSorter +import gzip +from hashlib import sha256 +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +DATA = HERE / "data" +SOURCE_HEAD = "7d84799a447867d36137d12ef7ca5646154d763c" +WORD = "ae62d5d8bef6f7146454b4b3643e487a58380c606a16c5baef7bf0dcf9df1472" +CERTS = "39ef28b708cd8bf1166b111d656809407b370dd11cd81a8e43820779f995aca3" +CALLER = "62d94fb992acab0a71c3d12f22be4ce63f4f65e5cbe3f420b93aa1393ffa8dcf" +DONOR_HEAD = "28b2af322a1fab01b3734365988930920f9dda48" +PARENT = "72705b094d83d2ba24006661bbb031786a691b776bedb94515b1321e1535105f" +CHILD = "8e7b755bd2d2d387bc3d3adfe48100985adf74775ca5acbb143170a3d16b5ccf" +PINS = { + "WORD.json.gz": ("50c1facfc5626c060560e2f354b71bd92d0bb1c1e853b2aad72abcbaaa5328a5", WORD), + "CERTS.json": (CERTS, CERTS), + "CALLER.json.gz": ("d889996a337f648087208ab51c98eaf052705d4fca88b5d01b6e9257a829897a", CALLER), + "PARENT-GRAPH.json.gz": ("c86288cddb4b80af3c8128c9a0d2f7a1e82bae64c5152a0d96a19d166afaab1d", PARENT), + "CANDIDATE-GRAPH.json.gz": ("0177c25371181e3b1f2c13325eb8434fbf6384a9ab99a612849efd5d0f6ab2cc", CHILD), +} +REMOVE = 95828 +KEEP = 104442 +ROLE = 1256 +START, RELAY, END = (476, 878, 127) + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(raw): + return sha256(raw).hexdigest() + + +def read(name): + path = DATA / name + packed = path.read_bytes() + packed_sha, raw_sha = PINS[name] + need(digest(packed) == packed_sha, f"transport hash of {name}") + raw = gzip.decompress(packed) if path.suffix == ".gz" else packed + need(digest(raw) == raw_sha, f"decoded hash of {name}") + return raw + + +@cache +def rational(literal): + number = Fraction(literal) + need(number and str(number) == literal, "reduced nonzero rational literal") + return number + + +def accumulate(row, source, factor): + for token, value in source.items(): + total = row.get(token, 0) + factor * value + if total: + row[token] = total + else: + row.pop(token, None) + + +@dataclass +class Graph: + """Every paid result is a distinct stable token. Terminals are never donors.""" + + first: int + initial: list + final: list + moves: dict + forms: dict + + def schedule(self): + terminals = set(range(self.first, self.first + len(self.final))) + need(self.forms.keys() == terminals | self.moves.keys(), "complete paid and public forms") + dependencies = {} + for key in sorted(self.forms): + source = self.moves[key][0] if key in self.moves else self.final[key - self.first] + dependencies[key] = [] + for donor in sorted(self.forms[key]): + if donor >= 0: + need(donor in self.moves and self.moves[donor][1] == source, + f"same ordered chart for paid donor at {key}") + dependencies[key].append(donor) + else: + role = ~donor + need(0 <= role < len(self.initial) and self.initial[role] == source, + f"same ordered chart for input donor at {key}") + return list(TopologicalSorter(dependencies).static_order()) + + def transpose(self): + def reverse(node): + if node < 0: + return self.first + ~node + if node >= self.first: + return ~(node - self.first) + return node + + rows = {key: {} for key in self.moves} + rows.update({self.first + r: {} for r in range(len(self.initial))}) + for key, row in self.forms.items(): + for donor, weight in row.items(): + rows[reverse(donor)][reverse(key)] = weight + return Graph(self.first, self.final, self.initial, + {key: (b, a) for key, (a, b) in self.moves.items()}, rows) + + +@dataclass +class Clear: + clock: int + role: int + chart: int + born: int + left: dict + right: dict + sources: list + + +def raw_fold(word, certificates): + """Apply the attributed #7674 folding rule and capture both CLEAR sides.""" + n = word["public"] + start, end, program = word["initial"], word["final"], word["program"] + first = len(program) + capacity = n + word["owned_fields"] + need(n == len(start) == len(end) == 1501 and first == 154768 and capacity == 1569, + "exact raw denominator") + rows = [{~r: Fraction(1)} for r in range(n)] + [None] * word["owned_fields"] + charts = start[:] + [None] * word["owned_fields"] + active, moves, forms, raw_moves = {}, {}, {}, {} + witnesses = [] + peak = 0 + for clock, event in enumerate(program): + op, role, *args = event + need(type(role) is int and 0 <= role < capacity, "literal raw owner label") + if op == "INIT": + need(n <= role and role not in active and rows[role] is None, "new private owner") + need(0 <= args[0] < len(word["frames"]), "valid INIT chart") + charts[role] = args[0] + rows[role] = {} + active[role] = clock + peak = max(peak, len(active)) + continue + row = rows[role] + need(row is not None, "current live field") + if op == "MOVE": + a, b, owned = args + need(type(owned) is bool and owned == (role >= n) and a == charts[role] + and 0 <= b < len(word["frames"]), "literal owner and MOVE charts") + moves[clock], forms[clock] = (a, b), row + raw_moves[clock] = [role, a, b, owned, active.get(role)] + charts[role], rows[role] = b, {clock: Fraction(1)} + continue + need(charts[role] == args[-1], "literal scalar chart") + if op == "CLEAR": + need(role in active and str(clock) in certificates, f"certified private retirement {clock}") + relation = {} + sources = [] + for label, literal in sorted(certificates[str(clock)].items(), key=lambda item: int(item[0])): + field = int(label) + need(0 <= field < capacity and field != role and rows[field] is not None, + f"other live CLEAR witness source at {clock}") + factor = rational(literal) + accumulate(relation, rows[field], factor) + sources.append([field, charts[field], str(factor)]) + witnesses.append(Clear(clock, role, charts[role], active.pop(role), row, relation, sources)) + charts[role], rows[role] = None, None + elif op == "SCALE": + factor = rational(args[0]) + rows[role] = {token: coefficient * factor for token, coefficient in row.items()} + else: + donor, literal, _ = args + need(op == "ADD" and 0 <= donor < capacity and donor != role + and rows[donor] is not None and charts[donor] == charts[role], "other cocharted ADD") + accumulate(row, rows[donor], rational(literal)) + need(charts[:n] == end and all(value is None for value in charts[n:]) and not active, + "same public exit and complete private retirement") + need(peak == 51 and len(moves) == 6144 and len(witnesses) == len(certificates) == 235, + "complete native MOVE and CLEAR custody") + forms.update({first + r: rows[r] for r in range(n)}) + return Graph(first, start, end, moves, forms), witnesses, raw_moves + + +def span(basis): + values = {0} + for axis in basis: + need(type(axis) is int and 0 < axis < 512 and axis not in values, + "independent binary ordered chart") + values |= {axis ^ value for value in values} + return values + + +def contract(source, atlas, witnesses, raw_moves): + a, c, b = START, RELAY, END + need(raw_moves[REMOVE] == [ROLE,a,c,False,None] and raw_moves[KEEP] == [ROLE,c,b,False,None], + "literal route anchors and owner") + need(source.moves[REMOVE] == (a,c) and source.moves[KEEP] == (c,b) + and source.forms[KEEP] == {REMOVE: Fraction(1)}, "pure relay at the anchored paid reader") + readers = [key for key,row in source.forms.items() if REMOVE in row] + need(readers == [KEEP] and all(REMOVE not in clear.left and REMOVE not in clear.right for clear in witnesses), + "sole reader and no original CLEAR incidence") + basis_a,basis_c,basis_b = (atlas[x] for x in (a,c,b)) + need(span(basis_a) < span(basis_c) < span(basis_b) + and tuple(map(len,(basis_a,basis_c,basis_b))) == (3,6,9), "positive 3+3→6 chart nesting") + marks = { + "remove":REMOVE,"keep":KEEP,"charts":[a,c,b],"ranks":[3,3,6],"scale":"1", + "removed_raw_move":raw_moves[REMOVE],"surviving_raw_move_before":raw_moves[KEEP], + "direct_pair_already_paid":(a,b) in source.moves.values(), + "all_readers_of_removed":readers,"raw_clear_use_of_removed":False, + } + forms,moves = dict(source.forms),dict(source.moves) + forms[KEEP] = forms.pop(REMOVE) + del moves[REMOVE] + moves[KEEP] = (a,b) + return Graph(source.first,source.initial,source.final,moves,forms),marks + + +def serialized(graph, frames, kind, **extra): + metadata = { + "schema":"p104-exact-banked-dag/v1","kind":kind,"source_pr":7700,"source_pr_head":SOURCE_HEAD, + "source_word_sha256":WORD,"caller_sha256":CALLER, + "source_clear_certificates_sha256":CERTS,"reference_bank_head":DONOR_HEAD,**extra, + } + return canonical({ + "metadata":metadata,"frames":frames,"initial":graph.initial,"final":graph.final, + "first_output":graph.first,"moves":[[key,*route] for key,route in sorted(graph.moves.items())], + "forms":[[key,[[token,str(value)] for token,value in sorted(row.items())]] + for key,row in sorted(graph.forms.items())], + "schedule":graph.schedule(), + }) + + +def rebuild(): + word = json.loads(read("WORD.json.gz")) + certs = json.loads(read("CERTS.json")) + caller = json.loads(read("CALLER.json.gz")) + need(certs["candidate_canonical_sha256"] == WORD and caller["stages"] == 16 + and caller["ambient_rank"] == 137, "literal source and signed caller binding") + certificates = certs["clear_event_index"] + parent,witnesses,raw_moves = raw_fold(word,certificates) + child,mark = contract(parent,word["frames"],witnesses,raw_moves) + graphs = { + "PARENT-GRAPH.json.gz":serialized(parent,word["frames"],"parent"), + "CANDIDATE-GRAPH.json.gz":serialized(child,word["frames"],"candidate", + source_banked_graph_sha256=PARENT,paid_relay=mark), + } + for name,raw in graphs.items(): + need(raw == read(name), f"deterministic reconstruction of decoded {name}") + return word,certificates,parent,child,witnesses,mark,graphs + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out-dir", type=Path, help="Optional directory for regenerated gzip artifacts") + args = parser.parse_args() + *_,graphs = rebuild() + if args.out_dir: + for name,raw in graphs.items(): + with (args.out_dir/name).open("xb") as stream: + stream.write(gzip.compress(raw,mtime=0)) + print("PASS_CF6A_REBUILD", PARENT, CHILD) + + +if __name__=="__main__": + main() diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/interval_gate_signed.py b/research/interleaved-basis-residual-audit/retained/source/vendor/interval_gate_signed.py new file mode 100644 index 0000000000..2d8b9255d5 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/interval_gate_signed.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python3 +# PATCHED COPY of research/shared-wire-split-composition/interval_gate.py (see README.md and interval_gate.diff). +# Do not confuse with the pinned original, which is unchanged. +"""Independent certified fixed-grid intervals (80 decimal places). +ln via 2 atanh after binary range reduction; exp(-x) via alternating +Taylor brackets. Uses only integer floor/ceiling, not Decimal transcendents. +""" +from fractions import Fraction as F +from functools import lru_cache +from pathlib import Path +import json,argparse +if not __debug__: raise RuntimeError('Run without -O; assertions are proof checks.') +B=10**80 + +def ceildiv(a,b):return -((-a)//b) +def exact(q): + q=F(q);return q.numerator*B//q.denominator,ceildiv(q.numerator*B,q.denominator) +def add(a,b):return a[0]+b[0],a[1]+b[1] +def sub(a,b):return a[0]-b[1],a[1]-b[0] +def mul(a,b): + p=[a[i]*b[j] for i in (0,1) for j in (0,1)];return min(p)//B,ceildiv(max(p),B) +def div(a,b): + assert b[0]>0 + p=[F(a[i]*B,b[j]) for i in (0,1) for j in (0,1)] + return min(p).__floor__(),max(p).__ceil__() +def smul(a,q):return mul(a,exact(q)) +def atanh_log(y): + yi=exact(y);yy=mul(yi,yi);p=yi;s=(0,0) + for j in range(100):s=add(s,smul(p,F(2,2*j+1)));p=mul(p,yy) + # 0 <= tail <= 2 y^201/[201(1-y^2)] < 3*(1/3)^201. + return s[0],s[1]+ceildiv(3*B,3**201) +@lru_cache(None) +def log(r): + assert r>=1 + k=r.bit_length()-1;y=F(r-2**k,r+2**k) + a=atanh_log(y);b=atanh_log(F(1,3));return add(a,smul(b,k)) +def expminus(x): + assert 0<=x[0]<=x[1]0 and margins[str(hi)][1]<0 and margins[str(tested)][0]>0 + target=moment(T,tested);paid=moment(P,tested) + alpha=div(paid,target) + # Tail exponent = 1-tested+1/7; argument exp may not be negative. + # r^(1-tested+1/7)=r^(1-tested)* exp(log(r)/7). + def exppos(x): + assert 0<=x[0]<=x[1]0 and gap.numerator==1;step=gap.denominator + wins=lambda j:(step*j+1)**written<2**j + l,h=1,2 + while not wins(h):l,h=h,2*h + while h-l>1: + m=(l+h)//2 + if wins(m):h=m + else:l=m + assert wins(h) and not wins(h-1) + # Monotonicity: upper derivative bound on [0, cap]. + derivative=(0,0) + for rr in T.keys()|P.keys(): + c=T.get(rr,0)-P.get(rr,0);r=int(rr) + term=mul(power(r,cap if c>=0 else 0),log(r));derivative=add(derivative,smul(term,-c)) + assert derivative[1]<0 + result=dict(claim=str(claim),tested=str(tested),raw_bracket=[str(lo),str(hi)],moment_margins={k:show(v) for k,v in margins.items()},moment_margin_float={k:value(v) for k,v in margins.items()},derivative_upper=float(F(derivative[1],B)),alpha=value(alpha),gamma=value(gamma),delta=value(delta),minimum_log_power=lp,written_log_power=written,compiler_gap=str(gap),H=str(step*h),BIT_pin=str(cap),BIT_margin=str(cap-tested)) + # Outer formulas evaluated independently after algebraically substituting + # b=k+5g,a=k+4g,q=k+3g,epsilon=1-g,beta=1-3g. + k=claim;g=gap;b=k+5*g;a=k+4*g;q=k+3*g;ep=1-g;be=1-3*g;r0=g/10;stop=layout=g + sig=1-b;tau=1-a;internal=tau+(1-stop)*max(sig-tau,0);leaf=sig+stop*(1-sig);lam=1-(q+a)/2;xi=ep*(1+q)-F(3,32)+layout;key=be+1-ep + M=[ep*q,a,1-ep+q*be,1-ep+a*be,1-ep+be,F(3,32)+xi-ep,xi+F(1,2)-ep,ep,1-(ep+be+48-128+2)] + checks=[cap-a,b-a,q,b-q,a-q,stop,1-stop,(1-stop)*b-a,1-internal-q,1-leaf-q,lam-tau,lam-sig,lam-internal,1-q-lam,1-q-leaf,ep,1-ep,xi-F(1,2),ep-xi,be,ep-be,1-be,1-(2*xi-2)-r0-be,1-(2*xi-2)-be,1-ep-r0,1-ep,r0,1-key,1-be-2*(1-ep),128-48-be,layout,ep-a,F(1,32)-b,F(2**45-7**16),F(2),2-xi,F(5),1-be,1-be,1-ep,M[2]-M[0],g,k-F('.001730970419199163702738'),1-ep,F(11,2)]+[x-k for x in M] + functional=[1-be,be*(1-F(3,1000)),128-48-ep-be-1,be*(1-F(1,250))] + assert len(checks)==54 and len(functional)==4 and min(checks+functional)>0 + result['outer']=dict(strict_count=54,functional_count=4,minimum_margin=str(min(checks+functional)),BIT_just_below_effective_rejected=(a-F(1,10**12))-a<0) + # Input-lift is only needed on [1-tested_complex,1]. + # L(k)=sum_pos r^(1-k)-sum_neg r^(1-k); L(0)=0; L'(0)=-d1; + # L''(k)=sum_pos r ln^2 r r^-k - sum_neg r ln^2 r r^-k >= -N for k>=0, + # where N=sum_neg r ln^2 r (the positive part is >=0 and r^-k<=1 for r>=1). + # Hence L'(k)>=-d1-kN and L(k)>=-k d1-k^2 N/2. Only the NEGATIVE-coefficient + # curvature enters (signed bound); |.| over both parts was valid but loose. + pos={7:1,3:1,5:1};neg={9:1,4:1,1:2};d1=(0,0);curvature=(0,0);abs_curvature=(0,0) + for hist,sign in ((pos,1),(neg,-1)): + for r,c in hist.items(): + d1=add(d1,smul(log(r),sign*c*r)) + abs_curvature=add(abs_curvature,smul(mul(log(r),log(r)),c*r)) + if sign<0:curvature=add(curvature,smul(mul(log(r),log(r)),c*r)) + assert curvature[0]>=0 + lift_cap=cap if cap<=LIFT_RANGE else tested + assert tested<=lift_cap and F(d1[1],B)+lift_cap*F(curvature[1],B)<0 + lifts={} + for price in (claim,tested): + lift=sub(moment(pos,price),moment(neg,price));assert lift[0]>0 + assert price*(-F(d1[1],B))-price*price*F(curvature[1],B)/2>0 + lifts[str(price)]=show(lift) + result['input_lift']=dict(margins=lifts,interval_kappa_cap=str(lift_cap),derivative_upper_on_required_interval=str(F(d1[1],B)+lift_cap*F(curvature[1],B)),signed_curvature_upper=str(F(curvature[1],B)),absolute_curvature_upper=str(F(abs_curvature[1],B)),signed_derivative_ceiling=str(-F(d1[1],B)/F(curvature[1],B))) + return result +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('audit');p.add_argument('--claim',default='.00362852408');p.add_argument('--tested',default='.00362852408007');p.add_argument('--lower',default='.00362852408398727978896072723289');p.add_argument('--upper',default='.00362852408398727978896072723290');p.add_argument('--out',required=True);p.add_argument('--bit-pin',default=BIT_PIN);a=p.parse_args() + r=gate(json.loads(Path(a.audit).read_text())['invoice'],a.claim,a.tested,a.lower,a.upper,a.bit_pin);Path(a.out).write_text(json.dumps(r,indent=2)+'\n');print(json.dumps(r,indent=2)) diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/network.py b/research/interleaved-basis-residual-audit/retained/source/vendor/network.py new file mode 100644 index 0000000000..0ebc1925c4 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/network.py @@ -0,0 +1,217 @@ +"""Construct the communication circuit and apply the rational pivots.""" +from dataclasses import dataclass +from fractions import Fraction +from functools import cache +from graphlib import TopologicalSorter +from hashlib import sha1, sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +PARENT = "ee251f6005d2a92b887c5b804bd7aac05989d278b2c9ccb3c3091b50d533b08d" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def encoded(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def source_word(): + for pin in read(HERE / "SOURCE-PINS.json"): + raw = (HERE / pin["file"]).read_bytes() + need(sha256(raw).hexdigest() == pin["sha256"], "source SHA-256") + need(sha1(f"blob {len(raw)}\0".encode() + raw).hexdigest() == pin["git_blob"], "source Git blob") + base = read(HERE / "source/K372-2-WORD.json.gz") + patch = read(HERE / "source/source-edits.json") + need(sha256(encoded(base)).hexdigest() == patch["source"], "source edit origin") + result = [] + cursor = 0 + for edit in patch["edits"]: + start, stop = edit["start"], edit["stop"] + need(cursor <= start <= stop <= len(base["program"]), "source edit range") + need(base["program"][start:stop] == edit["before"], "source edit preimage") + result.extend(base["program"][cursor:start]) + result.extend(edit["after"]) + cursor = stop + result.extend(base["program"][cursor:]) + word = dict(base, program=result) + need(sha256(encoded(word)).hexdigest() == patch["candidate"] == PARENT, "parent word") + return word + + +def main_roles(word): + h = word["hosted"] + return set(word["live"]) | {i + 112 for i in word["live"]} | set(h["X2"]) | set(h["Y2"]) + + +@cache +def rational(literal): + return Fraction(literal) + + +def add_scaled(row, donor, factor): + for index, value in donor.items(): + new = row.get(index, 0) + factor * value + if new: + row[index] = new + else: + row.pop(index, None) + + +@dataclass +class Network: + first_output: int + initial: list + final: list + moves: dict + forms: dict + + def schedule(self): + for node, form in self.forms.items(): + chart = self.moves[node][0] if node < self.first_output else self.final[node - self.first_output] + for donor in form: + if donor < 0: + need(0 <= ~donor < len(self.initial), "input owner") + donor_chart = self.initial[~donor] + else: + need(donor in self.moves, "missing donor") + donor_chart = self.moves[donor][1] + need(donor_chart == chart, "nonlocal scalar") + need(set(self.forms) == self.moves.keys() | set(range(self.first_output, self.first_output + len(self.final))), + "output inventory") + dependencies = {node: sorted(i for i in self.forms[node] if i >= 0) for node in sorted(self.forms)} + return list(TopologicalSorter(dependencies).static_order()) + + def transpose(self): + def reverse(node): + if node < 0: + return self.first_output + ~node + if node >= self.first_output: + return ~(node - self.first_output) + return node + + edges = {k: {} for k in self.moves} + edges.update({self.first_output + r: {} for r in range(len(self.initial))}) + for node, form in self.forms.items(): + for donor, coefficient in form.items(): + edges[reverse(donor)][reverse(node)] = coefficient + moves = {k: (b, a) for k, (a, b) in self.moves.items()} + return Network(self.first_output, self.final, self.initial, moves, edges) + + +def fold(word): + n = word["public"] + rows = [{~r: 1} for r in range(n)] + [None] * word["owned_fields"] + charts = word["initial"][:] + [None] * word["owned_fields"] + forms, moves = {}, {} + for clock, event in enumerate(word["program"]): + op, r = event[:2] + if op == "INIT": + need(r >= n and rows[r] is None, "private birth") + rows[r], charts[r] = {}, event[2] + continue + need(rows[r] is not None, "inactive register") + if op == "MOVE": + _, _, a, b, owned = event + need(charts[r] == a and owned == (r >= n), "original transfer") + moves[clock], forms[clock] = (a, b), rows[r] + rows[r], charts[r] = {clock: 1}, b + else: + need(charts[r] == event[-1], "original scalar chart") + if op == "CLEAR": + need(r >= n, "public retirement") + rows[r], charts[r] = None, None + elif op == "SCALE": + rows[r] = {k: v * rational(event[2]) for k, v in rows[r].items()} + else: + need(op == "ADD" and event[2] != r and charts[event[2]] == charts[r], "original donor") + add_scaled(rows[r], rows[event[2]], rational(event[3])) + need(charts[:n] == word["final"] and all(f is None for f in charts[n:]), "original exit") + first = len(word["program"]) + forms.update({first + r: rows[r] for r in range(n)}) + return Network(first, word["initial"], word["final"], moves, forms) + + +def coefficients(entries): + result = {k: rational(v) for k, v in entries} + need(len(entries) == len(result) and all(result.values()), "sparse coefficient list") + return result + + +def pivot(net, edit): + drop, lead = edit["remove"], edit["pivot"] + combination = coefficients(edit["combination"]) + sender = coefficients(edit["sender"]) + side = coefficients(edit["receiver"]) + need(lead in combination and drop in net.moves and lead in net.moves, "pivot slots") + _, middle = net.moves[drop] + old, destination = net.moves[lead] + uses = {m: row[drop] for m, row in net.forms.items() if drop in row} + need(old == middle and combination.keys() <= uses.keys(), "pivot combination") + need(all(net.moves.get(m) == (middle, destination) for m in uses), "shared destination") + aggregate = {} + for m, weight in combination.items(): + add_scaled(aggregate, net.forms[m], weight) + response = aggregate.get(drop, 0) + need(response, "zero pivot response") + + forms = net.forms.copy() + del forms[drop] + forms[lead] = sender + for m, weight in uses.items(): + if m != lead: + residual = net.forms[m].copy() + add_scaled(residual, aggregate, -Fraction(weight, response)) + need(drop not in residual, "uncancelled transfer") + forms[m] = residual + + combined = {lead: 1} + add_scaled(combined, side, -1) + recovered = {} + for m, weight in uses.items(): + if m == lead: + row = {k: -v / combination[lead] for k, v in combination.items() if k != lead} + else: + row = {m: 1} + add_scaled(row, combined, Fraction(weight, response)) + recovered[m] = row + for k, row in list(forms.items()): + affected = row.keys() & recovered.keys() + if affected: + new = {i: v for i, v in row.items() if i not in affected} + for i in affected: + add_scaled(new, recovered[i], row[i]) + forms[k] = new + moves = net.moves.copy() + del moves[drop] + moves[lead] = (edit["source_chart"], destination) + return Network(net.first_output, net.initial, net.final, moves, forms) + + +def networks(word): + parent = fold(word) + net = parent + receipts = [] + for edit in read(HERE / "PIVOTS.json"): + direction = edit["direction"] + need(direction in ("forward", "transpose"), "pivot direction") + if direction == "transpose": + net = net.transpose() + before = len(net.moves) + net = pivot(net, edit) + if direction == "transpose": + net = net.transpose() + net.schedule() + need(len(net.moves) == before - 1, "paid slot count") + receipts.append([direction, edit["remove"], edit["pivot"], len(net.moves)]) + return parent, net, receipts diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/physical.py b/research/interleaved-basis-residual-audit/retained/source/vendor/physical.py new file mode 100644 index 0000000000..e7c4e5798b --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/physical.py @@ -0,0 +1,868 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact grids and occupied bank schedules for the cf6a banked relay. + +Adapt the guarded bank and exact-root accounting of #7697, based on #7682. +The graph folds the supplied #7700 tape and contracts its role-1256 relay. +""" + +from argparse import ArgumentParser +from collections import Counter +from fractions import Fraction +import gzip +from hashlib import sha256 +import importlib.util +import json +from math import gcd, lcm +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +PEER = "72705b094d83d2ba24006661bbb031786a691b776bedb94515b1321e1535105f" +CANDIDATE = "8e7b755bd2d2d387bc3d3adfe48100985adf74775ca5acbb143170a3d16b5ccf" +SOURCE_WORD = "ae62d5d8bef6f7146454b4b3643e487a58380c606a16c5baef7bf0dcf9df1472" +SOURCE_HEAD = "7d84799a447867d36137d12ef7ca5646154d763c" +SOURCE_CERTS = "39ef28b708cd8bf1166b111d656809407b370dd11cd81a8e43820779f995aca3" +CALLER = "62d94fb992acab0a71c3d12f22be4ce63f4f65e5cbe3f420b93aa1393ffa8dcf" +CALLER_REPLAY = "ced48867f07ca0143604aa98cfd74fa7453696b9d3221f7c230d73e9ab9ba81f" +STAGES = 16 +CALLER_ODD = 2025 +COMPILER_H = 14571800000000000000 +AMBIENT_CAP = 153 +PROTECTED_HELPERS = (325, 1087) +OLD_NATIVE_STOCK = 15290 +REMOVED, SURVIVOR = 95828, 104442 +RELAY_ROLE = 1256 +RELAY_CHARTS = (476, 878, 127) +PAYLOAD_AXES = 4 + + +def require(condition, reason): + if not condition: + raise ValueError(reason) + + +def encoded(data): + return json.dumps(data, sort_keys=True, separators=(",", ":")).encode() + + +def load_gzip(path, pin, *, canonical=True): + packed = path.read_bytes() + raw = gzip.decompress(packed) + require(sha256(raw).hexdigest() == pin, f"wrong decoded hash for {path.name}") + data = json.loads(raw) + require(not canonical or encoded(data) == raw, f"noncanonical data for {path.name}") + return data, sha256(packed).hexdigest() + + +def chart_span(basis): + span = {0} + for axis in basis: + require(type(axis) is int and 0 < axis < 512 and axis not in span, + "invalid independent ordered chart basis") + span |= {axis ^ vector for vector in span} + return span + + +def exact_coefficient(text): + value = Fraction(text) + require(value and str(value) == text, "noncanonical or zero scalar incidence") + return value + + +def exact_div(value, denominator): + result, remainder = divmod(value, denominator) + require(remainder == 0, "nonintegral scalar pre-product") + return result + + +def grid_parts(grid): + height = (grid & -grid).bit_length() - 1 + return grid >> height, height + + +def ceiling_bits(value): + return (-(-value.numerator // value.denominator)).bit_length() + + +def public_interface(graph, layout): + n = len(graph["initial"]) + require(layout["public"] == n == len(graph["final"]) == 1501 + and len(layout["live"]) == len(layout["ports"]) == 104, + "complete public and port denominators") + hosted = layout["hosted"] + hosted_ports = set(hosted["Dports"]) + second_planes = list(zip(hosted["X2"], hosted["Y2"], strict=True)) + require(len(hosted_ports) == len(second_planes) == 96, "actual 96 hosted ports") + live = layout["live"] + mains = set(live) | {role + 112 for role in live} | set(hosted["X2"]) | set(hosted["Y2"]) + require(len(mains) == 400 and mains <= set(range(n)), "400 distinct real main slots") + for port, (x, q) in enumerate(zip(live, layout["ports"], strict=True)): + y = x + 112 + initial, final = graph["initial"], graph["final"] + frames = graph["frames"] + require(frames[initial[x]] == [q] and frames[initial[y]] == [] + and frames[final[x]] == [1 << j for j in range(9)] + and len(frames[final[y]]) == 8 + and all((v & q).bit_count() % 2 == 0 for v in frames[final[y]]), + f"main binding at port {port}") + for position, pair in zip(hosted["Dports"], second_planes, strict=True): + original = (live[position], live[position] + 112) + require(all(graph[boundary][a] == graph[boundary][b] + for boundary in ("initial", "final") for a, b in zip(original, pair)), + "separate hosted main partners in the same charts") + require(all(r not in mains and (graph["initial"][r], graph["final"][r]) == (3, 237) + for r in PROTECTED_HELPERS), "fixed rank-four same-owner helper boundaries") + return mains, hosted_ports, second_planes + + +def expected_rows(n, layout, interface, unit): + mains, hosted, second = interface + rows = [{r: unit} for r in range(n)] + for port, x in enumerate(layout["live"]): + y = x + 112 + if port in hosted: + rows[y][x] = unit + else: + rows[x][y] = -unit + rows[y] = {x: exact_div(unit, 2), y: exact_div(unit, 2)} + for x, y in second: + rows[x][y] = -unit + require(all(r in mains or row == {r: unit} for r, row in enumerate(rows)), + "independent arbitrary helper definition") + return rows + + +def graph_inputs(graph): + n = len(graph["initial"]) + first = graph["first_output"] + require(n == 1501 and first == 154768, "stable paid and public namespace") + moves = {key: (a, b) for key, a, b in graph["moves"]} + rows = {key: [(donor, exact_coefficient(coef)) for donor, coef in terms] + for key, terms in graph["forms"]} + terminal_keys = set(range(first, first + n)) + order = graph["schedule"] + require(len(moves) == len(graph["moves"]) and all(0 <= key < first for key in moves), + "exact positive paid slots") + require(len(rows) == len(graph["forms"]) == len(moves) + n + and set(rows) == moves.keys() | terminal_keys and moves.keys().isdisjoint(terminal_keys) + and len(order) == len(rows) and set(order) == rows.keys(), + "exact held-bank schedule denominator") + require(all([donor for donor, _ in row] == sorted({donor for donor, _ in row}) + for row in rows.values()), "unique donor keys in literal scalar order") + return moves, rows + + +def graph_bounds(graph, moves, rows, mains): + frames = graph["frames"] + spans = list(map(chart_span, frames)) + starts, ends = graph["initial"], graph["final"] + first = graph["first_output"] + n = len(starts) + require(all(type(chart) is int and 0 <= chart < len(spans) for chart in (*starts, *ends)), + "valid public charts") + + def rank(a, b, helper=False): + require(0 <= a < len(spans) and 0 <= b < len(spans), "valid paid chart IDs") + require(spans[a] < spans[b] or (not helper and spans[b] < spans[a]), + "strictly nested positive paid or helper charts") + return abs(len(frames[b]) - len(frames[a])) + + paid = Counter(rank(a, b) for a, b in moves.values()) + productive = Counter(rank(starts[r], ends[r], helper=True) for r in range(n) if r not in mains) + available = {~r: (chart, 1, Fraction(1)) for r, chart in enumerate(starts)} + grid, peak_mass, peak_node = 1, Fraction(1), None + for key in graph["schedule"]: + a = moves[key][0] if key in moves else ends[key - first] + row_grid, mass = 1, Fraction() + for donor, q in rows[key]: + require(donor in available and available[donor][0] == a, + f"donor unavailable or in wrong chart at row {key}") + _, divisor, weight = available[donor] + row_grid = lcm(row_grid, divisor * q.denominator) + mass += abs(q) * weight + grid = lcm(grid, row_grid) + if mass > peak_mass: + peak_mass, peak_node = mass, key + if key in moves: + available[key] = (moves[key][1], row_grid, mass) + odd, height = grid_parts(grid) + return { + "public": n, "slots": len(moves), "terms": sum(map(len, rows.values())), + "path_grid": grid, "path_grid_odd": odd, "path_grid_height": height, + "positive_path_mass_bound_unscaled": str(peak_mass), + "positive_path_mass_peak_node": peak_node, + "paid_native_ranks": dict(paid), "positive_helper_ranks": dict(productive), + } + + +def exact_basis_grid(graph, moves, rows, grid, expected): + """Check every separate rational product, prefix and installed basis row.""" + values = {~r: {r: grid} for r in range(len(graph["initial"]))} + product_gcd = snapshot_gcd = grid + odd_factors = {} + for prime in (3, 5): + reduced = grid + while reduced % prime == 0: + reduced //= prime + require(reduced < grid, f"missing expected odd prime {prime}") + odd_factors[prime] = grid // reduced + off_grid_controls = {} + n_checks = nontrivial = 0 + divisors = Counter() + peak_absolute = grid + for key in graph["schedule"]: + row, row_bound = {}, 0 + for donor, q in rows[key]: + a, b = q.numerator, q.denominator + n_checks += len(values[donor]) + nontrivial += len(values[donor]) if b != 1 else 0 + if b != 1: + divisors[b] += len(values[donor]) + for column, value in values[donor].items(): + product = exact_div(a * value, b) + product_gcd = gcd(product_gcd, product) + if len(off_grid_controls) < len(odd_factors): + for prime, factor in odd_factors.items(): + if prime not in off_grid_controls and product % factor: + require(value % factor == 0, "first under-scaled donor already off grid") + reduced_numerator = a * (value // factor) + require(reduced_numerator % b, "removed odd factor must cause a literal DIV fault") + off_grid_controls[prime] = { + "row": key, "donor": donor, "entrance_column": column, + "coefficient": str(q), "removed_factor": factor, + "numerator_without_factor": reduced_numerator, "denominator": b, + "positive_remainder": reduced_numerator % b, + } + row_bound += abs(product) + result = row.get(column, 0) + product + if result: + row[column] = result + else: + row.pop(column, None) + peak_absolute = max(peak_absolute, row_bound) + for value in row.values(): + snapshot_gcd = gcd(snapshot_gcd, value) + if key in moves: + values[key] = row + else: + require(row == expected[key - graph["first_output"]], f"wrong normalized endpoint {key}") + return { + "coefficient_products": n_checks, "checked_nontrivial_divisions": nontrivial, + "checked_nontrivial_divisions_by_denominator": dict(divisors), + "exact_all_public_rows": len(expected), + "minimum_product_grid": grid // product_gcd, "minimum_snapshot_grid": grid // snapshot_gcd, + "maximum_exact_row_prefix_mass_scaled": str(Fraction(peak_absolute, 1 << grid_parts(grid)[1])), + "missing_odd_factor_controls": off_grid_controls, + } + + +class HeldBank: + """Finite extent fixture with typed payloads and separately guarded streams.""" + + def __init__(self, homes): + self.homes = homes + self.blank = (None, None, (0,) * PAYLOAD_AXES) + self.left_guard = object() + self.right_guard = object() + self.dummy = object() + self.left = self.left_guard + self.right = self.right_guard + self.slots = [self.dummy] + [ + (("dirty", slot), -1, tuple((-1)**axis * (slot + axis) for axis in range(PAYLOAD_AXES))) + for slot in range(1, homes + 1) + ] + self.head = 0 + self.operations = Counter() + self.overwritten_cells = Counter() + self.trace = sha256() + # GET restores the selector head. Its complete donor and the running + # accumulator have independent backing throughout the term. + self.streams = {name: None for name in ("accumulator", "donor", "product", "quotient")} + self.stream_resets = 0 + + def access(self, slot, operation, replacement=None, *, require_blank=False, clear=False): + require(self.head == 0 and 1 <= slot <= self.homes, "bad guarded bank selection") + self.head = slot + try: + old = self.slots[slot] + require(not require_blank or old == self.blank, + "send or install before previous full owner extent cleared") + if clear: + require(replacement is None and len(old[2]) == PAYLOAD_AXES, "wrong reset extent") + # Scan every addressed payload cell without inspecting its + # value or treating a normalized zero as a reset. + cleared = tuple(0 for _ in old[2]) + self.slots[slot] = (None, None, cleared) + self.overwritten_cells[operation] += len(cleared) + if replacement is not None: + require(len(replacement[2]) == PAYLOAD_AXES, "wrong staged copy extent") + tag, chart, payload = replacement + self.slots[slot] = (tag, chart, tuple(cell for cell in payload)) + self.operations[operation] += 1 + self.trace.update(encoded([operation, slot, old[0], replacement[0] if replacement else None])) + return old + finally: + self.head = 0 + + def reset_stream(self, name): + live = self.streams[name] + if live is not None: + require(len(live) == PAYLOAD_AXES, "wrong stream reset extent") + self.streams[name] = None + self.stream_resets += 1 + + def close(self): + require(self.head == 0 and self.slots[0] is self.dummy + and self.left is self.left_guard and self.right is self.right_guard + and all(slot == self.blank for slot in self.slots[1:]) + and all(stream is None for stream in self.streams.values()), + "packed bank and four stream retirement") + + +def rejected_write(bank, slot, record, control_operation): + try: + bank.access(slot, control_operation, record, require_blank=True) + except ValueError as failure: + require(str(failure) == "send or install before previous full owner extent cleared" + and bank.head == 0, "wrong dirty or outstanding-sender control failure") + else: + raise ValueError("dirty or held payload accepted as blank") + + +def partial_clear_control(): + bank = HeldBank(2) + old_unselected = bank.slots[2] + # A missing final address remains dirty even though the tag, chart, and + # all earlier positions have been cleared. + bank.slots[1] = (None, None, (0,) * (PAYLOAD_AXES - 1) + (17,)) + record = (("fresh", 0), 3, (1,) * PAYLOAD_AXES) + rejected_write(bank, 1, record, "partial_clear_fault") + residue = bank.access(1, "clear_every_address", clear=True) + require(residue[2][-1] == 17 and bank.slots[1] == bank.blank and bank.slots[2] == old_unselected, + "complete overwrite must remove the residual and preserve neighbors") + bank.access(1, "accepted_after_full_clear", record, require_blank=True) + return {"dirty_unaddressed_last_cell_rejected": True, "neighbor_unchanged": True} + + +def held_schedule(graph, moves, rows, grid, expected, control=False): + n, k, first = len(graph["initial"]), len(moves), graph["first_output"] + entrance = {~r: r + 1 for r in range(n)} + returned = {key: n + i + 1 for i, key in enumerate(sorted(moves))} + terminal = {first + r: n + k + r + 1 for r in range(n)} + sender = 2*n + k + 1 + scratch = range(sender + 1, sender + 5) + allocated = set(entrance.values()) | set(returned.values()) | set(terminal.values()) | {sender} | set(scratch) + require(allocated == set(range(1, 2*n + k + 6)), "injective bank home plan") + bank = HeldBank(len(allocated)) + odd = grid_parts(grid)[0] + binary_grid = grid // odd + public = [ + (("public", r), chart, tuple( + binary_grid * ((r * (719 - 41*axis) + 29 + 37*axis) % 127 - 63) + for axis in range(PAYLOAD_AXES) + )) + for r, chart in enumerate(graph["initial"]) + ] + original_public = public.copy() + for slot in sorted(allocated): + old = bank.access(slot, "initialize_complete_dirty_home", clear=True) + require(all(old[2]), "every initial fixture address must be dirty") + for r, (_, chart, value) in enumerate(public): + scaled = tuple(x * odd for x in value) + bank.access(entrance[~r], "write_entrance", (("entry", r), chart, scaled), require_blank=True) + known = dict(entrance) + installed = set() + outstanding = None + attempted_early_reuse = False + + for key in graph["schedule"]: + paid = key in moves + source, destination = moves[key] if paid else (graph["final"][key - first], None) + require(bank.streams["accumulator"] is None, "running accumulator already occupied") + bank.streams["accumulator"] = (0,) * PAYLOAD_AXES + for donor, q in rows[key]: + require(donor in known, "read before donor RETURN") + tag, chart, value = bank.access(known[donor], "read_immutable_donor") + require(tag == (("entry", ~donor) if donor < 0 else ("returned", donor)) + and chart == source, "wrong owner or chart at guarded GET") + require(all(bank.streams[name] is None for name in ("donor", "product", "quotient")), + "term workspace was live before GET") + bank.streams["donor"] = tuple(cell for cell in value) + bank.streams["product"] = tuple(q.numerator * x for x in bank.streams["donor"]) + bank.streams["quotient"] = tuple(exact_div(x, q.denominator) for x in bank.streams["product"]) + bank.streams["accumulator"] = tuple(a + b for a, b in zip( + bank.streams["accumulator"], bank.streams["quotient"], strict=True)) + for name in ("donor", "product", "quotient"): + bank.reset_stream(name) + value = bank.streams["accumulator"] + if paid: + require(outstanding is None and key not in known, "invalid new native sender") + bank.access(sender, "initialize_empty_sender_before_departure", require_blank=True, clear=True) + record = (("sender", key), source, value) + bank.access(sender, "stage_full_sender", record, require_blank=True) + outstanding = key + if control and key == SURVIVOR: + rejected_write(bank, sender, (("sender", key + 1), source, value), "early_sender_fault") + require(bank.slots[sender] == record and key not in known and bank.slots[returned[key]] == bank.blank, + "fault disturbed the parked sender or exposed an incomplete return") + attempted_early_reuse = True + held_tag, held_chart, held_value = bank.access(sender, "read_parked_sender") + require(outstanding == key and held_tag == ("sender", key) and held_chart == source, + "parked sender must survive until shape and complete return") + # Native checks supply both complete adapters and the paid + # Gaussian child. Their normalized composite preserves this value. + returned_record = (("returned", key), destination, held_value) + bank.access(returned[key], "write_complete_return", returned_record, require_blank=True) + bank.access(sender, "clear_full_sender_after_return", clear=True) + require(bank.head == 0, "sender head not restored after full retirement") + outstanding = None + known[key] = returned[key] + else: + role = key - first + bank.access(terminal[key], "write_terminal", (("terminal", role), source, value), require_blank=True) + bank.reset_stream("accumulator") + + require(outstanding is None and len(known) == n+k and public == original_public, + "all full public entrances must remain intact throughout the native schedule") + for role in range(n): + tag, chart, values = bank.access(terminal[first + role], "read_terminal_for_same_owner_install") + predicted = tuple(exact_div( + sum(q * original_public[i][2][axis] for i, q in expected[role].items()), grid) + for axis in range(PAYLOAD_AXES)) + unscaled = tuple(exact_div(value, odd) for value in values) + require(tag == ("terminal", role) and chart == graph["final"][role] and unscaled == predicted, + "wrong extent, chart, value or same-owner terminal install") + public[role] = (("public", role), chart, unscaled) + installed.add(role) + bank.trace.update(encoded(["public_install_and_unscale", role, chart])) + require(installed == set(range(n)) and all( + record[:2] == (("public", role), graph["final"][role]) for role, record in enumerate(public)), + "every public owner fully installed exactly once") + for slot in sorted(allocated): + bank.access(slot, "retire_complete_home", clear=True) + bank.close() + terms = sum(map(len, rows.values())) + wanted = { + "initialize_complete_dirty_home": len(allocated), "write_entrance": n, + "read_immutable_donor": terms, "initialize_empty_sender_before_departure": k, + "stage_full_sender": k, "read_parked_sender": k, "write_complete_return": k, + "clear_full_sender_after_return": k, "write_terminal": n, + "read_terminal_for_same_owner_install": n, "retire_complete_home": len(allocated), + } + resets = { + op: count * PAYLOAD_AXES for op, count in wanted.items() + if op in {"initialize_complete_dirty_home", "initialize_empty_sender_before_departure", + "clear_full_sender_after_return", "retire_complete_home"} + } + require(bank.operations == wanted and bank.overwritten_cells == resets + and bank.stream_resets == 3*terms+k+n, "complete independent selected replay counts") + return { + "numerical_homes": len(allocated), "guarded_dummy_slots": 1, "separate_guide_tracks": 1, + "max_outstanding_native_senders": 1, "declared_senders": 1, + "immutable_entry_banks": n, "immutable_paid_return_banks": k, + "deferred_terminal_banks": n, "native_scalar_scratch_homes": 4, + "additional_independent_guarded_streams": len(bank.streams), + "trace_sha256": bank.trace.hexdigest(), "selected_logical_operations": dict(bank.operations), + "fixture_addressed_cells_per_home": PAYLOAD_AXES, + "fixture_addressed_cells_overwritten": dict(bank.overwritten_cells), + "tracked_stream_reset_visits": bank.stream_resets, + "same_owner_complete_fixture_outputs": len(installed), "exact_odd_unscale_outputs": len(installed), + "retired_and_guards_restored": True, "live_sender_alias_control_rejected": attempted_early_reuse, + "all_public_inputs_preserved_until_final_installs": True, + } + + +def scalar_service(value, coefficient, signed_width): + """Finite signed carry, quotient, exact remainder and padded installation.""" + a, b = abs(coefficient.numerator), coefficient.denominator + magnitude = abs(value) + require(magnitude.bit_length() < signed_width, "input width") + padding = signed_width + 26 + carry, bits = 0, [] + for j in range(padding): + carry += a * ((magnitude >> j) & 1) + bits.append(carry & 1) + carry >>= 1 + require(carry == 0, "padded product overflow") + quotient = remainder = 0 + for bit in reversed(bits): + trial = 2 * remainder + bit + next_bit = int(trial >= b) + remainder = trial - next_bit * b + quotient = (quotient << 1) | next_bit + require(remainder == 0, "physical remainder") + require(quotient.bit_length() < signed_width, "installed scalar overflow") + return -quotient if (value < 0) != (coefficient.numerator < 0) else quotient + + +def scalar_cases(graph_rows, caller, scales): + factors = {factor for rows in graph_rows for row in rows.values() for _, factor in row} + factors.update(Fraction(event[-1]) for event in caller["events"] + if event[0] != "J" and event[1] in ("ADD", "SCALE")) + factors.update((Fraction(-1), Fraction(1), Fraction(-1, 2), Fraction(1, 2))) + for scale in scales: + factors.update((Fraction(scale), Fraction(1, scale), Fraction(-1, scale))) + bits = max(max(abs(q.numerator).bit_length(), q.denominator.bit_length()) for q in factors) + require(bits <= 24, "all literal scalar and division conversions fit W+26") + cases = 0 + for coefficient in sorted(factors): + for k in (0, -127, -1, 1, 19, (1 << 68) + 1): + value = k * coefficient.denominator + signed_width = max(3, abs(value).bit_length()+2, abs(k * coefficient.numerator).bit_length()+2) + require(scalar_service(value, coefficient, signed_width) == k * coefficient.numerator, + "fixed scalar sign/carry/remainder or installation") + cases += 1 + rejected_denominators = (2, 3, 5, 7) + for denominator in rejected_denominators: + try: + scalar_service(1, Fraction(-1, denominator), 3) + except ValueError as failure: + require(str(failure) == "physical remainder", "wrong inexact scalar rejection") + else: + raise ValueError("nonintegral scalar installed") + return {"distinct_scalar_and_conversion_factors": len(factors), "signed_bit_transducer_cases": cases, + "coefficient_bits": bits, "rejected_one_tick_denominators": rejected_denominators, + "retained_max_bits": 24, "component_padding": 26} + + +def caller_envelope(caller): + """Majorize raw caller products with no cancellation or operator commutation.""" + roles = [(0, Fraction(1)) for _ in range(caller["roles"])] + max_height, max_mass = 0, Fraction(1) + pre_height, pre_mass = 0, Fraction(1) + visits = Counter() + + def observe(*values): + nonlocal max_height, max_mass + for height, mass in values: + max_height = max(max_height, height) + max_mass = max(max_mass, mass) + + def scale(value, factor): + height, mass = value + return height + grid_parts(factor.denominator)[1], abs(factor) * mass + + def add(first, second): + return max(first[0], second[0]), first[1] + second[1] + + stages = [] + for event in caller["events"]: + if event[0] == "J": + _, stage, (x, y, u, v), (a, b, alpha, beta) = event + require((Fraction(alpha), Fraction(beta)) == (-1, Fraction(1, 2)), + "exact signed joint envelope coefficients") + stages.append(stage) + pre_height = max(pre_height, *(roles[j][0] for j in (x, y, u, v, a, b))) + pre_mass = max(pre_mass, *(roles[j][1] for j in (x, y, u, v, a, b))) + roles[y], roles[u] = add(roles[y], roles[x]), add(roles[u], roles[v]) + old_a, old_b = roles[a], roles[b] + roles[a] = add(old_a, old_b) + roles[b] = add(scale(old_a, Fraction(1, 2)), scale(old_b, Fraction(1, 2))) + observe(roles[y], roles[u], roles[a], roles[b]) + continue + kind, op, role, *args = event + visits[op] += len(caller["types"][kind]["ports"]) + if op == "ADD": + term = scale(roles[args[0]], Fraction(args[-1])) + roles[role] = add(roles[role], term) + observe(term) + elif op == "SCALE": + roles[role] = scale(roles[role], Fraction(args[-1])) + elif op == "SWAP": + donor = args[0] + roles[role], roles[donor] = roles[donor], roles[role] + elif op == "QUERY": + roles[role] = add(roles[role], roles[args[0]]) + elif op == "LAMBDA": + height, mass = roles[role] + # (1 ± i)/2 and (1 ∓ i)/2 each have Gaussian l1 norm one. + roles[role] = height + 1, 2 * mass + else: + require(op in {"IDLE_ONE", "IDLE_ODD"}, "unknown signed caller operation") + observe(roles[role]) + require(stages == list(range(1, STAGES+1)), "complete exact 16-stage raw schedule") + return { + "records": len(caller["events"]), "stages": len(stages), "uses": dict(visits), + "binary_height_at_all_completed_cuts_and_products": max_height, + "binary_height_at_native_entrances": pre_height, + "scaled_mass_at_all_cuts_and_products": str(CALLER_ODD * max_mass), + "scaled_mass_at_native_entrances": str(CALLER_ODD * pre_mass), + "normalized_bound_uses_no_cancellation_or_commutation": True, + } + + +def replay_caller(caller, layout): + path = HERE / "engines/caller/caller16.py" + require(sha256(path.read_bytes()).hexdigest() == CALLER_REPLAY, "wrong signed caller engine") + spec = importlib.util.spec_from_file_location("physical_signed_caller16", path) + require(spec is not None and spec.loader is not None, "signed caller engine must be loadable") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + result = module.signed_caller(caller, layout, CALLER_ODD, 9) + require(result["calls"] == STAGES and result["roles"] == 68 and result["root_owners"] == 3536 + and result["exact_preproduct_divisions"] == 153295 + and Fraction(result["peak_scaled_mass"]) == Fraction(495734175, 2), + "exact inherited caller odd scale and literal divide replay") + roots_q = sum(len(specification["ports"]) * sum(row[0] < 0 for row in specification["diagonal"]) + for specification in caller["types"].values()) + require(roots_q == 3536, "charge all root negative-q ordinary translations") + envelope = caller_envelope(caller) + require(envelope["uses"] == result["uses"], "independent weighted caller operation count") + return result, envelope, roots_q + + +def ordinary_budget(native, signed, roots_q, scalar_bits): + n, k, terms, homes = (native[key] for key in ("public", "slots", "terms", "numerical_homes")) + conversions = 2 * (signed["root_owners"] + STAGES * n) + reset_counts = { + "dirty_home_initializations_and_retirements": 2 * homes, + "term_and_row_stream_initializations_and_retirements": 8 * (terms + k + n), + "owner_scale_unscale_stream_initializations_and_retirements": 4 * n, + "sender_reinitializations_and_retirements": 2 * k, + } + transfer_counts = { + "complete_scalar_donor_staging_legs": 2 * terms, + "complete_sender_and_terminal_staging_legs": 2 * (k + n), + "paid_parked_sender_return_and_adapter_legs": 6 * k, + "immutable_entrance_and_public_terminal_install_legs": 4 * n, + } + resets, transfers = sum(reset_counts.values()), sum(transfer_counts.values()) + selector_l = 14*homes + 9 + selector_constant = 63*homes - 7*homes.bit_count() + 27*homes.bit_length() + 59 + # Allow the separate full overwrite scan for every reset, in addition + # to the selector/reset bound, including the stream resets. + selections = [resets*(selector_l+2) + transfers*(selector_l+128), + resets*(selector_constant+3) + transfers*(selector_constant+320)] + selected = native["selected_logical_operations"] + checked_home_resets = sum(selected[op] for op in native["fixture_addressed_cells_overwritten"]) + checked_copy_visits = sum(selected.values()) - checked_home_resets + require(checked_home_resets == 2*(homes+k) + and resets >= checked_home_resets + native["tracked_stream_reset_visits"], + "full occupied resets, sender reuse and independent stream resets charged") + require(checked_copy_visits == terms+3*(k+n) and transfers == 2*checked_copy_visits + 2*k, + "all staged copy visits plus complete paid adapter legs charged") + p = STAGES * k + sum(signed["fixed_caller_paid"].values()) + t = STAGES * sum(native["positive_helper_ranks"].values()) + sum(signed["fixed_root_targets"].values()) + uses = signed["uses"] + maps = 2*(p+t+STAGES*400) + 2*(uses["IDLE_ONE"]+uses["IDLE_ODD"]) + maps += 3*uses["QUERY"] + uses["LAMBDA"] + uses["IDLE_ODD"] + roots_q + scalar_counts = { + "literal_native_products_and_accumulations": STAGES * terms, + "width_padded_native_row_lifecycles": STAGES * 4 * (k + n), + "public_boundary_installations_and_scale_preparations": STAGES * 2 * n, + "private_home_flags_and_cleanup": STAGES * homes, + "serial_sender_initialization_and_retirement": STAGES * 2 * k, + "weighted_signed_caller_operation_slots": sum(uses.values()), + "complete_array_odd_conversions": conversions, + } + scalar_count = 32 * sum(scalar_counts.values()) + require(homes <= OLD_NATIVE_STOCK and native["additional_independent_guarded_streams"] == 4, + "retained numerical home ceiling and extra independent streams") + return { + "native_numeric_homes": homes, "native_numeric_homes_plus_dummy": homes+1, + "raw_numeric_homes": STAGES*homes, "raw_numeric_homes_plus_dummy": STAGES*(homes+1), + "separate_guarded_guide_tracks_per_native": 1, "separate_guarded_guide_tracks_raw": STAGES, + "separate_guarded_streams_per_native": 4, "separate_guarded_streams_raw": STAGES*4, + "odd_conversions": conversions, "reset_services_per_native": resets, + "typed_selected_transfers_per_native": transfers, + "reset_services_by_kind_per_native": reset_counts, + "typed_transfer_legs_by_kind_per_native": transfer_counts, + "reset_services_all_native_stages": STAGES * resets, + "typed_selected_transfer_legs_all_native_stages": STAGES * transfers, + "selector_steps_per_selected_service_L_and_constant": [selector_l, selector_constant], + "additional_full_overwrite_steps_per_reset_L_and_constant": [2, 3], + "selected_total_steps_per_native_L_and_constant": selections, + "selected_total_steps_raw_L_and_constant": [STAGES * part for part in selections], + "scalar_services": scalar_count, "scalar_step_rate": 2**max(20, scalar_bits+8), + "raw_scalar_incidence_allowance_before_factor_32": scalar_counts, + "ordinary_map_slots": maps, "ordinary_elementary_record_upper": maps*4*(AMBIENT_CAP+1)**2, + "raw_paid_positions": p, "raw_productive_targets": t, "root_negative_q_translations": roots_q, + "native_paid_wrappers": STAGES * k, + "native_productive_wrappers": STAGES * sum(native["positive_helper_ranks"].values()), + "ordinary_main_pair_slots": STAGES * 400, + "compiled_ordinary_work": "Full-view resets, selects, copies, guide and layout setup and return, exact scalar and odd conversions, matchers, fixed descriptors, root normalization, and all native, caller and child adapters.", + "compiled_stock": "Disjoint occurrence-tagged bank tuples, dummy origins, guides and four guarded streams per stage; complete public owners, matching child views, compiler and BIT workspace, and every parked ancestor.", + "layout": { + "padded_payload": "L'=N_c(2(W+26)+3)", + "per_stage_selector_and_stream_tracks": 11, + "guide_setup_and_retirement": "q(N_c)+q(W')+22N_cW'+36N_c+7W'+36+7L'+10; q(x)=24x-7popcount(x)+15ell(x)+12; W'=W+26", + "aggregate_owned_tuple_M": "sum_stage[(homes+6)(L'+2)+ell(N_c)+ell(W+26)+max(ell(N_c),ell(W+26),ell(homes))+max(N_c,homes)+max(W+26,ell(homes))+10]", + "shadow_cells_upper": "M+352", + "complete_view_step_bound": "34*(256(M+352)+128) plus fixed-degree descriptor work", + }, + } + + +def root_envelope(native, caller): + max_binary = max(caller["binary_height_at_all_completed_cuts_and_products"], + *(caller["binary_height_at_native_entrances"] + side["path_grid_height"] + for side in native.values())) + max_mass = max(Fraction(caller["scaled_mass_at_all_cuts_and_products"]), + *(Fraction(caller["scaled_mass_at_native_entrances"]) * side["path_grid_odd"] + * Fraction(side["positive_path_mass_bound_unscaled"]) + for side in native.values())) + mass_bits = ceiling_bits(max_mass) + c = 2 * max(max_binary, mass_bits) + return { + "caller_odd": CALLER_ODD, + "native_odd": {side: audit["path_grid_odd"] for side, audit in native.items()}, + "native_binary": {side: audit["path_grid_height"] for side, audit in native.items()}, + "context_mass_bound": str(max_mass), "context_mass_bits": mass_bits, + "context_binary_bits": max_binary, "context_c": c, + "H_guard": "bit_length(context_c*1920*153**1920*(H+1)**2) < H for each actual compiler bound H", + "exact_grid": "2^(-p-D)", + "signed_width": "W=p+h+2D+3", + "temporary_width": "W+26", + } + + +def relay_edit(parent, candidate, word): + require(all(parent[field] == candidate[field] == word[field] + for field in ("frames", "initial", "final")), + "same complete raw chart atlas and public owner shapes") + require(parent["first_output"] == candidate["first_output"] == len(word["program"]), + "stable raw clocks and complete public output namespace") + enter, middle, leave = RELAY_CHARTS + require(word["program"][REMOVED] == ["MOVE", RELAY_ROLE, enter, middle, False] + and word["program"][SURVIVOR] == ["MOVE", RELAY_ROLE, middle, leave, False], + "literal nonproductive source relay on owner 1256") + parent_moves, parent_rows = graph_inputs(parent) + child_moves, child_rows = graph_inputs(candidate) + raw_moves = {clock: (event[2], event[3]) for clock, event in enumerate(word["program"]) + if event[0] == "MOVE"} + require(parent_moves == raw_moves and len(raw_moves) == 6144 and len(child_moves) == 6143, + "exact source and contracted paid denominators") + require(child_moves == {key: (enter, leave) if key == SURVIVOR else edge + for key, edge in parent_moves.items() if key != REMOVED}, + "only one direct paid edge replaces the two source children") + require(parent_rows[SURVIVOR] == [(REMOVED, Fraction(1))] + and [key for key, terms in parent_rows.items() if any(donor == REMOVED for donor, _ in terms)] + == [SURVIVOR], + "pure single-consumer relay") + require(child_rows == {key: parent_rows[REMOVED] if key == SURVIVOR else terms + for key, terms in parent_rows.items() if key != REMOVED}, + "retained paid sender uses exactly four substituted source terms") + edited = {REMOVED, SURVIVOR} + require([key for key in candidate["schedule"] if key not in edited] + == [key for key in parent["schedule"] if key not in edited], + "relative schedule order of all rows outside the relay") + positions = (parent["schedule"].index(REMOVED), parent["schedule"].index(SURVIVOR), + candidate["schedule"].index(SURVIVOR)) + require(positions == (3308, 4114, 3310), "exact old and new zero-based relay schedule positions") + a, b, c = (chart_span(word["frames"][chart]) for chart in RELAY_CHARTS) + require(a < b < c and (len(a), len(b), len(c)) == (8, 64, 512), + "strict consecutive ranks 3+3, direct rank 6") + return {"role": RELAY_ROLE, "removed_paid_key": REMOVED, "surviving_paid_key": SURVIVOR, + "ordered_charts": list(RELAY_CHARTS), "old_ranks": [3, 3], "new_rank": 6, + "new_sender_donors": [[donor, str(coef)] for donor, coef in child_rows[SURVIVOR]], + "schedule_positions_zero_based": {"parent_removed": positions[0], "parent_survivor": positions[1], + "candidate_survivor": positions[2]}, + "relative_order_unchanged_rows": len(candidate["schedule"]) - 1, + "row_later_relay_consumers": 1, "new_recursive_charges_outside_replacement": 0} + + +def check_raw_clear_inventory(word, certs): + indices = {str(clock) for clock, event in enumerate(word["program"]) if event[0] == "CLEAR"} + certificates = certs["clear_event_index"] + count = sum(len(terms) for terms in certificates.values()) + require(certs["candidate_canonical_sha256"] == SOURCE_WORD and set(certificates) == indices + and len(indices) == 235 and count == 1135, "source raw CLEAR certificate inventory") + return {"raw_clear_clocks": len(indices), "normalized_source_terms": count, + "bank_execution_source": "complete addressed retirement in the new banked schedule", + "raw_clear_role": "source-word chronological normalized proof; graph replay checks its own ownership"} + + +def check_depth_guard(root, h): + require(h > 0, "positive compiler H") + k_star = 1920 * 153**1920 * (h + 1)**2 + bits = (root["context_c"] * k_star).bit_length() + require(bits < h, "common exact-root depth guard") + return {"compiler_H": h, "argument_bit_length": bits, "strict_guard_passed": True} + + +def qualify(parent, candidate, word, certs, caller, h): + relay = relay_edit(parent, candidate, word) + clear_inventory = check_raw_clear_inventory(word, certs) + signed, caller_bound, roots_q = replay_caller(caller, word) + native, all_rows = {}, [] + for side, graph in (("parent", parent), ("candidate", candidate)): + interface = public_interface(graph, word) + moves, rows = graph_inputs(graph) + all_rows.append(rows) + audit = graph_bounds(graph, moves, rows, interface[0]) + grid = audit["path_grid"] + expected = expected_rows(audit["public"], word, interface, grid) + native[side] = { + **audit, + **exact_basis_grid(graph, moves, rows, grid, expected), + **held_schedule(graph, moves, rows, grid, expected, control=side == "candidate"), + } + parent_audit, child = native["parent"], native["candidate"] + require(parent_audit["path_grid"] == 2025 << 20 and parent_audit["terms"] == 172415 + and parent_audit["coefficient_products"] == 9044218, "independent G3 folded native anchor") + require(set(child["missing_odd_factor_controls"]) == {3, 5} and child["live_sender_alias_control_rejected"], + "actual under-scaled literal divisions and outstanding sender controls must reject") + old_paid = Counter(parent_audit["paid_native_ranks"]) + new_paid = Counter(child["paid_native_ranks"]) + require(new_paid - old_paid == {6: 1} and old_paid - new_paid == {3: 2} + and child["positive_helper_ranks"] == parent_audit["positive_helper_ranks"], + "exact paid replacement, unchanged productive ranks") + require(sum(rank * count for rank, count in new_paid.items()) + == sum(rank * count for rank, count in old_paid.items()), "paid rank mass conservation") + require((parent_audit["numerical_homes"], child["numerical_homes"]) == (9151, 9150), + "complete serial sender realization on both exact graphs") + root = root_envelope(native, caller_bound) + scalars = scalar_cases(all_rows, caller, (CALLER_ODD, *root["native_odd"].values())) + ordinary = {side: ordinary_budget(audit, signed, roots_q, scalars["coefficient_bits"]) + for side, audit in native.items()} + return { + "status": "PASS_CF6A_RELAY_BANK_PHYSICAL", + "scope": "Complete folded normalized products, all public endpoints, charged guarded bank schedules, finite scalar services and common exact root under the retained physical and recursive interfaces.", + "relay": relay, "raw_clear_source_inventory": clear_inventory, + "native": native, "ordinary": ordinary, "scalar_services": scalars, + "physical_controls": partial_clear_control(), + "caller_exact": signed, "caller_hereditary_envelope": caller_bound, "common_exact_root": root, + "bit_guard": check_depth_guard(root, h), + "both_graphs_respect_historical_numeric_homes_and_streams": True, + "inherited_private_home_cap_per_stage": OLD_NATIVE_STOCK, + "raw_stage_count": STAGES, + } + + +def main(): + parser = ArgumentParser(description=__doc__) + parser.add_argument("--parent", type=Path, default=HERE / "data/PARENT-GRAPH.json.gz") + parser.add_argument("--candidate", type=Path, default=HERE / "data/CANDIDATE-GRAPH.json.gz") + parser.add_argument("--word", type=Path, default=HERE / "data/WORD.json.gz") + parser.add_argument("--certs", type=Path, default=HERE / "data/CERTS.json") + parser.add_argument("--caller", type=Path, default=HERE / "data/CALLER.json.gz") + parser.add_argument("--candidate-sha256", default=CANDIDATE) + parser.add_argument("--compiler-H", type=int, default=COMPILER_H) + parser.add_argument("--out", type=Path) + args = parser.parse_args() + require(args.candidate_sha256 == CANDIDATE, "wrong frozen candidate pin") + parent, parent_gzip = load_gzip(args.parent, PEER) + child, child_gzip = load_gzip(args.candidate, CANDIDATE) + word, word_gzip = load_gzip(args.word, SOURCE_WORD) + caller, caller_gzip = load_gzip(args.caller, CALLER, canonical=False) + certs_raw = args.certs.read_bytes() + require(sha256(certs_raw).hexdigest() == SOURCE_CERTS, "wrong literal raw CLEAR certificate binding") + result = qualify(parent, child, word, json.loads(certs_raw), caller, args.compiler_H) + result.update({ + "graphs": {"parent": PEER, "candidate": CANDIDATE}, "caller_sha256": CALLER, + "source_head": SOURCE_HEAD, "source_word_sha256": SOURCE_WORD, "source_certs_sha256": SOURCE_CERTS, + "transport_sha256": {"parent": parent_gzip, "candidate": child_gzip, "word": word_gzip, + "caller": caller_gzip}, + }) + if args.out is None: + print(json.dumps(result, sort_keys=True, indent=2)) + else: + with args.out.open("x", encoding="utf-8") as handle: + json.dump(result, handle, sort_keys=True, indent=2) + handle.write("\n") + print(result["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/recoding.py b/research/interleaved-basis-residual-audit/retained/source/vendor/recoding.py new file mode 100644 index 0000000000..c96d8b844d --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/recoding.py @@ -0,0 +1,155 @@ +"""Rebuild the exact source graph and apply the ordered rational cut certificate.""" +from fractions import Fraction +from hashlib import sha1, sha256 +from pathlib import Path +import json +import sys + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE / "vendor")) +import construct +from network import Network, add_scaled, coefficients, encoded, need, pivot, read + + +def sources(): + for item in read(HERE / "SOURCE-PINS.json"): + raw = (HERE / item["path"]).read_bytes() + git_blob = b"blob " + str(len(raw)).encode() + b"\0" + raw + need(sha256(raw).hexdigest() == item["sha256"] and + sha1(git_blob).hexdigest() == item["git_blob"], f"source pin {item['path']}") + word = read(HERE / "data/WORD.json.gz") + certs = read(HERE / "data/CERTS.json") + raw, clears, moves = construct.raw_fold(word, certs["clear_event_index"]) + graph, relay = construct.contract(raw, word["frames"], clears, moves) + parent = construct.serialized(graph, word["frames"], "candidate", + source_banked_graph_sha256=construct.PARENT, paid_relay=relay) + need(sha256(parent).hexdigest() == construct.CHILD, "published role-1256 parent") + net = Network(graph.first, graph.initial, graph.final, graph.moves, graph.forms) + return word, net, read(HERE / "CUTS.json") + + +def combine(weights, forms): + result = {} + for token, weight in weights.items(): + add_scaled(result, forms[token], weight) + return result + + +def check_bank(net, row, chart): + for key in row: + if key < 0: + need(~key < len(net.initial) and net.initial[~key] == chart, "public bank chart") + else: + need(key in net.moves and net.moves[key][1] == chart, "paid bank chart") + + +def dot(row, direction): + return sum(row[k] * direction[k] for k in row.keys() & direction.keys()) + + +def hub(net, edit): + t, j, hub_chart = edit["incoming"], edit["outgoing"], edit["hub"] + source, middle = net.moves[t] + start, target = net.moves[j] + need(start == middle and len({source, middle, hub_chart, target}) >= 3 + and hub_chart not in (source, middle, target), "hub route") + direction = coefficients(edit["innovation"]) + receiver = coefficients(edit["receiver"]) + group = {k for k, pair in net.moves.items() if pair == (source, middle)} + need(direction.get(t) == 1 and direction.keys() <= group, "normalized cut direction") + + feedback = edit["kind"] == "feedback" + if feedback: + local = net.forms[j] + sent = coefficients(edit["sender"]) + else: + local = coefficients(edit["group"]) + need(local.keys() <= group, "local signal group") + sent = combine(local, net.forms) + check_bank(net, sent, source) + check_bank(net, receiver, hub_chart) + response = dot(local, direction) + need(response != 0, "zero response") + moves = dict(net.moves) + moves[t], moves[j] = (source, hub_chart), (hub_chart, target) + forms = dict(net.forms) + forms[t] = sent + for k, weight in direction.items(): + if k != t: + forms[k] = dict(net.forms[k]) + add_scaled(forms[k], net.forms[t], -weight) + + # Remove the transmitted direction from each row at its old receiver. + corrections = {} + for k, row in net.forms.items(): + if k in (t, j) or row.keys().isdisjoint(direction): + continue + ratio = Fraction(dot(row, direction), response) + if ratio: + need(net.moves.get(k) == (middle, hub_chart), "lost receiver component") + corrections[k] = ratio + residual = dict(row) + add_scaled(residual, local, -ratio) + need(dot(residual, direction) == 0, "cut did not cancel") + residual.pop(t, None) + forms[k] = residual + + if feedback: + determinant = 1 - dot(receiver, corrections) + need(determinant != 0, "singular receiver recovery") + recovered = {k: weight / determinant for k, weight in receiver.items()} + add_scaled(recovered, {t: 1}, Fraction(1, determinant)) + else: + recovered = {t: 1} + forms[j] = dict(receiver) + add_scaled(forms[j], recovered, 1) + for k, row in list(forms.items()): + if feedback and k == j: + continue + factor = dot(row, corrections) + if factor: + forms[k] = dict(row) + add_scaled(forms[k], recovered, factor) + if feedback: + forms[j] = recovered + return Network(net.first_output, net.initial, net.final, moves, forms) + + +def apply(net, edits, frames, observer=None): + spans = [construct.span(basis) for basis in frames] + for i, edit in enumerate(edits): + need(edit["direction"] in ("forward", "transpose") + and edit["kind"] in ("pivot", "group", "feedback"), "cut type") + dual = edit["direction"] == "transpose" + before = net.transpose() if dual else net + if edit["kind"] == "pivot": + check_bank(before, coefficients(edit["sender"]), edit["source_chart"]) + check_bank(before, coefficients(edit["receiver"]), before.moves[edit["pivot"]][1]) + if observer: + observer(i, before, edit) + after = pivot(before, edit) if edit["kind"] == "pivot" else hub(before, edit) + changed = [edit["pivot"]] if edit["kind"] == "pivot" else [edit["incoming"], edit["outgoing"]] + for key in changed: + a, b = after.moves[key] + need(spans[a] < spans[b] or spans[b] < spans[a], "strictly nested cut transfer") + after.schedule() + net = after.transpose() if dual else after + return net + + +def layout(word, net): + return dict(frames=word["frames"], initial=net.initial, final=net.final, + first_output=net.first_output, moves=[[k, *ab] for k, ab in sorted(net.moves.items())], + forms=[[k, [[j, str(c)] for j, c in sorted(row.items())]] + for k, row in sorted(net.forms.items())], schedule=net.schedule()) + + +def receipt(name, result): + stored = read(HERE / "results" / (name + ".json")) + need(json.loads(json.dumps(result)) == stored, "receipt mismatch: " + name) + + +if __name__ == "__main__": + word, parent, cuts = sources() + net = apply(parent, cuts, word["frames"]) + sys.stdout.buffer.write(encoded(layout(word, net))) diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/selected-bit-ambient.json b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-bit-ambient.json new file mode 100644 index 0000000000..cd19f356a5 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-bit-ambient.json @@ -0,0 +1,98 @@ +{ + "name": "bit-ambient", + "command": [ + "/usr/local/bin/python3.12", + "-I", + "-B", + "docs/research/pr-intake-evidence/pr7000-admission/check_bit_ambient.py" + ], + "base": "17469fff78c22941280f04d39dc5a1faee09c840", + "started_at": "2026-11-10T13:34:04.485882+00:00", + "exit_code": 0, + "wall_seconds": 0.26789799984544516, + "peak_sampled_descendant_kib": 1600, + "stop": null, + "limits": { + "seconds": 30, + "descendant_kib": 1048576, + "sampling_seconds": 0.2, + "serial": true + }, + "python": "3.12.8 (v3.12.8:2dc476bcb91, Dec 3 2024, 14:43:19) [Clang 13.0.0 (clang-1300.0.29.30)]", + "platform": "macOS-26.6.2-arm64-arm-64bit", + "source_sha256": { + "research/shared-wire-split-composition/native-accounting.json": "ec4f2657a6c172a16c68e958e865ef7bf5217a47814fb506e6e144d19daeaebc", + "research/shared-wire-split-composition/INDEPENDENT-NOTICE.md": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8", + "research/shared-wire-split-composition/INDEPENDENT-SOURCES.json": "dced1457df5230466ba6202fd6d4595bc2b7fb2a65302806bf2720b1837ff350", + "research/shared-wire-split-composition/SOURCES.json": "c66f8049a4e4bf9890d5f7d9f386de2c4897490f8f5e48edcc69a54b9333d103", + "research/shared-wire-split-composition/NATIVE-INPUTS.json": "9bb6c1567783661334d6c1d23f715ce5635cbbb513678819ab9e020a34c7e4c0", + "research/shared-wire-split-composition/VERIFY.json": "f27f759db9707cf5e8e4a331ca509401186c994ed661a9f4b480961642d5544f", + "research/shared-wire-split-composition/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/shared-wire-split-composition/INDEPENDENT-REVIEW.md": "c24c7ee899c258420e281afe4e6dfcd890adf552b469822a38c13898bcd2a936", + "research/shared-wire-split-composition/compose.py": "f057d659243575529cfd89a5534c8f333d0716897ee495bfe3de67eeb0970c20", + "research/shared-wire-split-composition/interval_gate.py": "60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5", + "research/shared-wire-split-composition/reproduce.py": "9b9fca18bf28c627ff29ba06048503af0cb5f27a4ffabeadffed50e0678c96c9", + "research/shared-wire-split-composition/FULL-RESULT.json": "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7", + "research/shared-wire-split-composition/TASK.json": "60e22522e87684c068f32c8ec687305f2be934f2800e2f10a55483bff02506a1", + "research/shared-wire-split-composition/VALIDATION.md": "582d71db76db5ac7bcfb2f9a962479d1a76d321c7536f08347f16fe01ec9d52e", + "research/shared-wire-split-composition/chart_delta.json": "881bc1bb93e1738aa9269f41af6db0ef80b377920aed6f91e79b9b6ed70e5deb", + "research/shared-wire-split-composition/independent.py": "21f46a8340331abb1486b50bd4e04453f1968b0a5950d86ff7780dd368590874", + "research/shared-wire-split-composition/NOTICE": "da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249", + "research/shared-wire-split-composition/chart_delta.py": "865f1e526663cb6e53092db66b5fdabae5ed37a0afe7520bdbe1bb21d0266d38", + "research/shared-wire-split-composition/README.md": "f8d540c9f505d5856416897c231bcb9186f873f6148b68b9f23fedac70313831", + "research/shared-wire-split-composition/split_build.py": "54f80d3c557175acfc2cf13059f00f004be3f18fb6c76946e05efe8ca8b5f33a", + "research/shared-wire-split-composition/independent_construction.py": "1e8d66885afce4181ff6195c31aa3445886410b13faf1c8c7321f3ae7fc9554e", + "research/shared-wire-split-composition/precision_replay.py": "850d9098c5946ab27ef5228acc54d59df2196e72259d3e21588ec0c319c8f5ee", + "research/shared-wire-split-composition/VERIFY-INDEPENDENT.json": "820992b885fffaee53854be2c0200b7d4bf96ec678c305b1eff3e6be1364b3e3", + "research/shared-wire-split-composition/CONSTRUCTION-REVIEW.md": "038392a7c5f1705b1978bcc35f9dc889d4ccd457a1f32c384a500c81259e978b", + "research/shared-wire-split-composition/build_wire.py": "b0e1f38dd70f7c1a6f4d9ec8289c76747f558dc8e1ba44b22dd58ff82870e6bd", + "research/shared-wire-split-composition/full_verify.py": "08134736288c3a1067d61185f195c645aa2624051b45c808b2447360d2d20ae0", + "research/shared-wire-split-composition/verify.py": "d2a291f8f4ea6dce51648ba44614d655b47e8e38d235458ac64924af7552b57b", + "research/shared-wire-split-composition/CONSTRUCTION.md": "40249ccc0854393aa3a6ff14845879407ebeb0bc365f14c49ab155489addb436", + "research/shared-wire-split-composition/frozen/verify_host3_odd.py": "e75ad2096ba2587d1dc9c8982b2c2eb7c6fd2636a80adcd943314ef2cf6fd258", + "research/shared-wire-split-composition/frozen/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "research/shared-wire-split-composition/frozen/physical.py": "4e995d1158033d83bf69b671f23dc7924d66edbbe07623ba063ba7421234ea20", + "research/shared-wire-split-composition/frozen/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "research/shared-wire-split-composition/data/caller.json": "3828d53e80ea97e8b866320f081af20b6b93bfebd58b95b56b85a7afe151af5e", + "research/shared-wire-split-composition/data/split759.proof.json": "35f8b64110957b6f51fd8dd0e53326c466e2ffeecf9254012f0e55a5275bea81", + "research/shared-wire-split-composition/data/bit-admission.json": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b", + "research/shared-wire-split-composition/data/split759_450.proof.json": "78b25749911131b50bb4565b17a06d08ccf4b511ec05e598e7f146c96aed4174", + "research/shared-wire-split-composition/data/wh_6937.json.gz": "25326dac562fa07edd28a6daf302de0c27f5f2e82f610eaf3671d39575f8dbea", + "research/shared-wire-split-composition/data/final.json.gz": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "research/shared-wire-split-composition/data/extra_wire_spec.json": "b065bd6c3b0762bc90f5cd0a0c1fb6b9664edefc5a1becbff6734a72ab7698d8", + "research/shared-wire-split-composition/data/main_6936.json.gz": "273e81f176f001684b1fa3eb857992bf58b54748004fcfe806b83adb48d2cc00", + "research/shared-wire-split-composition/retained/query-only-precision-envelope/envelopes.py": "783da6b5b450fc07434946cb9ec86070dfee01df6b5fa1c385cb024def2c9a9f", + "research/shared-wire-split-composition/retained/query-only-precision-envelope/source_binding.py": "624c459311c58f3847b7713b818bfd340153abf42919f02ac9aa8892ed52a2bd", + "research/shared-wire-split-composition/retained/odd-native-common-grid/independent_bounds.py": "198521def614fe78fa728f1dde2b7fb820c0c0e0ac3ad0c9224dccbf51eac0d5", + "research/paired-query-only-bit/SOURCES.json": "1037b0a2d0d60d998630d0d6faf80bc8f2d4351ba1a50dcdfa9f7e86e44019fd", + "research/paired-query-only-bit/PROOF.md": "3c32eb61bec108aceee3d2d676c2c115391f5d0f9845ac209214bb58ef4ebee4", + "research/paired-query-only-bit/INDEPENDENT-REVIEW.json": "e44a7204dcac835817e89be12fc0fb33d981c99ed6ebc3e33b48e49d2fdaeeb3", + "research/paired-query-only-bit/VERIFY.json": "774280bdef625e08e3f854a0f886f65b4283db17fcb397efe7556f97082cbaad", + "research/paired-query-only-bit/check.py": "460ed9a77d66264b00c31d0a7f8dab1db9aab21ec4cc0eaf0452bd4be4ef585e", + "research/paired-query-only-bit/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/paired-query-only-bit/EFREE-CALLER.json.gz": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b", + "research/paired-query-only-bit/EFREE-RESULT.json": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b", + "research/paired-query-only-bit/TASK.json": "4c76a0988a076598a22473b2849f062116e09613939a4a4fb672e5792c5c7906", + "research/paired-query-only-bit/VALIDATION.md": "1cc6f940cf4ce1cc6c54c9d07fd2574c1bdbb543097eede31ad78836b1918903", + "research/paired-query-only-bit/NOTICE": "8c73eaf46327f01b4cfc18640b5e5f552648fc5e4427cbccd42af5e7ecd3b732", + "research/paired-query-only-bit/README.md": "cfdb5e13f1b7571a76f6d645eb3bcc703e545e55a34a6fdc08a8e6f96ba1a9a8", + "research/paired-query-only-bit/INPUT-PINS.json": "84007e990d41cf4aac3cd9c1a08984b895fff20acdefc99d464262ec2ad694d4", + "research/paired-query-only-bit/independent/bit_review.py": "6db4b1657bac033ed526fb714b4830b51ae2260d2ce11c3ef0b9e907cadd47db", + "research/paired-query-only-bit/independent/interval_gate.py": "8dc2bc4c64cba3f83c664373984a075f1a14b4d53958084091345c8cab189dec", + "research/paired-query-only-bit/data/selected_review.md": "8bd158b8ef68202000f167b9b78db0b31531b5b067b5cbd91b5bf35f3ddd1ab6", + "research/paired-query-only-bit/data/selected_record.json": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa", + "research/paired-query-only-bit/data/selected_claim.json": "9cee8a1304fa893be3d3b641eda42fdd9b2fd6a5ac2124fb891de7a1a5e8d92e", + "research/paired-query-only-bit/data/query_only_6980.json": "3828d53e80ea97e8b866320f081af20b6b93bfebd58b95b56b85a7afe151af5e", + "research/paired-query-only-bit/data/6980_PROOF.md": "0cede285a98dd61b78020651202729c6d9cd16fb078ee5fe9a01aa2400df5432", + "research/paired-query-only-bit/data/6834_result.json": "5c3dd8b954de767e41ec7b3d51895ed8c28968d39cb6af57a84c01683f5780ae", + "research/paired-query-only-bit/retained/audit_binary_mixed.py": "bb6616dbf536acf10163b8fff65ebfa69d01dfdeda3c0ead388c03377361b298", + "research/paired-query-only-bit/retained/NOTICE": "620e4ec6f537fa1c071f019ac92fa0e4eec8ab487c811e84153292b981de0424", + "research/paired-query-only-bit/retained/inputs/independent_interval.py": "9293f567aa4afd9b4e618f1cddd3cf66eea51c5e194e3c578e7a8f4db6e04a57", + "research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz": "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78", + "research/paired-query-only-bit/retained/inputs/credited_trim.py": "fcff17fdd3108be68761fbde0fcbfe218be166cf518c99f7163e60d53ab785d9", + "research/paired-query-only-bit/retained/inputs/inputs/exact_arithmetic.py": "0ce7e7137422d5ffeda22085c81fa88471bbe963100fdad62e659f1e3bf89326" + }, + "source_unchanged": true, + "log": "bit-ambient.log", + "log_sha256": "90e8b8bba405ec40d89c6f522cceb48fe873e51527f39a88d0c61b4f1990f98e" +} diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/selected-claim.json b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-claim.json new file mode 100644 index 0000000000..c9b816f844 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-claim.json @@ -0,0 +1,65 @@ +{ + "schema": "proposed-conditional-integer-multiplication-claim/1", + "kappa": "363005817/100000000000", + "source_result": "research/shared-wire-split-composition/FULL-RESULT.json", + "uniform_templates": [ + { + "family": "complex", + "rank_encoding": "2^14174600000000000000", + "saving": "181502908503/50000000000000", + "ambient": 153 + }, + { + "family": "BIT before cover", + "rank_encoding": "2^296630000000000", + "saving": "38525299/10000000000", + "ambient": 134 + } + ], + "covered_BIT_saving": "19262649/5000000000", + "ordinary_BIT_saving": "4815653101/1250000000000", + "admitted_BIT_saving": "12039/3125000", + "complex_BIT_premise": "376669/100000000", + "BIT_bootstrap": [ + "17/5000", + "38507/10000000", + "12039/3125000" + ], + "nine_outer_savings": { + "main_transform": "36300581700299636994182997/10000000000000000000000000000", + "global_coordinate_router": "90751454251/25000000000000", + "fused_gaussian": "36300581700398910982548991/10000000000000000000000000000", + "group_bit_router": "9075145425124727745637247/2500000000000000000000000000", + "group_scans": "49999999999999/50000000000000", + "boundary_algebraic_matrix": "36300581700399636994182997/10000000000000000000000000000", + "sparse_union_movement": "4098800581700399636994182997/10000000000000000000000000000", + "polynomial_products": "99999999999999/100000000000000", + "microbox_face_corrections": "1925000000000001/25000000000000" + }, + "outer_formula_source": "research/shared-wire-split-composition/interval_gate.py", + "limiting_outer_saving": "36300581700299636994182997/10000000000000000000000000000", + "strict_limiting_slack": "299636994182997/10000000000000000000000000000", + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "scope": "Conditional shared-native mixed caller with exact common-grid scalar service; five inherited assumptions. No materialized uniform word, complete multiplier, independent human proof or formal-kernel acceptance." +} diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/selected-validation.json b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-validation.json new file mode 100644 index 0000000000..7291ce5ab9 --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/selected-validation.json @@ -0,0 +1,223 @@ +{ + "schema_version": 1, + "status": "admitted_conditional", + "base": "f16923d466a6aba912299882e0545564d2ba7bb2", + "source_heads": { + "7000": "93effe2a135bf57b9e484cb630d8dd057159aec9", + "7001": "d777f3a0aa2878bea0478918923dabcf86b9878b" + }, + "selected_frontier_changed": true, + "selected_kappa": "0.00363005817", + "previous_kappa": "0.003125804", + "registered_replays_complete": true, + "all_jobs_finished": true, + "receipts": [ + { + "name": "bit-primary", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/bit-primary.json", + "sha256": "2bd4ae504350b8189e5a25c8e55212666ad15e16e3d85a824691513f0f498b11", + "wall_seconds": 13.74172916682437, + "peak_sampled_descendant_kib": 32544, + "exit_code": 0 + }, + { + "name": "bit-independent", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/bit-independent.json", + "sha256": "16088896d2b49bb81d17b778f162e41aee988188d79e76bdffe967ac0e9d40ff", + "wall_seconds": 0.4980977922677994, + "peak_sampled_descendant_kib": 34128, + "exit_code": 0 + }, + { + "name": "complex-primary", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/complex-primary.json", + "sha256": "fab9a2ead4a6212f3bc262a8da1019a623c420af02a38edb63807516b5cee8bf", + "wall_seconds": 99.33472337480634, + "peak_sampled_descendant_kib": 241472, + "exit_code": 0 + }, + { + "name": "complex-independent", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/complex-independent.json", + "sha256": "cbecd914e3a231b915ab4826a0046c0118fe1c800f2cca5a5c1e9586aa87d7e7", + "wall_seconds": 84.73606283264235, + "peak_sampled_descendant_kib": 110064, + "exit_code": 0 + }, + { + "name": "complex-physical", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/complex-physical.json", + "sha256": "fab7f7e00d40a09508a5bee285dc8fb33f06c92f48ed86e1f99affc35207627c", + "wall_seconds": 80.88798883417621, + "peak_sampled_descendant_kib": 699600, + "exit_code": 0 + }, + { + "name": "owned-factorizations", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/owned-factorizations.json", + "sha256": "938d1791dc320d7fa0bdb44ef318641960798823cd66c4074a037bb9c7682bd9", + "wall_seconds": 22.427095042075962, + "peak_sampled_descendant_kib": 102480, + "exit_code": 0 + }, + { + "name": "lambda-algebra", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/lambda-algebra.json", + "sha256": "bc871b73eaf56318c8be84b117c6f8e7eed8db4e0f9d0ab729eeb5d425a4a1d7", + "wall_seconds": 0.5506485840305686, + "peak_sampled_descendant_kib": 17728, + "exit_code": 0 + }, + { + "name": "bit-ambient", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/bit-ambient.json", + "sha256": "437ad2f9e7956e7f2b477b546f53a6c8cfa0567e207024300e9a7e58d3c0202c", + "wall_seconds": 0.26789799984544516, + "peak_sampled_descendant_kib": 1600, + "exit_code": 0 + }, + { + "name": "bit-ambient-optimized", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/bit-ambient-optimized.json", + "sha256": "977abde2a364af1a0153033f759cc2d90ea79b6f266bcdbb0830c52d22976ded", + "wall_seconds": 0.26918487483635545, + "peak_sampled_descendant_kib": 2272, + "exit_code": 0 + }, + { + "name": "interface-bindings", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/interface-bindings.json", + "sha256": "e3313b43b32169fba878600b43a722c51cce770f685f151433a7addeff25c3d3", + "wall_seconds": 0.28022624971345067, + "peak_sampled_descendant_kib": 1920, + "exit_code": 0 + }, + { + "name": "interface-bindings-optimized", + "receipt": "docs/research/pr-intake-evidence/pr7000-admission/interface-bindings-optimized.json", + "sha256": "030311e1fcdf372c059545a8c355cf09b4931fda34b7759333406f14d837b2bd", + "wall_seconds": 0.28489804081618786, + "peak_sampled_descendant_kib": 4832, + "exit_code": 0 + }, + { + "name": "application", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/application.json", + "sha256": "b6ca671c7101674a40a2c30fdea0ec95f08f9b61bbc9a0926d38da9a6942e14b", + "wall_seconds": 49.84868695773184, + "peak_sampled_descendant_kib": 105232, + "exit_code": 0 + }, + { + "name": "application-optimized", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/application-optimized.json", + "sha256": "f8989171cd7561dccd1ce0db3a7cb119640b965d7f6212d21e9f2d7f16590365", + "wall_seconds": 38.167422249913216, + "peak_sampled_descendant_kib": 106320, + "exit_code": 0 + }, + { + "name": "scalar", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/scalar.json", + "sha256": "d3eb6cf49dd74cc78ea85703236ec1e31a84b6c52e5a42311a65b7a19faeb669", + "wall_seconds": 10.96639662515372, + "peak_sampled_descendant_kib": 47040, + "exit_code": 0 + }, + { + "name": "scalar-optimized", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/scalar-optimized.json", + "sha256": "13e86b7a72e98e8189c964969b43fb055291f5b2efa92fc7ca63e5bf6b8324bb", + "wall_seconds": 15.716162957716733, + "peak_sampled_descendant_kib": 45600, + "exit_code": 0 + }, + { + "name": "native-catalogue-0", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/native-catalogue-0.json", + "sha256": "60911939b399975817334f2ab0e33e1b3d15ac937baab1bc82573f18c761766e", + "wall_seconds": 222.34261462511495, + "peak_sampled_descendant_kib": 58640, + "exit_code": 0 + }, + { + "name": "native-catalogue-1", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/native-catalogue-1.json", + "sha256": "d7cb2b5ac7ebdfdde129877916bded5c5dfc386316b6395dbe58ebbefdd7c69d", + "wall_seconds": 249.59168437542394, + "peak_sampled_descendant_kib": 58624, + "exit_code": 0 + }, + { + "name": "native-catalogue-2", + "receipt": "docs/research/pr-intake-evidence/pr7000-application/native-catalogue-2.json", + "sha256": "2e1f8fd8e4504b2495d07488bf9831e913c706a3e94d1c4de3c1866c585cacaa", + "wall_seconds": 338.04289187537506, + "peak_sampled_descendant_kib": 59712, + "exit_code": 0 + } + ], + "historical_input_aliases": { + "cc723faaf0d182693f69d51ad8a5b3d483103e4a8d0e2ecbbcb5e1508e77404e": "docs/research/pr-intake-evidence/pr7000-application/orchestration-initial.txt", + "8b8067cfd88d785a74c68e8b8e519b3b90c2122298aa3c1b29cb51efea164b63": "docs/research/pr-intake-evidence/pr7000-application/orchestration-monolithic.txt" + }, + "nonexecuted_inventory_changes": { + "scalar": { + "docs/research/pr-intake-evidence/pr7000-application/check_application.py": "c44411369b8bfa66ed2865b0be15ccb45b7410d0a34d2fa24b6fe0fc6a08b17d" + }, + "scalar-optimized": { + "docs/research/pr-intake-evidence/pr7000-application/check_application.py": "c44411369b8bfa66ed2865b0be15ccb45b7410d0a34d2fa24b6fe0fc6a08b17d" + } + }, + "nonexecuted_inventory_changes_reason": "The scalar harness inventoried check_application.py but did not execute or import it. Later changes added application controls; both application modes then passed at its current hash. Both exact scalar executions used the unchanged current scalar checker. Orchestration snapshots retain the earlier harness bytes.", + "prior_review_checker_sha256": { + "check_bit_ambient.py": "e8dabd0285c2ea84472a588a0f6f56e0a7865535ba5f0109db56b08cb7e79886", + "check_interface_bindings.py": "24f5a3c1660b2490981c3af2bd00791c95a0eae373b20db08854d61362c5e08f" + }, + "failed_attempt": { + "receipt": "docs/research/pr-intake-evidence/pr7000-application/native-catalogue.json", + "sha256": "aed71658d6b85b37c44bfb961c9f56c7d72e625b9d5fcc8b492b75d17ce4aa6c", + "original_checker": "docs/research/pr-intake-evidence/pr7000-application/native-catalogue-monolithic.txt", + "scope": "600-second monolithic timeout; no successful coverage reused. Disjoint bounded parts replace it." + }, + "coverage": [ + "All five registered candidate/BIT checks reused at unchanged scientific input hashes.", + "Current complete native catalogue: 3057 maps, 104 main boundary pairs, exact signed Pauli action and absolute Gaussian phase.", + "All 14400 complex native contacts and current paid-owner lists; all 636 BIT frames and 111 main charts.", + "Exact fixed-rational scalar reference normal/optimized; common-grid and fixed-tape scan application supplied in the review.", + "Current root/complete-spectator layouts, owned lifetimes, full cost units and fresh thresholds applied under the same five assumptions." + ], + "remaining": [], + "retained_assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "reuse_invalidation": "Any changed executed checker, source data, imported engine, occurrence recipe or application premise invalidates its affected coverage. Orchestration-only historical aliases and the scalar job's nonexecuted application checker are explicit. The previous selected record is preserved byte-for-byte as frontier6030.json.", + "scope": "Maintainer conditional application admission; finite checks and a written specialization, not a complete multiplier, independent human proof or formal-kernel acceptance.", + "review_files_sha256": { + "PROOF-REVIEW.md": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055", + "SOURCES.json": "8fa7eb44bcc8c7d442848b9f51e9b5e26413a433ebc382f302c350981871265c", + "check_application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "check_exact_scalar.py": "f83e506617a92027b3ff82f28bc043e34e890951eb7f3bd930e08c6c02a04a9d", + "check_native_catalogue.py": "6120e1ea1e07eeba757694d209437a38f121b0a377cc466889a30fa52c561472", + "replay_bounded.py": "ed8324a1f126d3282e312ecc252e4f4847ec50aed9e8b70d00b98d4b9ab96a16" + } +} diff --git a/research/interleaved-basis-residual-audit/retained/source/vendor/upstream_application.py b/research/interleaved-basis-residual-audit/retained/source/vendor/upstream_application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/interleaved-basis-residual-audit/retained/source/vendor/upstream_application.py @@ -0,0 +1,369 @@ +#!/usr/bin/env python3 +"""Exact-source caller geometry, occurrence allocation and rational BIT frames. + +No contributor scientific module is imported. Complex phase-polynomial +method credited to the retained fragment physical audit; here coefficients +of the full degree-two polynomial are constructed instead of probing it. +OpenAI Codex assistance for Douglas Colkitt. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + raw = (ROOT / path).read_bytes() + pin = next(p for p in json.loads((HERE / 'SOURCES.json').read_text())['files'] + if p['path'] == path) + need(sha256(raw).hexdigest() == pin['sha256'], 'source bytes: ' + path) + return json.loads(gzip.decompress(raw) if path.endswith('.gz') else raw) + + +def digest(value): + return sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def bits(n): + result = [] + while n: + a = n & -n + result.append(a) + n ^= a + return result + + +def dot(a, b): + return (a & b).bit_count() % 2 + + +def terms(items): + c = Counter() + for v, a in items: + c[v] += a + return {v: a % 4 for v, a in c.items() if v and a % 4} + + +def sub(a, b): + return terms(list(a.items()) + [(v, -c) for v, c in b.items()]) + + +def polynomial(t): + # parity(sum x_i) = sum x_i - 2 sum_{i 0, 'positive complete helper job') + T[rank] += 1 + need(len(mapping) == len(set(mapping.values())) == word['public'], 'injective native inputs') + for r in range(word['public'], word['public']+word['owned_fields']): + mapping[r] = ('owned', ci, r-word['public']) + need(len(set(mapping.values())) == word['public']+51, 'owned/public separation') + for ni, move in native_moves: + _, r, start, end, owned = move + rank = abs(len(word['frames'][end])-len(word['frames'][start])) + need(owned == (r >= word['public']) and rank > 0, 'actual paid owner class') + P[rank] += 1 + occurrences.append([ci, ni, list(mapping[r]), rank, start, end]) + for pi, q in enumerate(word['ports']): + transform = route(q, by_q[q], stage) + before_axes = [1 << j for j in range(9+8*(stage-1))] + after_axes = [1 << j for j in range(9+8*stage)] + spectator = [1 << j for j in range(9, 9+8*stage)] + x0 = terms((a, 1) for a in before_axes) + y0 = terms(list(x0.items())+[(q, -1)]) + x1 = terms((a, 1) for a in after_axes) + y1 = terms(list(x1.items())+[(q, -1)]) + nx0 = terms([(a, 1) for a in spectator]+[(q, 1)]) + ny0 = terms((a, 1) for a in spectator) + nx1 = terms((a, 1) for a in spectator+[1 << j for j in range(9)]) + ny1 = terms(list(nx1.items())+[(q, -1)]) + shifts = [boundary(a, b, transform) for a, b in + ((x0, nx0), (y0, ny0), (nx1, x1), (ny1, y1))] + body = terms((1 << j, 1) for j in range(9+8*(stage-1), 9+8*stage)) + for actual, expected in ((sub(x1,x0),body), (sub(y1,y0),body), + (sub(y1,x0),terms(list(body.items())+[(q,-1)])), + (sub(x1,y0),terms(list(body.items())+[(q,1)]))): + need(not polynomial(sub(actual,expected)), 'all four contact operators') + need(polynomial(sub(terms([(q,1)]),terms([(q,-1)]))), 'wrong query orientation rejected') + phase_records.append([ci,pi,shifts,2 if pi in second else 1]) + else: + ty, op, r, *a = e + kind = caller['types'][ty] + used = [r] + ([a[0]] if op in ('ADD','SWAP','QUERY') else []) + need(all(kind['offset'] <= x < kind['offset']+kind['roles'] for x in used), 'caller owners stay in type') + need(len(used) == len(set(used)), 'distinct scalar/query owners') + if op in ('QUERY','IDLE_ONE'): + if op == 'QUERY': + need(a[1] in (-1,1), 'signed completed query') + rank = 1; query_uses += len(kind['ports']) + else: + selected = a[0] + need(selected and len(selected)==len(set(selected)) + and all(1 <= s <= 18 for s in selected), 'whole idle stage axes') + rank = 8*len(selected); idle_uses += len(kind['ports']) + for pi in kind['ports']: + owner = ['query_scratch',ci,pi] if op == 'QUERY' else ['main',pi,r] + occurrences.append([ci,op,owner,rank]); P[rank] += 1 + elif op == 'LAMBDA': + need(a[0] in (-1,1), 'global normalizer sign') + lambda_uses += len(kind['ports']) + need(stage_order == list(range(1,19)), 'fresh chronological native stages') + for kind in caller['types'].values(): + for diagonal in kind['diagonal']: + qp, zero, *selection = diagonal + need(qp in (-1,0,1) and zero == 0 and len(selection)==18 + and set(selection)<={0,1} and any(selection), 'positive nonempty root endpoint') + rank = abs(qp)+8*sum(selection) + for pi in kind['ports']: + q = word['ports'][pi] + axes = [1 << (9+8*j+k) for j,yes in enumerate(selection) if yes for k in range(8)] + actual = terms([(q,qp)]+[(a,1) for a in axes]) + target = terms((a,1) for a in ([q] if qp else [])+axes) + need(translation(sub(target,actual)) == (q if qp == -1 else 0), 'whole output correction') + T[rank] += 1 + for name, actual in [('P',P),('T',T)]: + need(actual == Counter({int(k):v for k,v in receipt['invoice'][name].items()}), 'independent '+name+' invoice') + need(sum(T.values()) == len(owners), 'every productive target is one actual owner') + need(len(occurrences) == sum(P.values()), 'every paid position retained in order') + return dict(ambient=153, native_calls=18, native_public=1480, fresh_helpers=19440, + productive_fields=len(owners), paid_positions=len(occurrences), + complete_paid_position_digest=digest(occurrences), + native_contact_boundaries=sum(4*r[3] for r in phase_records), + phase_record_digest=digest(phase_records), nonzero_boundary_translations=sum(sum(bool(x) for x in r[2])*r[3] for r in phase_records), + reserved_native_banks=18*51, reserved_serial_query_lambda_bank=1, + query_uses=query_uses, idle_uses=idle_uses, lambda_uses=lambda_uses, + paid=dict(sorted(P.items())), targets=dict(sorted(T.items())), + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def inverse(matrix): + n = len(matrix) + a = [[Q(x) for x in row]+[Q(i==j) for j in range(n)] for i,row in enumerate(matrix)] + det = Q(1) + for j in range(n): + pivot = next((i for i in range(j,n) if a[i][j]),None) + need(pivot is not None, 'rational basis invertible') + if pivot != j: + a[j],a[pivot] = a[pivot],a[j]; det = -det + v = a[j][j]; det *= v; a[j] = [x/v for x in a[j]] + for i in range(n): + if i != j: + v = a[i][j] + a[i] = [x-v*y for x,y in zip(a[i],a[j])] + return [row[n:] for row in a], det + + +def bit_application(word, caller, receipt): + ff = word['frames']; determinants=[]; denominator_witnesses=set() + for label, frame in ff.items(): + B,A = frame['B'],frame['A']; d = frame['dim'] + need(len(B)==d and len(A)==8-d and all(len(v)==8 for v in B+A), 'rational frame dimensions') + need(all(sum(Q(x)*Q(y) for x,y in zip(b,a))==0 for b in B for a in A), 'complement annihilation') + inv, det = inverse(list(zip(*(B+A)))) + determinants.append([label,str(det)]) + denominator_witnesses.add(abs(det.numerator)); denominator_witnesses.add(det.denominator) + for row in inv: + denominator_witnesses.update(x.denominator for x in row) + for row in B+A: + denominator_witnesses.update(Q(x).denominator for x in row) + charts=[] + for port in range(111): + head=ff[str(word['start'][port])]; body=ff[str(word['final'][port+111])] + need(head['dim']==1 and body['dim']==7, 'actual main head/body ranks') + u=head['B'][0] + need(all(sum(Q(x)*Q(y) for x,y in zip(u,v))==0 for v in body['B']), 'main complement') + inv,det=inverse(list(zip(*([u]+body['B'])))) + charts.append([port,str(det)]) + denominator_witnesses.update([abs(det.numerator),det.denominator]) + for row in inv:denominator_witnesses.update(x.denominator for x in row) + P,T=Counter(),Counter(); positions=[]; names={('main',pi,r) for pi in range(111) for r in range(38)} + calls=[] + for ci,e in enumerate(caller['events']): + op=e[0] + if op=='LOCAL': + _,stage,src,dst=e; calls.append(stage) + mapping={i:('main',i,src) for i in range(111)} + mapping.update({i+111:('main',i,dst) for i in range(111)}) + for r in range(222,word['public']): + owner=('helper',ci,r); need(owner not in names,'fresh BIT helper');names.add(owner);mapping[r]=owner + T[abs(ff[str(word['start'][r])]['dim']-ff[str(word['final'][r])]['dim'])]+=1 + need(len(mapping)==len(set(mapping.values()))==659,'injective BIT occurrence') + for r in range(659,659+word['owned_fields']):mapping[r]=('owned',ci,r-659) + for ni,move in enumerate(word['program']): + if move[0]=='MOVE': + _,r,a,b=move;rank=abs(ff[str(a)]['dim']-ff[str(b)]['dim']) + P[rank]+=1;positions.append([ci,ni,list(mapping[r]),rank,a,b]) + elif op=='QUERY': + need(e[1]!=e[2] and 0<=min(e[1:])<=max(e[1:])<38,'BIT query owners') + for pi in range(111):P[1]+=1;positions.append([ci,op,['query_scratch',ci,pi],1]) + elif op=='IDLE_ONE': + _,owner,ss=e;need(ss and len(ss)==len(set(ss)) and all(1<=s<=18 for s in ss),'BIT idle axes') + for pi in range(111):P[7*len(ss)]+=1;positions.append([ci,op,['main',pi,owner],7*len(ss)]) + need(calls==[s for s in range(1,19) for _ in range(2)],'paired native chronology') + for d in caller['diagonal']: + need(d['q']==1 and d['stages'] and len(d['stages'])==len(set(d['stages'])),'BIT positive endpoint') + T[1+7*len(d['stages'])]+=111 + need(P==Counter({int(k):v for k,v in receipt['paid'].items()}) and + T==Counter({int(k):v for k,v in receipt['targets'].items()}),'complete BIT invoice') + need(sum(T.values())==len(names)==19950,'BIT owner count') + return dict(ambient=134, rational_frames=len(ff), rational_main_charts=len(charts), + rational_determinants_digest=digest(determinants), + finite_prime_exclusion_witness_count=len(denominator_witnesses), + finite_prime_exclusion_witness_digest=digest(sorted(denominator_witnesses)), + native_calls=len(calls), fresh_helpers=36*437, productive_fields=len(names), + paid_positions=len(positions), complete_paid_position_digest=digest(positions), + reserved_native_banks=36*word['owned_fields'], reserved_serial_query_bank=1, + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def main(): + p='research/shared-wire-split-composition/' + w,c,r=read(p+'data/final.json.gz'),read(p+'data/caller.json'),read(p+'FULL-RESULT.json') + phases=read('research/p104-two-chain-shared-native/retained/runtime/DATA-PHASES.json') + complex_result=complex_application(w,c,r,phases) + p='research/paired-query-only-bit/' + bw,bc,br=read(p+'retained/inputs/BIT-NATIVE-WORD.json.gz'),read(p+'EFREE-CALLER.json.gz'),read(p+'EFREE-RESULT.json') + bit_result=bit_application(bw,bc,br) + controls={} + def reject(name, action): + try:action() + except ValueError as error:controls[name]=str(error) + else:raise ValueError('negative control accepted: '+name) + alias=deepcopy(c);joint=next(e for e in alias['events'] if e[0]=='J');joint[2][2]=joint[2][0] + reject('same_frame_main_alias',lambda:complex_application(w,alias,r,phases)) + reordered=deepcopy(c);joint=next(e for e in reordered['events'] if e[0]=='J');joint[1]=2 + reject('wrong_stage',lambda:complex_application(w,reordered,r,phases)) + bad_bit=deepcopy(bw);bad_bit['frames']['0']['A'][1]=bad_bit['frames']['0']['A'][0][:] + reject('singular_BIT_spectator_basis',lambda:bit_application(bad_bit,bc,br)) + q=w['ports'][0];basis=next(x for x in phases['recipes'] if x['q']==q)['idle_children'][0]['orthogonal_axes'][:8] + reject('singular_complex_route',lambda:route(q,basis[:-1]+basis[:1],1)) + transform=route(q,basis,1) + before=terms((1<= net.first_output} + equations = {"readout": (actual, required), "calibration": (observed, entrance_form(net, order, old_outputs)), + "response": (terminal, coefficients(split["return_direction"]))} + failures = {} + for name, (left, right) in equations.items(): + indices = sorted(i for i in left.keys() | right.keys() if left.get(i, 0) != right.get(i, 0)) + if indices: + i = indices[0] + failures[name] = dict(coordinates=len(indices), first_coordinate=i, + actual=str(left.get(i, 0)), required=str(right.get(i, 0))) + need(failures, "the alternative restriction must invalidate this split") + result.append(dict(restriction=prior["role"], split=split["role"], failures=failures)) + return result + + +def verify(): + counts = Counter() + controls = set() + # The frame table belongs to the parent graph. All edits use its chart IDs. + dims = list(map(len, read(HERE / "data/BASE-GRAPH.json.gz")["frames"])) + paid, targets = Counter(), Counter() + def rank(a, b): + return abs(dims[a] - dims[b]) + def audit(net, edit): + kind = edit["event"] + counts[kind] += 1 + record_job_changes(net, edit, rank, paid, targets) + if kind not in ("split", "restrict"): + return + order = net.schedule() + if kind == "restrict": + source = entrance_form(net, order, coefficients(edit["source"])) + need(source.get(edit["role"]), "the surrendered input has no effect on the constraint") + for bank in edit["banks"]: + row = coefficients(bank["relation"]) + survived = entrance_form(net, order, row) + need(survived == source, "false receiver restriction") + counts["receiver_equations"] += 1 + if edit["direction"] not in controls: + row[bank["remove"]] += 1 + need(entrance_form(net, order, row) != source, "altered restriction accepted") + controls.add(edit["direction"]) + return + source = coefficients(edit["source_covector"]) + steering = coefficients(edit["source_direction"]) + decoder = coefficients(edit["return_covector"]) + response = coefficients(edit["return_direction"]) + readout = coefficients(edit["readout"]) + calibration = coefficients(edit["calibration"]) + pulse = coefficients(edit["pulse"]) + for k in pulse: + need(k in net.moves or net.first_output <= k < net.first_output + len(net.final), + "pulse must reach a paid instruction or a terminal") + chart = net.moves[k][0] if k in net.moves else net.final[k - net.first_output] + need(chart == edit["split_chart"], "pulse at the wrong source chart") + need(entrance_form(net, order, readout) == source, "split readout") + old_outputs = {net.first_output + i: v for i, v in decoder.items()} + need(entrance_form(net, order, old_outputs) == entrance_form(net, order, calibration), + "split calibration and decoder") + effect = pulse_response(net, order, pulse) + terminal = {k - net.first_output: v for k, v in effect.items() if k >= net.first_output} + need(terminal == response, "split output response") + input_effect = pulse_response(net, order, {k: sum(v * steering.get(~j, 0) for j, v in row.items() if j < 0) + for k, row in net.forms.items()}) + need({k - net.first_output: v for k, v in input_effect.items() if k >= net.first_output} == response, + "source and pulse must give the same output direction") + need(dot(source, steering) != 0 and dot(decoder, response) != 0 and + dot(readout, effect) == dot(calibration, effect) == 0, "causal split") + key = next(iter(pulse)) + pulse[key] += 1 + wrong = pulse_response(net, order, pulse) + need(any(wrong.get(net.first_output + i, 0) != response.get(i, 0) for i in range(len(net.initial))), + "altered pulse accepted") + counts["rejected_pulse_mutations"] += 1 + controls.add("pulse") + graph, layout, net = build(audit) + need(controls == {"forward", "transpose", "pulse"}, "checked fault controls") + parent = read(HERE / "data/QUOTIENT-APPLICATION.json")["invoice"] + candidate = read(HERE / "results/application.json")["invoice"] + for side, delta in (("paid", paid), ("targets", targets)): + before = Counter({int(k): v for k, v in parent[side].items()}) + before.update({grade: 16 * change for grade, change in delta.items()}) + need({str(k): v for k, v in before.items() if v} == candidate[side], "journal invoice for " + side) + journal = read(HERE / "EDITS.json") + return dict(events=dict(counts), graph_sha256=digest(graph), reverse=reverse_columns(net, layout), + native_change_from_7713=dict(paid=dict(sorted(paid.items())), targets=dict(sorted(targets.items()))), + alternate_restrictions=alternate_restrictions(journal), rejected=sorted(controls), + chronological_edits=len(journal)) + + +if __name__ == "__main__": + result = verify() + receipt("witness", result) + print("PASS_INTERLEAVED_WITNESSES", result["chronological_edits"], result["reverse"]["columns"]) diff --git a/research/interleaved-basis-residual-audit/verify.py b/research/interleaved-basis-residual-audit/verify.py new file mode 100644 index 0000000000..9cedb322ac --- /dev/null +++ b/research/interleaved-basis-residual-audit/verify.py @@ -0,0 +1,115 @@ +"""Verify the deposited residual certificates and independently counted price. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +""" + +from copy import deepcopy +from fractions import Fraction as F +from pathlib import Path +import gzip +import hashlib +import json +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import audit +import price + + +def reject(action): + try: + action() + except ValueError: + return + raise ValueError('changed certificate was accepted') + + +def altered(entries): + result = deepcopy(entries) + result[0][1] = str(F(result[0][1]) + 1 if F(result[0][1]) != -1 else F(2)) + return result + + +def controls(g0, g, restriction, split, item): + observation = audit.row(split['readout']) + for field in ('multipliers', 'expansion'): + changed = deepcopy(item['readout']) + changed[field] = altered(changed[field]) + reject(lambda: audit.check_functional(g, observation, changed)) + reject(lambda: audit.check_response(g, audit.row(split['pulse']), {}, altered(item['pulse']))) + reject(lambda: audit.check_response(g, {}, audit.row(split['source_direction']), altered(item['steering']))) + identity = deepcopy(item['split_identity']) + identity['column'] = altered(identity['column']) + reject(lambda: audit.check_identity(g, split['role'], identity)) + half = deepcopy(restriction) + source = audit.row(half['source']) + audit.require(source.get(~549) == F(1, 2), 'role549 half-input source pin') + source.pop(~549) + half['source'] = audit.packed(source) + reject(lambda: audit.check_functional(g0, audit.observations(half), item['restriction'])) + return 6 + + +def price_controls(invoice, counts): + low, high = price.rank_price(4, F(1, 2)) + audit.require(low <= 2 <= high and high - low < F(1, 10**9), 'closed-form square-root control') + audit.require(price.margin(invoice, '0') == ('1328', '1328'), 'zero-saving rank-mass control') + changed = deepcopy(invoice) + for rank, count in counts['fixed_targets'].items(): + changed['targets'][str(rank)] -= count + missing_roots = price.margin(changed, audit.read('PRICE.json')['claim']) + audit.require(F(missing_roots[1]) < 0, 'omitted root targets must lose') + changed = deepcopy(invoice) + for rank, count in counts['fixed_paid'].items(): + changed['paid'][str(rank)] -= count + missing_paid = price.margin(changed, audit.read('PRICE.json')['bracket'][1]) + audit.require(F(missing_paid[0]) > 0, 'omitted caller charges must change upper-point sign') + return dict(closed_form_rank4_half=True, zero_saving_surplus=1328, + missing_roots_at_claim=missing_roots, missing_fixed_paid_at_upper=missing_paid) + + +def calculate(): + for pin in json.loads((audit.ROOT / 'SOURCE-PINS.json').read_text()): + raw = (audit.ROOT / pin['path']).read_bytes() + audit.require(hashlib.sha256(raw).hexdigest() == pin['sha256'], 'source SHA-256 differs') + audit.require(hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + == pin['git_blob'], 'source Git blob differs') + raw = gzip.decompress((audit.ROOT / 'CERTIFICATE.json.gz').read_bytes()) + certificate = json.loads(raw) + results, primal_equations, multipliers, rejected = [], 0, 0, 0 + for case, item in zip(audit.cases(), certificate, strict=True): + role, variant, restriction, split, g0, g = case + audit.require((item['role'], item['variant']) == (role, variant), 'certificate case differs') + result = audit.check_case(g0, g, restriction, split, item) + results.append(result) + primal_equations += len(g0['forms']) + 3 * len(g['forms']) + multipliers += sum(len(item[k]['multipliers']) for k in ('restriction', 'readout', 'calibration')) + multipliers += len(item['restriction_identity']['row']['multipliers']) + len(item['split_identity']['row']['multipliers']) + if role == 1409 and variant == 'chosen': + rejected = controls(g0, g, restriction, split, item) + expected = audit.read('results/witness.json')['alternate_restrictions'] + actual = [] + for result in results: + if result['variant'] == 'alternate': + failures = {k: dict(coordinates=v['coordinates'], first_coordinate=v['first_coordinate'], + actual=v['difference'], required='0') for k, v in result['failures'].items()} + actual.append(dict(restriction=result['restriction'], split=result['split'], failures=failures)) + audit.require(actual == expected, 'published counterexamples differ') + invoice, counts = price.invoice() + result = dict(cases=results, invoice=invoice, counts=counts, prices=price.verify_prices(invoice), + controls=dict(rejected_certificates=rejected, price=price_controls(invoice, counts)), + certificate_sha256=hashlib.sha256(raw).hexdigest(), + certificate_counts=dict(dual_identities=30, primal_solutions=24, + primal_equations=primal_equations, nonzero_multipliers=multipliers)) + return json.loads(json.dumps(result)) + + +def main(): + actual = calculate() + expected = json.loads((audit.ROOT / 'RESULT.json').read_text()) + audit.require(actual == expected, 'published audit receipt differs') + print('PASS_INTERLEAVED_BASIS_RESIDUAL_AUDIT', actual['certificate_counts'], '96512 paid 17296 productive') + + +if __name__ == '__main__': + main()