diff --git a/.github/workflows/completed-core-sharing.yml b/.github/workflows/completed-core-sharing.yml new file mode 100644 index 0000000000..31832a1ef3 --- /dev/null +++ b/.github/workflows/completed-core-sharing.yml @@ -0,0 +1,29 @@ +name: Verify completed-core sharing + +on: + push: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + certificate: + runs-on: ubuntu-24.04 + timeout-minutes: 15 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.14'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7 + with: + python-version: ${{ matrix.python-version }} + - name: Replay construction, exact certificate and corruption controls + run: python3 research/completed-core-sharing/verify.py + - name: Require frozen inputs to remain unchanged + run: git diff --exit-code diff --git a/research/completed-core-sharing/MANIFEST.json b/research/completed-core-sharing/MANIFEST.json new file mode 100644 index 0000000000..45fbd69202 --- /dev/null +++ b/research/completed-core-sharing/MANIFEST.json @@ -0,0 +1,86 @@ +{ + "scope": "PR117 and signed MRP87; conditional on PROOF.md interfaces", + "sha256": { + "NOTICE": "e78d0d18f40776db3e482cf33930c8db073edf4da6cf6b3e5c96b7101e39a4c2", + "PROOF.md": "24eb6d03e32b5322e4e86bde521dc8d32a11bf33f72e806eba985ba47ce05fb0", + "README.md": "fb7f1712e78ab2e1305d056a006a256cd7df20ed72f306d25ad05cd8f86e0190", + "certificate.json": "28047357ba06b2b24e39303693a5a7bb14f3ce1e6be28d2f84a78d7dd4d43803", + "inputs/research/current-public-main/tree/certificates/copied-centers-network.json": "7dbd675e42e22ac076280360f8750031851564bb7a56079e66236fee5d0a6cdf", + "inputs/research/current-public-main/tree/scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d", + "inputs/research/optimization.py": "e2c01c0c8570c610d0d8ae864974f59cd67343b4e622a2b019caf99e3cfda80d", + "inputs/research/pr-foundations-mrp-control.json": "52edabac25a5f126f141c4122134fff5c76190513db7732226bcd8c18242c995", + "inputs/research/pr-foundations-mrp-interface.json": "6ba6814c4a784cec253f7102e89289a5a01df1eb889aaaf01338e43bc63f934b", + "inputs/research/pr-foundations-mrp-interface.py": "ee18a011e130f17e370798356247cd017f926a4597e53b14e08cd109e53a4d4d", + "inputs/research/pr-foundations-mrp-interface.txt": "43b96386e6dc6bf157b33526e2977b6c603aa07b66abb2036d476981923c6001", + "inputs/research/pr-foundations-mrp-phase.json": "2ab3ebd4c86d7ae8f2e509f68d2a4bdde86ac2b315be7cc024e87ad7b055cf3b", + "inputs/research/pr-foundations-mrp-phase.py": "5eced9b0b7004a5976d3a6c4da75552f61302551edc5b787f81e0a2e75b55505", + "inputs/research/pr-network-mrp24-proof.txt": "e7c6c6bb6430bc285deb57ebd00a2e892fff9b0e36343a8a51a4b45c95ce622a", + "inputs/research/pr-network-mrp24-signed.json": "9117d3f010354fa2f32d5c5fb324b280977e82e76060a70a867767a90989ccaa", + "inputs/research/pr-network-mrp24.py": "d0e382c59bf6197fc05403d64fd32a6f40aba115b12f0749697f73f16e5dff1c", + "inputs/research/pr-review-network-geometry.json": "552e46201efa32f4ce3069d9f69239ba91e0fca508d94f309f2e836aa7b50cfc", + "inputs/research/pr117-public/COMMIT.json": "d490b77314f02bb477973a99d58e5872225bb95412fddb0dbd407508ad635f6d", + "inputs/research/pr117-public/DOWNLOAD_AUDIT.json": "c3f83b1729675c09d38e86e61b31722adf07f4d9e7a5b48c01e504369cc570a8", + "inputs/research/pr117-public/INHERITED_SOURCE_AUDIT.json": "a9da8fb74c62e74b4a64868f38537f280cc97fea1101a329c9e75261e5657a53", + "inputs/research/pr117-public/TREE.json": "da4551e23fb9d8d7e2fedddbcc9a1aaf7aa7a6d548e873c401b69f21f326ad59", + "inputs/research/pr117-public/tree/certificates/deferred-product-complex-dag.json.gz": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "inputs/research/pr117-public/tree/certificates/deferred-product-complex-input.json": "21f957e6d840e027ffdd1d7d3f95fd7d364c2cdef338c4ca79d25194e24179ca", + "inputs/research/pr117-public/tree/certificates/deferred-product-complex-word.json.gz": "c683e371b647a15944eed570c6cb8f9cb686c9ed24d616bb9c6c00d29803f718", + "inputs/research/pr117-public/tree/certificates/deferred-product-network.json": "3fa91f03cc70bb76d67e2eb75b15dc07c3986fd396845bf14707f91ce3e9f903", + "inputs/research/pr117-public/tree/notes/complex-circuit-construction.tex": "7c3341762dfae1997d658bdc1cdf398c04c4a1347333857b529737f6992048a1", + "inputs/research/pr117-public/tree/notes/copied-centers-complex.tex": "18eac6d5c5755e53230c0c12a633f38b6ce9666ef0322c1aff79394f2952af72", + "inputs/research/pr117-public/tree/notes/endpoint-gauge-complex.tex": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "inputs/research/pr117-public/tree/notes/stopped-product-assembly.tex": "1c3c7147851f30f1ff97679cfcda157b1cbe2655b8766e34f1345f20c630eaec", + "inputs/research/pr117-public/tree/notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "inputs/research/pr117-public/tree/notes/stopped-product-factorization.tex": "70d5a4405e1be9c7b6cfb326bb4ffdf88e5585d1fb3d16c7bb5ad62ac421fae3", + "inputs/research/pr117-public/tree/notes/stopped-product-interface.tex": "454a8f3924afc26e575b2a8cec6d0860397cb7f2dc431f3ba63fb8a7142cc96b", + "inputs/research/pr117-public/tree/notes/structured-bulk-complex.tex": "70eb8da7ea58cd9fcc79aa800bcc98a883ddfc505e91b45e7362afba1c8ea480", + "inputs/research/pr117-public/tree/references/semantic-bulk/pr21/translated-partial-complex.tex": "c5c9bb75a3eede63ad706eabac58c7d31ee480d92fd7e065f5302e726834ee52", + "inputs/research/pr117-public/tree/research/deferred-product/PROOF.md": "e4bdd57667e11d808515c74e8975fb807130cb9192aea97a090f9abdd26c77e8", + "inputs/research/pr117-public/tree/scripts/deferred_product/complex_frames.py": "5adb4d4e2298dcc3730f7480ebda207ef284ffb357185452a3b5cee30a31b39d", + "inputs/research/pr117-public/tree/scripts/deferred_product/replayed.py": "99c1e3694ae06a7ce7a370b04ecb45ea3fcfe69a6e6e7f4c4606e0a6c74c3184", + "inputs/research/pr117-public/tree/scripts/deferred_product_network.py": "420db93c65920bee13e43d3ed9afc1be56891d647a8098b3267a8f71a39fb9f5", + "inputs/research/pr117-public/tree/scripts/endpoint_gauge/match_complex_general.cpp": "fb83c08125521128a38f5ee53f91d192904cc3372ad8f196ad9576e5f4f727da", + "inputs/research/pr117-public/tree/scripts/partial_swap/binary_io.hpp": "d0be783f61ac4b7981e7e48a8c1139b52572302ba76c191c0e9a1b16a1a05e0e", + "inputs/research/round7-public/tree/certificates/round7/deferred_23.json.gz": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c", + "inputs/research/round7-public/tree/certificates/round7/witness_23.json.gz": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588", + "inputs/research/round7-public/tree/independent/deferred-readout/check_lifted.py": "c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c", + "inputs/research/round7-public/tree/independent/deferred-readout/deferred.py": "e92ac1db9fce8608cf5302336f05750fa327eda99f7170ed32e7323220ffc164", + "inputs/research/round7-public/tree/independent/deferred-readout/linalg.py": "56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b", + "inputs/research/round7-public/tree/independent/partial-swap/factor.py": "a246d8d4b4d110125406648f9fb49725894c3652102049caf3555ab191fc0e7b", + "inputs/research/round8-foundations-minimal-v-word.json.gz": "298c11fb29ab0afdf8d762c64a9b99d19a1e58465f3a0cbc9d2a59367c438fb7", + "inputs/research/round8-foundations-reuse117-interface.json": "9358825a1b29a770e23e70118cc24a659fb40bc865099ce8f77110ba31881b53", + "inputs/research/round8-foundations-reuse117-interface.py": "e3fe76a6342290ee703d502f3f51d820c793fabac31a9a92c29f80bc8e1dbe89", + "inputs/research/round8-foundations-reuse117-interface.txt": "6da8d3533c829987871d0c66036d362873cdc601cb01cfbc974893aa64111027", + "inputs/research/round8-foundations-reuse117-ledger.json": "a95f8002acfbd0b98b548c351adad1ec6110bd5133d10fa141072be0c5715f3d", + "inputs/research/round8-foundations-reuse117-ledger.py": "f53f5c7cbf8ad4220b36693acf3ecdcf9ba80184be7a2cdd279eafe12a3f6d9d", + "inputs/research/round8-foundations-transversal-frozen37.json": "218b42e4f59fb04692c2b66ed764a8cc4313706953ad49af27bf5c41ec226342", + "inputs/research/round8-network-final-geometry.py": "b3bc226c305e98d08b3adb4abef6794a607eb3e6f88fa13823c1086c5429228c", + "inputs/research/round8-network-minimal-v-ledger/forward-events.i32.gz": "afa817b15a4b7c30e0086380ac0c629e4672d14e3c03cf7675a743ef91eb3da5", + "inputs/research/round8-network-minimal-v-ledger/result.json": "21621c98008616261f23849015ca1690281440f26633d95d7bcbc6b3e05b7e68", + "inputs/research/round8-network-opposite-profile-proof.txt": "ca181fee5f183d3009b212a77a1ffe6e23f17c29e0eede28a2b3c8026fd644c8", + "inputs/research/round8-network-opposite-profile.json": "8403eb58f658999584de3f1e1af56e0ddb90ce0521ae6a68f9f57864da0dcdd1", + "inputs/research/round8-network-opposite-profile.py": "da2431d5fb6520273310ef6677c1c6c06b981de10d74fc3635dc45ee2d843934", + "inputs/research/round8-network-physical-ledger.py": "e95f693dde0dcff5f1b78fee95794cad4da0f227645e2be001b1d9c57cc78ee4", + "inputs/research/round8-network-pr104-audit.txt": "0ca0c5f861a0e5ba71f3dea74c23587821d498cbe4003605ac5affb2e4fc9d8b", + "inputs/research/round8-network-pr104-check.json": "6ba48bc0c8600369587e3cc63089c14f1d93555d5e104c12bc98a07237518dc2", + "inputs/research/round8-network-pr104-check.py": "4668be8eaf1b2d916dcd593edfde1f161a1470995f6a3140d7a6052fb20b97e1", + "inputs/research/round8-optimize-reuse117-mrp-independent.json": "afdcf5924c812cc23b4dd2c566f1bcaf0ea6443553970d0b4578d987f9a0e22c", + "inputs/research/round8-optimize-reuse117-mrp-independent.py": "28a9b7793e4a3220683e77fbd166f56445719e14470e58e83e1a2c072889fc0c", + "inputs/research/round8-optimize-reuse117-mrp-manifest.json": "0673919cac895b6fa53de877ab5ecdb1ea63a060d73a03919b2214be78ac19a4", + "inputs/research/round8-optimize-reuse117-mrp-manifest.py": "718abf7fa9edc40c8de80717bc687ee5ec8a8fa22a1bf011cdfacc950064a2c3", + "inputs/research/round8-optimize-reuse117-mrp.json": "49c6fcf9a09e2d0da29923c5b599cc0462f2cba188d1f53cc8181e9d10614c0a", + "inputs/research/round8-optimize-reuse117-mrp.py": "ded0f2448e5139a7ad6fe23b36d0b0caa3f4e3966c2bc25f577af01d31afd0fe", + "inputs/research/round8-optimize-reuse117-mrp.txt": "23cb3cf8884770d4c414227a4ff6d466ecb8a9a1d210aad8d55ff6e23ad50144", + "inputs/research/round8-optimize-reuse117-producer.json": "1930531011db468ec495a07eacb680931c7b673c5bfec3fd21924b3243e39685", + "inputs/research/round8-optimize-reuse117-producer.py": "165aeea5e6b42414359435f84b30de00008d59bb1ceb9c88ac14f4b09a836f67", + "inputs/research/round8-optimize-reuse117-source-audit.txt": "940508dbdba76ea47c92fa322a97ed246be004ac91510dea039041a3f6862314", + "licenses/PR117/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "licenses/PR117/NOTICE": "a0030510cd3b5334fb113eae759aadd2c25951bd353dfb69ad9cb780ae5adf30", + "licenses/PR117/PINS.json": "cfe0c800d2190512ac7ad0ab3a9ad4d28888d3a29d76c3e387ac71321431f27f", + "licenses/main/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "licenses/main/NOTICE": "1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f", + "licenses/round7/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "licenses/round7/NOTICE": "058a663112e633ab5349ce33b6119bacca2b9fd6c0a89918c4c0435d6dd7a008", + "verify.py": "3b601db852a88883b6d47f474440154bffe6a9d88ea49b96c467e16e249ef0dd" + } +} diff --git a/research/completed-core-sharing/NOTICE b/research/completed-core-sharing/NOTICE new file mode 100644 index 0000000000..7f73174c62 --- /dev/null +++ b/research/completed-core-sharing/NOTICE @@ -0,0 +1,26 @@ +Completed-core scratch sharing, 2026-10-09 + +This standalone research contribution and its local verification tools were +prepared with substantial OpenAI Codex assistance. It composes and extends +the credited public constructions listed in README.md and PROOF.md. It does +not claim independent external peer review, authorship by predecessor +contributors, or an official OpenAI result or endorsement. + +Original source files and notices are retained without attribution changes +under inputs/ and licenses/. Apache-2.0 remains applicable. The source-level +credit to Zhihao Chen in the local physical-ledger adaptation identifies the +inherited PR97 ledger; this local adaptation was not authored or reviewed +by him unless separately stated in the public source. + +The exact PR117 source pin, source hashes and original README identify +eumemic's producer and integration, with Anthropic Claude assistance. +The round-seven files retain Swapnil Jain's license and notice. Earlier +copied-center, producer, analytic, tape and semantic contributors retain +all attribution in the preserved notices. No license or predecessor notice +is superseded by this file. + +The explicit resolvable-packing generator implements the construction of +Xiande Zhang and Gennian Ge, Journal of Combinatorial Designs 18 (2010), +209-223, DOI 10.1002/jcd.20234, Lemmas 2.2 and 2.4. Their paper is not +redistributed. The signed partial grouping and its finite checks are +included in this contribution. diff --git a/research/completed-core-sharing/PROOF.md b/research/completed-core-sharing/PROOF.md new file mode 100644 index 0000000000..bb84b01291 --- /dev/null +++ b/research/completed-core-sharing/PROOF.md @@ -0,0 +1,276 @@ +# Completed-core sharing with a resolvable triple partition + +This is a conditional finite construction over the PR117 producer at commit +cbb05ce504d571546d9b7794c186a613c659c3bf. It uses the interfaces inherited from +PR104: the arbitrary-dirty carrier compiler, copied rational centers, +translated complex endpoints, paid binary address adapters, and the semantic +precision and fixed-tape recursion theorems. The stopped bit layer, all-size +analytic estimates, eligible-prime/field setup and recovery interfaces remain +inherited. The exact coupled exponent and its strict inequalities are checked +separately by the package verifier. This proof does not claim a dense execution +of every Gaussian transform matrix or an unconditional multiplication theorem. + +## 1. The completed-core contract and its PR117 binding + +Fix one outer triple label $b$. A logical core acts on data $d$ and all its +original dirty auxiliary values $a$ as + +\[ + (d,a)\longmapsto(L_b d,a). +\] + +The auxiliary block is the identity on **each original role**, with no +data/auxiliary or cross-auxiliary mixing. No original auxiliary is assumed zero. +Let $M$ be the product of carrier shears, $V$ the source injection, and $J$ the +combined rational side/center readout. The transparent word applies, in order, + +\[ + M;\ -J;\ M^{-1};\ V;\ M;\ J;\ M^{-1};\ -V. +\] + +Its target increment is +$-JMa+JM(a+Vx)=JMVx$, and its inverse cleanup returns every auxiliary +individually. Thus $JMV=I$ proves the displayed contract for arbitrary +Gaussian-rational dirty inputs, including correlated inputs. + +The PR117 producer retains the exact disjoint and intersection-two outputs, +24 disjoint centers $A_i$, and decoder/scatter + +\[ + T=\frac1{21}\sum_i A_i,\qquad + T-\frac12\sum_{i\in S}A_i. +\] + +The $A_i$ sum input triples avoiding coordinate $i$. For an input meeting $S$ +in $j$ coordinates, this center expression has coefficient $(j-1)/2$. +Adding half the disjoint output and subtracting half the intersection-two +output gives + +\[ + \frac{j-1+[j=0]-[j=2]}2=[j=3]. +\] + +The replay checks these supports over the integers, all carrier matches and +all actual source-to-carrier routing. There are 91770 additions, 8120 roots +and 71185 matched uses, giving + +\[ + R=91770+8120-71185=28705. +\] + +The upstream frame ledger alone is not a signed scalar replay: its addition +events omit signs, and its center incidence placeholders are not the rational +scatter coefficients. The additional audit explicitly binds every operand +to the DAG, every side root and coefficient to its target, and every center +to its excluded coordinate. It evaluates all source indicators through the +actual carrier gates and verifies every intended readout support. This +establishes $JMV=I$ for the actual scalar word. Four arbitrary-dirty integer +cases in each direction also check the signed word and its literal inverse; +these eight finite tests supplement, rather than replace, the universal +inverse-word argument above. + +The physical frame replay checks 778984 events, including 236340 moves, with +no frame violation or reflected continuity break. It verifies the exact paid +histogram, local zero source frames and local full pre-exterior sink frames +for every original auxiliary. Each terminal exterior follows the complete +cleanup word; it is not an internal return edge. + +Write $C_U$ for the actual partial complex transform on a nondegenerate binary +address subspace $U$, and $F$ for the full address space. Telescoping the gate +frames gives, before the terminal exterior, dirty residual $C_A$ in stage one, +where $A=\mathbf F_2^{24}\otimes\langle t_b\rangle$. Stage two has source +$C_{A^\perp}$ and pre-exterior sink $C_F$, hence residual + +\[ + C_F C_{A^\perp}^{-1}=C_A,\qquad + A=\langle t_b\rangle\otimes\mathbf F_2^{24}. +\] + +The source inverse is essential. Reversing the logical shear does not turn +this auxiliary residual into $C_A^{-1}$. Translated endpoint signs, temporary +center copies and data corrections remain those of the inherited compiler. + +## 2. Actual phases and completed-core sharing + +In a common Walsh coordinate system, + +\[ + C_U=H^{-1}\operatorname{diag}(i^{q_U(x)})H,\qquad + q_U(x)=\operatorname{wt}(P_Ux)\pmod4. +\] + +For orthogonal nondegenerate $U,V$, their projected vectors are orthogonal, so + +\[ + \operatorname{wt}(u+v) + =\operatorname{wt}(u)+\operatorname{wt}(v) + -2|\operatorname{supp}(u)\cap\operatorname{supp}(v)| + =\operatorname{wt}(u)+\operatorname{wt}(v)\pmod4. +\] + +Consequently $C_UC_V=C_{U\oplus V}$ exactly, including its scalar phase. +The actual weight modulo four matters: a triple line has active phase $-i$. + +Partition the 2024 triple labels into the supplied 87 groups $J$, each with +binary Gram matrix $I$. For each stage and group allocate $R$ original dirty +streams, replacing the old role index $(\mathrm{stage},b,u)$ by + +\[ + (\mathrm{stage},J,u),\qquad b\in J. +\] + +This is a new input allocation, not an aliasing of independent old values. +Different roles within one core and the two stage banks remain distinct. +Keep every original scalar gate, internal transformation, temporary copied +center and data correction. Run the complete cores of each group consecutively, +omitting only their terminal auxiliary exteriors. + +Within a stage, distinct outer labels use disjoint data fibres. Their grouping +therefore preserves the data map. Each completed core is block diagonal and +accepts every physical scratch state, including the transformed state left by +earlier cores. No residual is commuted through an internal gate, no clean +scratch is assumed, and no inter-core frame conversion is inserted for free. + +After a group, each shared role has residual $C_{G_J}$, where + +\[ + G_J=\bigoplus_{b\in J}A_b,\qquad \dim G_J=24|J|. +\] + +Apply $C_{G_J^\perp}$ to that role. The total action is exactly $C_F$. +A group of size 24 needs no correction. The argument is a whole-state linear +identity, valid with arbitrary spectators and parallel address columns. +The inherited interstage data macros, rank-one copied endpoint corrections, +data signs and bank normalization are retained. + +## 3. The signed 87-group partition and its paid adapters + +The explicit packing instantiates Lemmas 2.2 and 2.4 of Xiande Zhang and +Gennian Ge, *Maximal resolvable packings and minimal resolvable coverings of +triples by quadruples*, Journal of Combinatorial Designs 18 (2010), 209-223, +[DOI 10.1002/jcd.20234](https://doi.org/10.1002/jcd.20234); +[primary author copy](https://staff.ustc.edu.cn/~drzhangx/papers/mrpacking.pdf). +The supplied generator implements and exhaustively checks the finite +construction; no external implementation or redistributed paper is needed. + +There are 83 full classes, each consisting of six disjoint quadruples. +Replacing each quadruple by its four triple faces gives an orthonormal +24-vector group. The 32 remaining triples lie in four disjoint six-point +sets, choosing one endpoint from each of three fixed pairs in each set. + +For the signed variant, fix choices $c,d$ in the latter two pairs and let the +first pair be $\{a,b\}$. Group the two triples $\{a,c,d\},\{b,c,d\}$. +Their orthonormal complement inside that six-point set consists of the other +two tetrahedron faces $\{a,b,c\},\{a,b,d\}$ and the two unused unit coordinates. +Combining corresponding pairs from all four six-point sets yields four groups +of eight triples, each with an explicit 16-vector complement: eight vectors +of weight three and eight unit vectors. This is the accepted signed variant; +it does not use the wholly alternating complements of the disjoint-pair variant. + +The phase checker verifies exact coverage, every Gram entry of each completed +24-vector basis, the actual projections and all quadratic phase coefficients +on zero, the coordinate vectors and their pairwise sums (301 points). +These points determine a weight-of-linear-map quadratic modulo four. A direct +phase proof is also available: on one tetrahedron, at input weights +$0,1,2,3,4$, the numbers of odd face parities are $0,3,2,1,4$. +Three times those counts equal the original weight modulo four. Thus every +full group has exactly the full phase, with no leftover linear character. +The partial groups and their complementary faces have the same identity; +the unused units supply their ordinary positive phases. + +In the displayed complement basis the operator is eight $C^{-1}$ directions +and eight $C$ directions. With + +\[ + C=\frac12\begin{pmatrix}1+i&1-i\\1-i&1+i\end{pmatrix}, + \qquad Z=\operatorname{diag}(1,-1),\qquad C^{-1}=-iZCZ, +\] + +one positive width-16 child, paid diagonal $Z$ signs and paid binary orthogonal +basis adapters implement the complement. The scalar $(-i)^8=1$ already before +tensoring with the other 24-dimensional factor. Hence either stage orientation +uses one width-384 child per nonzero complement, with spectators unchanged. +The inherited binary-address compiler pays the adapters and signs as local +work; they are not extra Gaussian children or free tape permutations. + +The new outer complements must be distinguished from the producer's 3308 +internal alternating rank-two residuals. Their actual four-term Gauss sums +are $+2$ in 1284 cases and $-2$ in 2024 cases. They retain the inherited +general rank-two Gauss normal form, including its binary adapters and unit +phases. They are not replaced by two positive orthonormal directions. +No new odd divisor or recursive rank is introduced by either type of adapter. + +## 4. Complete child list and allocation + +Let $h=24$, $m=576$, $v=2024$, $N=v^2=4096576$ and $\ell=552$. +The new allocation is + +\[ + W=2N+2(87)R=13187822. +\] + +The copied-center histogram $H'_r$ replaces 24 rank-24 original transitions +by rank-one transitions and retains every rank-23 copy transform. Its mass is + +\[ + \sum_r rH'_r=hR+\ell=689472. +\] + +All recursive children are: + +| Class | Multiplicity | Width | +|---|---:|---:| +| Shared-role complement | 229640 | 384 | +| Internal copied-center | $2vH'_r$ | $r>0$ | +| Data macro | $2N$ | 529 | +| Data front | $4N$ | 23 | +| Endpoint copy | $N$ | 1 | + +The exterior multiplicity is $2R\cdot4$. The $2R\cdot83=4765030$ zero-rank +bridges are omitted. All other child classes are unchanged. Since the groups +cover all $v$ labels, the complete list has + +\[ + s=Wm-N+2v\ell=7594323392,\qquad Wm-s=1862080. +\] + +The largest child is 529. The finite role map supplies a schedule on $W$ +equal-volume streams, so each child has volume fraction $1/W$. +Complete-row padding and depth-first recursion use this new allocation; +the old stream count cannot be used with the new denominator. + +## 5. Shared histories, the odd grid and coefficient height + +A completed core is Gaussian dyadic: its data action is a framed integer shear +and its dirty block is $C_A$. The local divisor 21 cancels exactly on completion. +Sequentially reused scratch therefore preserves its existing odd-denominator +exponent. The new complement adapters are permutations and unit signs and +introduce no odd denominator or coefficient growth. + +There are still the same $2v$ cores and core scalar gates at each node. +The increased PR117 scalar count is retained: + +\[ + g_h=592224,\qquad G_0=N+2v(g_h+2h)=2401613632. +\] + +The exact common grid $2^{-P}21^{-K}$, with $K=G_0(D+1)$, covers the active +chain of unfinished calls of depth $D$. No child is rounded or re-encoded. +At the outer return the exact full tensor operation on every original role +is Gaussian dyadic, allowing exact odd-grid unscaling. + +Binary height and magnitude can accumulate across completed cores. The +semantic bound charges the sum of **all** child widths $sf$, every local +scalar operation and one unfinished child at an intermediate peak. It does +not rely on a path confined to one old scratch bank. The verifier retains +the full unreused PR117 semantic constants and checks local charges, +completed-child induction, odd-grid width and stock reserves for + +\[ + (W,s,\text{largest child})=(13187822,7594323392,529). +\] + +The new sharing and signed-complement composition introduce no additional +physical premise. The exact recurrence, stopped-bit transfer and coupled +assembly remain separately checked under the inherited analytic, physical, +tape, field/prime and recovery interfaces stated at the start. diff --git a/research/completed-core-sharing/README.md b/research/completed-core-sharing/README.md new file mode 100644 index 0000000000..ae96e5eecb --- /dev/null +++ b/research/completed-core-sharing/README.md @@ -0,0 +1,104 @@ +# Completed-core scratch sharing + +Under the inherited PR104/PR117 interfaces, this finite construction certifies + +\[ +T(n)=O\!\left(n(\log n)^{1-\kappa}\right),\qquad +\kappa=\frac{12310001053253}{10^{17}}=0.00012310001053253>2^{-13}. +\] + +The contribution shares complex scratch banks **between completed cores** +whose outer triple labels are binary-orthogonal. An explicit partition of all +2024 triples into 83 groups of 24 and four groups of eight reduces the +allocation to 13,187,822 original streams. Every internal operation is retained, +and each partial group pays an explicit signed complement transform for every +shared role. The complex supplier is PR117's regenerated all-disjoint producer +with 28,705 roles. The bit supplier is the included improved deferred word +with its stopped opposite-bank compiler. + +The result is conditional. [PROOF.md](PROOF.md) gives the composition, actual +phase signs, new allocation and precision argument. [certificate.json](certificate.json) +contains the complete exact profile, moment bounds, three row reserves and +all 47 strict constraints plus seven saving margins. No unconditional +multiplication theorem or full expanded Gaussian tape-word execution is claimed. + +## Verify + +From the repository root: + +```sh +python3 research/completed-core-sharing/verify.py +``` + +Requirements: Python 3.10+, a C++17 compiler available as `c++`, and a POSIX +environment. Only the standard library and local pinned sources are used. +The verifier does not install packages or access the network. Do not use `-O`. + +The default command verifies every frozen input hash, then uses a temporary +copy for all generated files. It regenerates the PR117 complex producer and +legal carrier matching; checks the final bit frame geometry; replays all +1,076,483 literal events on all 32,408 formal columns forward and reflected; +and compares decompressed event bytes to the saved word. It reconstructs the +87-group partition and checks its actual phases, explicit signed complement +bases, complete child list, opposite-bank algebra and signed core transfer. +The public PR117 frame ledger alone omits scalar signs; the included separate +source-to-target and inverse-word proof supplies the required scalar linkage. + +All arithmetic bounds are rational. A separate 64-term/degree12 interval +calculation checks the accepted 50-term/degree8 arithmetic. No floating root +is a proof input. Corruption controls reject a coverage-preserving +nonorthogonal group swap, a missing bit scatter, an omitted paid child and +the next kappa grid point. Submitted files remain read-only; gzip timestamps +and elapsed timings are not treated as mathematical data. + +## Profile and scope + +The exact complex saving is 0.0001231305483517511358. The coarse bit saving +is 0.0001245362098479795607; the stopped ordinary wrapper gives +0.0001244501335381315811393. The assembly uses beta=10^-6, eta=10^-16 and +the original-prefix margins. Maximum children 528 and 529 require halving +degrees 367 and 9. All three row reserves are included: degree 22000 exceeds +the required exponent by 20773/25. PR117's scalar count is retained in +G=2,401,613,632 and its conservative semantic guard. + +The proof consumes the transparent individually restored dirty core, paid +copied-center/bit adapters, stopped ordinary-leaf interface, semantic precision, +ordered-affine streaming, analytic/prime setup and exact recovery contracts. +The verifier regenerates PR117's complex producer; its separate bit producer +is not used. The full Gaussian compiler is supported by the stated operator +proof and inherited interfaces. Full repository verification is a separate +command; this script is the focused contribution check. + +For a fixed public comparison, this kappa is 17.8059% above +[PR117](https://github.com/CrocSwap/integer-mult-bounds/pull/117) at +`cbb05ce504d571546d9b7794c186a613c659c3bf`, whose kappa is 0.0001044939. +The public frontier check at 2026-10-09 01:14 UTC also found +[PR122](https://github.com/CrocSwap/integer-mult-bounds/pull/122), at +`b1a6f24e57141637b3ff040d6f2ce9d896ffb9bb`, claiming the coupled conditional +kappa 0.00010941620808215. This certificate is 12.5062% above that value. +PR122's verifier was not replayed here. These are pinned comparisons, not a +claim of global optimality or priority over concurrent work. + +## Provenance + +The partition implements the construction of Xiande Zhang and Gennian Ge, +*Maximal resolvable packings and minimal resolvable coverings of triples by +quadruples*, Journal of Combinatorial Designs 18 (2010), 209-223, Lemmas 2.2 +and 2.4: [DOI 10.1002/jcd.20234](https://doi.org/10.1002/jcd.20234), +[author-hosted paper](https://staff.ustc.edu.cn/~drzhangx/papers/mrpacking.pdf). +The generator and independently checked finite witness are included; the +paper is not redistributed. + +Credit eumemic for PR117's producer and integration; icekylinx for PR104's +rational centers and stopped compiler; Rohan Arun for PR107's arithmetic and +predecessor producer work; Avi Eisenberg and Rohan Gupta for the interval and +dual-suffix producer lineages; Swapnil Jain for the deferred construction; +Zhihao Chen for the reflected/signed, physical-ledger and semantic interfaces; +and predecessor authors identified in the retained notices. Source files and +receipts retain their original names under `inputs/` to preserve proof +bindings. [MANIFEST.json](MANIFEST.json) records their exact bytes. + +This local composition and verification were prepared with substantial +OpenAI Codex assistance. This is not an OpenAI endorsement or independent +external peer review. Original notices remain intact; see [NOTICE](NOTICE) +and `licenses/`. Search histories and generated binaries are excluded. diff --git a/research/completed-core-sharing/certificate.json b/research/completed-core-sharing/certificate.json new file mode 100644 index 0000000000..ad5534790a --- /dev/null +++ b/research/completed-core-sharing/certificate.json @@ -0,0 +1,437 @@ +{ + "kappa": "12310001053253/100000000000000000", + "kappa_decimal": "0.00012310001053253", + "status": "Conditional on the inherited interfaces stated in PROOF.md", + "coarse_bit": { + "saving": "1245362098479795607/10000000000000000000000", + "decimal": "0.0001245362098479795607", + "moment_gap_lower": "40925585448991303/10000000000000000000000000000000000000000", + "next_grid_rejected": "155670262309974451/1250000000000000000000", + "next_grid_excess_lower": "147146990225708609/10000000000000000000000000000000000000000" + }, + "ordinary_bit": "1244501335381315811393/10000000000000000000000000", + "ordinary_leaf": "384599/10000000000", + "theta": "1/1000", + "complex_moment": { + "saving": "615652741758755679/5000000000000000000000", + "decimal": "0.0001231305483517511358", + "moment_gap_lower": "754838593937636459/5000000000000000000000000000000000000000", + "next_grid_rejected": "1231305483517511359/10000000000000000000000", + "next_grid_excess_lower": "481747002555402313/10000000000000000000000000000000000000000" + }, + "complex_profile": { + "dimensions": [ + 24, + 24 + ], + "m": 576, + "N": 4096576, + "B1": 2497335, + "B2": 2497335, + "W": 13187822, + "L": 2234496, + "total_rank": 7594323392, + "deficit": 1862080, + "maxchild": 529, + "copied_histogram": [ + 16754, + 100065, + 67249, + 17471, + 10036, + 4698, + 2549, + 2766, + 7011, + 878, + 10867, + 2385, + 788, + 493, + 420, + 661, + 140, + 431, + 1365, + 1442, + 565, + 0, + 12, + 24, + 0 + ], + "child_multiplicities": { + "1": 409159696, + "2": 272223952, + "3": 70722608, + "4": 40625728, + "5": 19017504, + "6": 10318352, + "7": 11196768, + "8": 28380528, + "9": 3554144, + "10": 43989616, + "11": 9654480, + "12": 3189824, + "13": 1995664, + "14": 1700160, + "15": 2675728, + "16": 566720, + "17": 1744688, + "18": 5525520, + "19": 5837216, + "20": 2287120, + "22": 48576, + "23": 16483456, + "384": 229640, + "529": 8193152 + } + }, + "bridge": { + "complex": { + "m": 576, + "W": 13187822, + "s": 7594323392, + "maxchild": 529, + "halving_degree": 9, + "wire_bits": 24, + "scalar_terms": [ + { + "h": 24, + "v": 2024, + "c": 91770, + "invocations": 2024, + "local_group_upper": 592224, + "copied_center_extra_groups": 48 + }, + { + "h": 24, + "v": 2024, + "c": 91770, + "invocations": 2024, + "local_group_upper": 592224, + "copied_center_extra_groups": 48 + } + ], + "scalar_group_upper": 2401613632 + }, + "semantic": { + "E": 1031531976569127429085896678464, + "literal_charge": 835370797092924958997436, + "strict_literal_gap": 1031531141198330336160937681028, + "B": 1031531976569127429157544027776, + "C0": 19612721086794747362548571317438973216103734289332153416817836032, + "C1": 1, + "induction_gap": 95932473820928850911715647609088, + "fixed_odd_divisor": 21, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding", + "odd_grid_width_slack": 19612721086794747362548571317438971153039781151077294981649098862 + }, + "rows": { + "coefficient": 10377, + "degree": 22000, + "suffix_slope": 88000, + "degree_gap": "20773/25", + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse" + }, + "bit_coarse": { + "m": 529, + "W": 108516254, + "maxchild": 528, + "halving_degree": 367, + "wire_bits": 27 + }, + "ordinary_leaf_row_degree": 252, + "retained_semantic_constants": "PR117 complete unreused circuit; larger than needed after sharing" + }, + "assembly": { + "eta": "1/10000000000000000", + "kappa": "12310001053253/100000000000000000", + "kappa_decimal": "0.00012310001053253", + "certificate": { + "parameters": { + "a_bit": "615651626106013920244321/5000000000000000000000000000", + "a_complex": "615652741758755679/5000000000000000000000", + "tau": "4999384348373893986079755679/5000000000000000000000000000", + "sigma": "4999384347258241244321/5000000000000000000000", + "eta": "1/10000000000000000", + "beta": "1/1000000", + "q": "3078258130530068985569978893986079755679/25000000000000000000000000000000000000000000", + "c": "30782581305300692933957919469929783126768893986079755679/250000000000000000000000000000000000000000000000000000000000", + "epsilon": "249999999999999975000000000000000000000000000000000000000000/250061565162610601382789657708409790580683558893986079755679", + "lambda_": "49993843483738939861413208416106013920244321/50000000000000000000000000000000000000000000", + "lambda_prime": "24996921741869469931014430021106013920244321/25000000000000000000000000000000000000000000", + "alpha_squared_power": "46173871957963534783549683409791196335185000000000000000/250061565162610601382789657708409790580683558893986079755679", + "delta": "1/80000000000000000", + "C0": 19612721086794747362548571317438973216103734289332153416817836032, + "C1": 1, + "kappa": "12310001053253/100000000000000000" + }, + "strict_constraints": { + "bit_positive": "615651626106013920244321/5000000000000000000000000000", + "complex_above_bit": "1115652741758755679/5000000000000000000000000000", + "complex_below_one_over32": "155634347258241244321/5000000000000000000000", + "beta_positive": "1/1000000", + "beta_below_one": "999999/1000000", + "leaf_saving_above_bit": "1/10000000000", + "q_positive": "3078258130530068985569978893986079755679/25000000000000000000000000000000000000000000", + "q_below_internal": "615651626106013920244321/25000000000000000000000000000000000000000000", + "q_below_leaf": "2500000000615651626106013920244321/25000000000000000000000000000000000000000000", + "c_positive": "30782581305300692933957919469929783126768893986079755679/250000000000000000000000000000000000000000000000000000000000", + "c_below_one": "249969217418694699307066042080530070216873231106013920244321/250000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "3078258130530068985569978893986079755679/250000000000000000000000000000000000000000000000000000000000", + "lambda_above_tau": "615651626106013920244321/50000000000000000000000000000000000000000000", + "lambda_above_sigma": "11156527418203208416106013920244321/50000000000000000000000000000000000000000000", + "lambda_above_internal": "615651626106013920244321/50000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "615651626106013920244321/50000000000000000000000000000000000000000000", + "compact_leaf": "2500000000615651626106013920244321/25000000000000000000000000000000000000000000", + "compact_reservations": "3078258130530068985569978893986079755679/250000000000000000000000000000000000000000000000000000000000", + "lambda_prime_below_one": "3078258130530068985569978893986079755679/25000000000000000000000000000000000000000000", + "epsilon_positive": "249999999999999975000000000000000000000000000000000000000000/250061565162610601382789657708409790580683558893986079755679", + "epsilon_below_one": "61565162610626382789657708409790580683558893986079755679/250061565162610601382789657708409790580683558893986079755679", + "guard_width": "61565162610626382789657708409790580683558893986079755679/250061565162610601382789657708409790580683558893986079755679", + "K_geometry": "307825813053256929339579194699300909525819469929783126768893986079755679/2500615651626106013827896577084097905806835588939860797556790000000000000000", + "K_dominates_log": "307825813053006898556997889398604897309769469931014430021106013920244321/2500615651626106013827896577084097905806835588939860797556790000000000000000", + "record_suffix": "61565162610626382789657708409790580683558893986079755679/250061565162610601382789657708409790580683558893986079755679", + "phase_local": "4925213008849860561607454062181863665027003109095799770761106013920244321/20004925213008848110623172616672783246454684711518886380454320000000000000000", + "phase_boundary": "3693909756636832721118812062181912917157091590209419316441106013920244321/20004925213008848110623172616672783246454684711518886380454320000000000000000", + "gamma_sublinear": "15391290652662848006108024999999384348373893986079755679/250061565162610601382789657708409790580683558893986079755679", + "cell_above_band": "249984608709347312151993891975000000615651626106013920244321/500123130325221202765579315416819581161367117787972159511358", + "prime_interval_packing": "61565162610626382789657708409790580683558893986079755679/250061565162610601382789657708409790580683558893986079755679", + "alpha_positive": "46173871957963534783549683409791196335185000000000000000/250061565162610601382789657708409790580683558893986079755679", + "alpha_below_one": "250015391290652637848006108024999999384348373893986079755679/250061565162610601382789657708409790580683558893986079755679", + "alpha_below_one_fourth": "249876869674778747243655458974770625795342818893986079755679/1000246260650442405531158630833639162322734235575944319022716", + "delta_positive": "1/80000000000000000", + "delta_below_one_eighth": "9999999999999999/80000000000000000", + "short_record_fallback": "1249846049190780898822028528619867592941665111391948636979574685024383076253956332751041/1250307825813053006913948288542048952903417794469930398778395000000000000000000000000000", + "small_field_exposure": "30782581305325696012216049999998768696747787972159511358/250061565162610601382789657708409790580683558893986079755679", + "artificial_boundary": "140040633007322999662764304412771664539595689895260186843405321106013920244321/20004925213008848110623172616672783246454684711518886380454320000000000000000", + "literal_scalar_guard": "1031531141198330336160937681028", + "row_product_gap": "20773/25", + "original_prefix_above_kappa": "2739098158547522375129222854242930836162170129010909889383003/25006156516261060138278965770840979058068355889398607975567900000000000000000", + "coordinate_movement_above_kappa": "151573443363920244321/5000000000000000000000000000", + "compact_phase_layer_above_kappa": "238482506921416361301326277158832930355334540071049091826213/25006156516261060138278965770840979058068355889398607975567900000000000000000", + "bulk_exposure_above_kappa": "151573443363920244321/5000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "6156516261064842824645082612438045096169650877200420191965814265968526457/100024626065044240553115863083363916232273423557594431902271600000000000000000", + "scalar_work_above_kappa": "12313032522129982027088292612437798835519208471632322463565814265968526457/100024626065044240553115863083363916232273423557594431902271600000000000000000", + "dimension_above_kappa": "24996921741869467669804762755575382120127596048231538330902440071049091826213/25006156516261060138278965770840979058068355889398607975567900000000000000000" + }, + "margins": { + "original_prefix": "307825813053256929339579194699300909525819469929783126768893986079755679/2500615651626106013827896577084097905806835588939860797556790000000000000000", + "coordinate_movement": "615651626106013920244321/5000000000000000000000000000", + "compact_phase_layer": "30782581305300686777441658409791811986811106013920244321/250061565162610601382789657708409790580683558893986079755679", + "bulk_exposure": "615651626106013920244321/5000000000000000000000000000", + "Gaussian_arithmetic": "3693909756636832721118812062181912917157091590209419316441106013920244321/20004925213008848110623172616672783246454684711518886380454320000000000000000", + "scalar_work": "4925213008849860561607454062181863665027003109095799770761106013920244321/20004925213008848110623172616672783246454684711518886380454320000000000000000", + "dimension": "249999999999999975000000000000000000000000000000000000000000/250061565162610601382789657708409790580683558893986079755679" + }, + "minimum_margin": "30782581305300686777441658409791811986811106013920244321/250061565162610601382789657708409790580683558893986079755679", + "absorption_gap": "238482506921416361301326277158832930355334540071049091826213/25006156516261060138278965770840979058068355889398607975567900000000000000000", + "recurrence": { + "internal": "4999384348373893986079755679/5000000000000000000000000000", + "leaf": "4999384347873893986079755679/5000000000000000000000000000", + "reservations": "249969217418694699307066042080530070216873231106013920244321/250000000000000000000000000000000000000000000000000000000000" + } + }, + "cutoffs": { + "cutoff_log2_input": { + "guard": 873274, + "normalization": 113729, + "alpha": 469328897, + "compact": 4223960065, + "geometry": 24371, + "phase_cell": 19, + "period": 2111980033, + "stopped_leaf": 12002964, + "log_p": 25, + "reservoir": 14 + }, + "common_cutoff": 4223960065, + "power_checkpoints": [ + { + "log2_input": 4223960065, + "powers": { + "alpha": { + "exponent": 779904, + "rhs": 33791723912, + "rhs_bits": 35 + }, + "compact": { + "exponent": 519936, + "rhs": 135166982240, + "rhs_bits": 37 + }, + "period": { + "exponent": 1039872, + "rhs": 67583426088, + "rhs_bits": 36 + }, + "rows": { + "exponent": 1039872, + "rhs": 371708843880000, + "rhs_bits": 49 + }, + "leaf": { + "exponent": 4222, + "rhs": 2304, + "rhs_bits": 12 + } + } + }, + { + "log2_input": 8447920130, + "powers": { + "alpha": { + "exponent": 1559808, + "rhs": 67583404432, + "rhs_bits": 36 + }, + "compact": { + "exponent": 1039872, + "rhs": 270333704320, + "rhs_bits": 38 + }, + "period": { + "exponent": 2079744, + "rhs": 135166787128, + "rhs_bits": 37 + }, + "rows": { + "exponent": 2079744, + "rhs": 743417329600000, + "rhs_bits": 50 + }, + "leaf": { + "exponent": 8445, + "rhs": 2304, + "rhs_bits": 12 + } + } + }, + { + "log2_input": 16895840260, + "powers": { + "alpha": { + "exponent": 3119616, + "rhs": 135166765472, + "rhs_bits": 37 + }, + "compact": { + "exponent": 2079744, + "rhs": 540667148480, + "rhs_bits": 39 + }, + "period": { + "exponent": 4159488, + "rhs": 270333509208, + "rhs_bits": 38 + }, + "rows": { + "exponent": 4159488, + "rhs": 1486834301040000, + "rhs_bits": 51 + }, + "leaf": { + "exponent": 16891, + "rhs": 2304, + "rhs_bits": 12 + } + } + }, + { + "log2_input": 33791680520, + "powers": { + "alpha": { + "exponent": 6239232, + "rhs": 270333487552, + "rhs_bits": 38 + }, + "compact": { + "exponent": 4159488, + "rhs": 1081334036800, + "rhs_bits": 40 + }, + "period": { + "exponent": 8318976, + "rhs": 540666953368, + "rhs_bits": 39 + }, + "rows": { + "exponent": 8318976, + "rhs": 2973668243920000, + "rhs_bits": 52 + }, + "leaf": { + "exponent": 33783, + "rhs": 2304, + "rhs_bits": 12 + } + } + }, + { + "log2_input": 67583361040, + "powers": { + "alpha": { + "exponent": 12478464, + "rhs": 540666931712, + "rhs_bits": 39 + }, + "compact": { + "exponent": 8318976, + "rhs": 2162667813440, + "rhs_bits": 41 + }, + "period": { + "exponent": 16637952, + "rhs": 1081333841688, + "rhs_bits": 40 + }, + "rows": { + "exponent": 16637952, + "rhs": 5947336129680000, + "rhs_bits": 53 + }, + "leaf": { + "exponent": 67566, + "rhs": 2304, + "rhs_bits": 12 + } + } + }, + { + "log2_input": 135166722080, + "powers": { + "alpha": { + "exponent": 24956928, + "rhs": 1081333820032, + "rhs_bits": 40 + }, + "compact": { + "exponent": 16637952, + "rhs": 4325335366720, + "rhs_bits": 42 + }, + "period": { + "exponent": 33275904, + "rhs": 2162667618328, + "rhs_bits": 41 + }, + "rows": { + "exponent": 33275904, + "rhs": 11894671901200000, + "rhs_bits": 54 + }, + "leaf": { + "exponent": 135133, + "rhs": 2304, + "rhs_bits": 12 + } + } + } + ], + "all_interval_argument": "Same retained interval padding: on [Z,Z+k), bound RHS at Z+k and LHS at floor(Z/k); successive LHS doubles while affine RHS grows at most linearly.", + "inherited_thresholds": "Prime supply, eligible fixed rational basis and native setup, catalogue/descriptor bounds and exact recovery remain.", + "practical_runtime_claim": false + } + } +} diff --git a/research/completed-core-sharing/inputs/research/current-public-main/tree/certificates/copied-centers-network.json b/research/completed-core-sharing/inputs/research/current-public-main/tree/certificates/copied-centers-network.json new file mode 100644 index 0000000000..20bbb6806c --- /dev/null +++ b/research/completed-core-sharing/inputs/research/current-public-main/tree/certificates/copied-centers-network.json @@ -0,0 +1,684 @@ +{ + "adopted_sources": { + "files": { + "PROVENANCE.json": "27df488b36b4fa599b6e6b92408a4b37169125f40918c6ff29bb035e4342a7d4", + "README.md": "add72b080a24707aeda0d7a9ab8147003e3dc972575954d597b078aa82fb9619", + "SOURCES.json": "fd12f8ce03a9f504cbf62351e8f5f09b6209e6f9929081f7ad24a8e55cf09d64", + "pr29/LICENSE": "c95bae1d1ce0235ecccd3560b772ec1efb97f348a79f0fbe0a634f0c2ccefe2c", + "pr29/NOTICE": "1b4512d2fe2063aca8e59529f5f1552641b41128872fefa1f3411c991097a49f", + "pr29/SOURCE.json": "b2b71c863ebdb37c4110a13136490b1ee573258a4bc5ec0f72e725513d3896f3", + "pr29/paureel-direct-transfer.tex": "573bbc0ca0799dc255febb4dd35fba1549f3771480a32aa8e181ff62bc7cb253", + "pr29/two-stage-16-note.tex": "e01fc480181fb00d90599e002126b06056e5e574f97fd1d5698cdedb9097b54d", + "pr33/LICENSE": "c95bae1d1ce0235ecccd3560b772ec1efb97f348a79f0fbe0a634f0c2ccefe2c", + "pr33/NOTICE": "6cdb4f22681c300d0cfaa1cc28b7dc0ac3a3295f8ad5d76f779ceebced592847", + "pr33/SOURCE.json": "bb8f77e7da502ae2d36c81e74a899c8356eb21964310c894f4d76c61c7a1ee7f", + "pr33/two-stage-corners-47-45-note.tex": "eba0e302370c0628bab27f675c8961b3005ef2edc2ccb5591465c7f7ef559e5a" + } + }, + "assembly": { + "absorption_gap": "20374595379574062554852831/500038459899423101496154010000000000", + "margins": { + "Gaussian_arithmetic": "2307743950002130057689850384599/40003076791953848119692320800000000", + "bulk_exposure": "384599/10000000000", + "compact_phase_layer": "1922994942310150384599/50003845989942310149615401", + "coordinate_movement": "384599/10000000000", + "dimension": "49999999500000000000000000/50003845989942310149615401", + "original_prefix": "192349498077004980770049615401/5000384598994231014961540100000000", + "scalar_work": "3077141950002129750010650384599/40003076791953848119692320800000000" + }, + "minimum_margin": "1922994942310150384599/50003845989942310149615401", + "parameters": { + "C0": 2358858462850846165593256368932965330169899180021667007021321420800, + "C1": 1, + "a_bit": "384599/10000000000", + "a_complex": "717/10000000", + "alpha_squared_power": "2884742442310150000000/50003845989942310149615401", + "beta": "1/4", + "c": "1922994980770049615401/50000000000000000000000000", + "delta": "1/800000000", + "epsilon": "49999999500000000000000000/50003845989942310149615401", + "eta": "1/100000000", + "kappa": "384569/10000000000", + "lambda_": "999961540100384599/1000000000000000000", + "lambda_prime": "499980770050384599/500000000000000000", + "q": "19229949615401/500000000000000000", + "sigma": "9999283/10000000", + "tau": "9999615401/10000000000" + }, + "recurrence": { + "internal": "9999615401/10000000000", + "leaf": "39997849/40000000", + "reservations": "49998077005019229950384599/50000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "19233740653041002898391369320637/1000076919798846202992308020000000000", + "K_dominates_log": "192299496154009980770050384599/5000384598994231014961540100000000", + "K_geometry": "192349498077004980770049615401/5000384598994231014961540100000000", + "alpha_below_one": "50000961247499999999615401/50003845989942310149615401", + "alpha_below_one_fourth": "49992307020173069549615401/200015383959769240598461604", + "alpha_positive": "2884742442310150000000/50003845989942310149615401", + "artificial_boundary": "280025384083626938967288577050384599/40003076791953848119692320800000000", + "beta_below_one": "3/4", + "beta_positive": "1/4", + "bit_positive": "384599/10000000000", + "bulk_exposure_above_kappa": "3/1000000000", + "c_below_one": "49998077005019229950384599/50000000000000000000000000", + "c_positive": "1922994980770049615401/50000000000000000000000000", + "cell_above_band": "49999037752500000000384599/100007691979884620299230802", + "compact_leaf": "7657550384599/500000000000000000", + "compact_phase_layer_above_kappa": "20374595379574062554852831/500038459899423101496154010000000000", + "compact_reservations": "19229949615401/50000000000000000000000000", + "complex_above_bit": "332401/10000000000", + "complex_below_one_over32": "311783/10000000", + "coordinate_movement_above_kappa": "3/1000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "499980765070951493875728072554852831/500038459899423101496154010000000000", + "epsilon_below_one": "3846489942310149615401/50003845989942310149615401", + "epsilon_positive": "49999999500000000000000000/50003845989942310149615401", + "gamma_sublinear": "961747499999999615401/50003845989942310149615401", + "guard_width": "3846489942310149615401/50003845989942310149615401", + "lambda_above_internal": "384599/1000000000000000000", + "lambda_above_sigma": "33240100384599/1000000000000000000", + "lambda_above_tau": "384599/1000000000000000000", + "lambda_prime_above_lambda": "384599/1000000000000000000", + "lambda_prime_below_one": "19229949615401/500000000000000000", + "leaf_saving_above_bit": "153151/10000000000", + "literal_scalar_guard": "9693793493753822316795466474748", + "original_prefix_above_kappa": "5020759194373805077516392931/500038459899423101496154010000000000", + "phase_boundary": "2307743950002130057689850384599/40003076791953848119692320800000000", + "phase_local": "3077141950002129750010650384599/40003076791953848119692320800000000", + "prime_interval_packing": "3846489942310149615401/50003845989942310149615401", + "q_below_internal": "384599/500000000000000000", + "q_below_leaf": "7657550384599/500000000000000000", + "q_below_reservations": "19229949615401/50000000000000000000000000", + "q_positive": "19229949615401/500000000000000000", + "record_suffix": "3846489942310149615401/50003845989942310149615401", + "row_product_gap": "6548/25", + "scalar_work_above_kappa": "38468690653040995206411369320637/1000076919798846202992308020000000000", + "short_record_fallback": "499980763570836114177458768066390801/500038459899423101496154010000000000", + "small_field_exposure": "1923494999999999230802/50003845989942310149615401" + } + }, + "bit": { + "counts": { + "B1": 90850529, + "B2": 89184800, + "L": 2226400, + "N": 4073300, + "W": 188181929, + "child_multiplicities": { + "1": 2552008332, + "11": 12368273, + "13": 12508849, + "15": 21109768, + "17": 30321728, + "19": 26742560, + "21": 21308442, + "23": 97375675, + "25": 90850529, + "3": 10167311, + "481": 8146600, + "5": 9316541, + "525": 90850529, + "529": 89184800, + "7": 11539514, + "9": 11313286 + }, + "copied_center_circuits": [ + { + "center_ranks": [ + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24, + 24 + ], + "h": 25, + "histogram": [ + 12884, + 50502, + 41948, + 11341, + 13202, + 2948, + 6911, + 1451, + 5205, + 2429, + 3751, + 1361, + 3720, + 2639, + 3241, + 1571, + 3334, + 3366, + 2963, + 4019, + 2608, + 4868, + 12360, + 2802, + 25, + 0 + ] + }, + { + "center_ranks": [ + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22, + 22 + ], + "h": 23, + "histogram": [ + 9840, + 38432, + 32471, + 8898, + 9754, + 2116, + 5737, + 1725, + 4145, + 1547, + 3128, + 1551, + 2893, + 1925, + 2841, + 2450, + 2327, + 3096, + 2344, + 3628, + 9435, + 2110, + 23, + 0 + ] + } + ], + "deficit": 1846900, + "dimensions": [ + 25, + 23 + ], + "m": 575, + "maxchild": 529, + "total_rank": 108202762275 + }, + "enclosure": "24-term atanh log with geometric tail; exp upper 1+u+u^2/(2(1-u/3)); upward 2^-100 rounding", + "exponent": "9999615401/10000000000", + "logarithm_upper_bounds": { + "1": "8055120996289039834986510201087/1267650600228229401496703205376", + "11": "2507713807220875766410757505693/633825300114114700748351602688", + "13": "2401830701873955728941732615841/633825300114114700748351602688", + "15": "4622259533413645906880051247065/1267650600228229401496703205376", + "17": "4463596400121548501302116232465/1267650600228229401496703205376", + "19": "4322601157013306540033070101277/1267650600228229401496703205376", + "21": "2097865150350315252806914288597/633825300114114700748351602688", + "23": "4080409871454311703647630964023/1267650600228229401496703205376", + "25": "993677781208682032834719808971/316912650057057350374175801344", + "3": "1665616117285200439675966682269/316912650057057350374175801344", + "481": "226279144409595120389065954927/1267650600228229401496703205376", + "5": "6014916060561883983162694717895/1267650600228229401496703205376", + "525": "28830107311579700491549403293/316912650057057350374175801344", + "529": "105698746619583572308751728139/1267650600228229401496703205376", + "7": "5588386827848868581896472049205/1267650600228229401496703205376", + "9": "5269807941992563682421223258113/1267650600228229401496703205376" + }, + "moment_upper": "458747952400871058655097514872554580863/458747952401838555823394416015651635200", + "rounding_denominator": 1267650600228229401496703205376, + "saving": "384599/10000000000", + "strict_gap": "967497168296901143097054337/458747952401838555823394416015651635200" + }, + "complex": { + "child_width_multiplicities": [ + [ + 1, + 540572760 + ], + [ + 2, + 336785904 + ], + [ + 3, + 161899920 + ], + [ + 4, + 117097344 + ], + [ + 5, + 93051504 + ], + [ + 6, + 64779624 + ], + [ + 7, + 52822224 + ], + [ + 8, + 70243992 + ], + [ + 9, + 32150664 + ], + [ + 10, + 50699376 + ], + [ + 11, + 22728888 + ], + [ + 12, + 47580624 + ], + [ + 13, + 26208000 + ], + [ + 14, + 44907408 + ], + [ + 15, + 24714144 + ], + [ + 16, + 49192416 + ], + [ + 17, + 20815704 + ], + [ + 18, + 52501176 + ], + [ + 19, + 22624056 + ], + [ + 20, + 46348848 + ], + [ + 21, + 37759176 + ], + [ + 22, + 58961448 + ], + [ + 23, + 40773096 + ], + [ + 24, + 38781288 + ], + [ + 25, + 2208024 + ], + [ + 26, + 3741192 + ], + [ + 27, + 43112160 + ], + [ + 729, + 21464352 + ], + [ + 756, + 516232080 + ] + ], + "counts": { + "B1": 258116040, + "B2": 258116040, + "L": 4953312, + "N": 10732176, + "W": 537696432, + "child_multiplicities": { + "1": 540572760, + "10": 50699376, + "11": 22728888, + "12": 47580624, + "13": 26208000, + "14": 44907408, + "15": 24714144, + "16": 49192416, + "17": 20815704, + "18": 52501176, + "19": 22624056, + "2": 336785904, + "20": 46348848, + "21": 37759176, + "22": 58961448, + "23": 40773096, + "24": 38781288, + "25": 2208024, + "26": 3741192, + "27": 43112160, + "3": 161899920, + "4": 117097344, + "5": 93051504, + "6": 64779624, + "7": 52822224, + "729": 21464352, + "756": 516232080, + "8": 70243992, + "9": 32150664 + }, + "copied_center_circuits": [ + { + "center_ranks": [ + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27 + ], + "h": 28, + "histogram": [ + 14796, + 80867, + 51402, + 24710, + 17872, + 14202, + 9887, + 8062, + 10721, + 4907, + 7738, + 3469, + 7262, + 4000, + 6854, + 3772, + 7508, + 3177, + 8013, + 3453, + 7074, + 5763, + 8999, + 6223, + 5919, + 337, + 571, + 28, + 0 + ] + }, + { + "center_ranks": [ + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27, + 27 + ], + "h": 28, + "histogram": [ + 14796, + 80867, + 51402, + 24710, + 17872, + 14202, + 9887, + 8062, + 10721, + 4907, + 7738, + 3469, + 7262, + 4000, + 6854, + 3772, + 7508, + 3177, + 8013, + 3453, + 7074, + 5763, + 8999, + 6223, + 5919, + 337, + 571, + 28, + 0 + ] + } + ], + "deficit": 5778864, + "dimensions": [ + 28, + 28 + ], + "m": 784, + "maxchild": 756, + "total_rank": 421548223824 + }, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "9999283/10000000", + "logarithm_upper_bounds": { + "1": "6664409020351/1000000000000", + "10": "4361823927357/1000000000000", + "11": "4266513747553/1000000000000", + "12": "4179502370563/1000000000000", + "13": "4099459662889/1000000000000", + "14": "251584480671/62500000000", + "15": "3956358819249/1000000000000", + "16": "3891820298111/1000000000000", + "17": "766239135259/200000000000", + "18": "754807452491/200000000000", + "19": "116249063787/31250000000", + "2": "5971261839791/1000000000000", + "20": "3668676746797/1000000000000", + "21": "3619886582627/1000000000000", + "22": "3573366566993/1000000000000", + "23": "1764457402211/500000000000", + "24": "3486355190003/1000000000000", + "25": "3445533195483/1000000000000", + "26": "3406312482329/1000000000000", + "27": "3368572154347/1000000000000", + "3": "5565796731683/1000000000000", + "4": "5278114659231/1000000000000", + "5": "5054971107917/1000000000000", + "6": "4872649551123/1000000000000", + "7": "2303954527/488281250", + "729": "36367644171/500000000000", + "756": "36367644171/1000000000000", + "8": "4584967478671/1000000000000", + "9": "893436888603/200000000000" + }, + "moment_upper": "93758349669268174319758205865410416369669365194946428036263324886438920093698460010858713501882394775456058947688857504496378147740660153782705622445171968788940999158190850771009870660961702451316489933657453673410640256343163004633261783258126014322372415015196690665271304600343211202483869148840537844645971747977878306709988702092424295624899718047484041316483866997928443286860331217210569026228462754909148637641705274404842932443778349005557711550186032457951943018925944743009981965944635321901441335715694527157550303349516161701526749290641/93758350468742040597605202574977284831296217469066320109478051808997924815747809871469598767080130850070960188766796326960503351359516783898648613566748094827463364859111089535641760861980778679585390033605502742408965381060590533232327198822037065411694190195298932243216687627021627901452126335306662762812143738702048772208327890811345239489466958284593481432876514849600866059475807763859342905535630627309663603819191403583929521929211097357482640322392664177893686057570737252740635363274594047705896938069320731874459272819040000000000000000000", + "saving": "717/10000000", + "strict_gap": "799473866277846996709566868461626852274119892073214726922559004722049349860610885265197736074614901241077938822464125203618856630115942991121576126038522365700920238764631890201019076228268900099948049068998325124717427528599065415563911051089321775180102241577945383026678416698968257186466124918166171990724170465498339188718920943864567240237109440116392647851672422772615476546648773879307167872400514966177486129179086589485432748351924928772206631719941743038644792509730653397329958725804455602353626204716908969469523838298473250709359/93758350468742040597605202574977284831296217469066320109478051808997924815747809871469598767080130850070960188766796326960503351359516783898648613566748094827463364859111089535641760861980778679585390033605502742408965381060590533232327198822037065411694190195298932243216687627021627901452126335306662762812143738702048772208327890811345239489466958284593481432876514849600866059475807763859342905535630627309663603819191403583929521929211097357482640322392664177893686057570737252740635363274594047705896938069320731874459272819040000000000000000000" + }, + "finite_bridge": { + "bit": { + "W": 188181929, + "halving_degree": 9, + "m": 575, + "maxchild": 529, + "wire_bits": 28 + }, + "complex": { + "W": 537696432, + "halving_degree": 20, + "m": 784, + "maxchild": 756, + "s": 421548223824, + "scalar_group_upper": 4793351472, + "scalar_terms": [ + { + "c": 78437, + "copied_center_extra_groups": 56, + "h": 28, + "invocations": 3276, + "local_group_upper": 729892, + "v": 3276 + }, + { + "c": 78437, + "copied_center_extra_groups": 56, + "h": 28, + "invocations": 3276, + "local_group_upper": 729892, + "v": 3276 + } + ], + "wire_bits": 30 + }, + "rows": { + "coefficient": 852, + "contract": "W_complex^D_complex * W_bit^D_bit; one preceding prefix and padding; all temporary copies sequential", + "degree": 2000, + "degree_gap": "6548/25", + "suffix_slope": 8000 + }, + "semantic": { + "B": 9696565176891520488614054257040, + "C0": 2358858462850846165593256368932965330169899180021667007021321420800, + "C1": 1, + "E": 9696565176891520488192506033216, + "induction_gap": 533311084729033626873772984137200, + "literal_charge": 2771683137698171397039558468, + "strict_literal_gap": 9693793493753822316795466474748 + } + }, + "inherited_commit": "0ef3aeb61f55cc0b321ce6a0ef00acee25cefe52", + "kappa": "384569/10000000000", + "scope": "Exact finite moments and assembly; producer and corner certificates checked separately. Copied-stream scheduling, simultaneous basis existence, analytic and tape interfaces remain written proof dependencies.", + "source_sha256": { + "certificates/copied-centers-bit-axes.json": "ed307cef595091b11ba8f8e6ff11302ad8db190227a2fbf34c232fd680206254", + "certificates/copied-centers-complex-input.json": "91a9e54b455ecc36c3150abcf4a1c9138691c8faab464b5ce159ba8e376764e7", + "certificates/copied-centers-corner-25-23.json": "23b0540ddc1d98a775383bfc65c7cf512aad86b399bf71167220b2a8182f5610", + "certificates/copied-centers-input.json": "5f8a57b1a4dd3f271d4e859ad350db3674b74f744127e74a989e7790718cea24", + "notes/copied-centers-assembly.tex": "00117892971ae766188ace0af03030c44164fda105e42b70d84f52c3339a7dcb", + "notes/copied-centers-bit.tex": "ccc8191ddb51698251ed4461a4c26104501b9b2ee37ce3cbe82fa73e85ae40dd", + "notes/copied-centers-complex.tex": "18eac6d5c5755e53230c0c12a633f38b6ce9666ef0322c1aff79394f2952af72", + "notes/copied-centers-lemma.tex": "d0ce6d3d504996aadb098227885224e48df46101daec8893523a0a8b7364d8fe", + "notes/copied-centers-note.tex": "1099559bea3090399a2496bfb8fdf8966ac39d22fd413e35643af5ee0bb08556", + "references/copied-centers/MANIFEST.json": "5636f7beb34ae439f076d36e13d95d3057ce41ccbdba9da63d7727198b093ccb", + "scripts/copied_centers/README.md": "8d348a28fc11615fb686f7d47548db06a5000378b54e0e47438d17292b5942b9", + "scripts/copied_centers/__init__.py": "13db4f09038a2ff5335cbd4dbd93274b0fb16b3c7b51e4de67cbb2801a3f78e1", + "scripts/copied_centers/corners.py": "9eecdc39c67cc18c806a33f0be03986c28591d322881fd60c11f52c625c8067b", + "scripts/copied_centers/physical.py": "837345d1f8753eab0e70f105b1d1bb0db965b993da037b1825ddef3672609d7d", + "scripts/copied_centers_network.py": "409ebfbd8a41c4c4d089aa0949fcf5a949415dc26f57440ffd48b7bd8881e6a9", + "scripts/copied_centers_producer.py": "33afa6fe25677e13656fa8a200a25ed3510ef70c1ff9f1186612cbd9ee75d209", + "scripts/partial_swap_network.py": "acdd81b4dea2815f8838a0c3ea8ac4968f2bc13fd7c99173473d865779096782", + "scripts/structured_bulk_assembly.py": "e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d" + }, + "status": "Conditional copied-center multiplication witness" +} diff --git a/research/completed-core-sharing/inputs/research/current-public-main/tree/scripts/structured_bulk_assembly.py b/research/completed-core-sharing/inputs/research/current-public-main/tree/scripts/structured_bulk_assembly.py new file mode 100644 index 0000000000..b76f9cb5a4 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/current-public-main/tree/scripts/structured_bulk_assembly.py @@ -0,0 +1,103 @@ +#!/usr/bin/env python3 +"""Copyright 2026 icekylinx. Apache-2.0. +Substantial OpenAI GPT-6 Astra and Codex assistance. + +Exact finite bridge and assembly for the round-three networks. + +Adapted parameter calculation and semantic/product-row proof from PR23, +Zhihao Chen (jacklightChen), which attributes routing, phase-cell inverse +and bulk resampling to the RaD project (hipotures), commit +45d9b60355872041f9275f77c057514def0d45bc. This file does not regenerate, +audit, or substitute for the finite-network or analytic source proofs. +""" +from fractions import Fraction as Q + +def js(x): + if isinstance(x,Q):return str(x) + if isinstance(x,dict):return {str(k):js(v) for k,v in x.items()} + if isinstance(x,(tuple,list)):return [js(v) for v in x] + return x + +def halving(m,r): + assert 0=s+E and 2*B+18Q(coeff*51,25) + return dict(bit=dict(m=bit_m,W=bit_W,maxchild=bit_maxchild, + halving_degree=db,wire_bits=wb), + complex=dict(m=m,W=W,s=s,maxchild=r,halving_degree=dc, + wire_bits=wc,scalar_terms=scalar_terms,scalar_group_upper=G), + semantic=dict(E=E,literal_charge=charge,strict_literal_gap=E-charge, + B=B,C0=C0,C1=1,induction_gap=2*B*(m-r)-s-E), + rows=dict(coefficient=coeff,degree=degree,suffix_slope=4*degree, + degree_gap=Q(degree)-Q(coeff*51,25), + contract='W_complex^D_complex * W_bit^D_bit; preceding row prefix, single complete-row padding, nested bit stock restored')) + +def assembly(bit_saving,complex_saving,bridge,kappa,eta=Q(1,10**8),beta=Q(1,4)): + a,b=bit_saving,complex_saving + tau,sigma=1-a,1-b + q=a*(1-2*eta); lp=1-q; lam=(tau+lp)/2 + c=q*(1+eta); eps=(1-eta)/(1+c+q) + minimum=eps*q; r=(minimum+1-eps)/2; delta=eta/8 + internal=tau+(1-beta)*max(sigma-tau,Q(0));leaf=sigma+beta*(1-sigma) + margins=dict(original_prefix=1-eps*(1+c),coordinate_movement=a, + compact_phase_layer=minimum,bulk_exposure=a, + Gaussian_arithmetic=min(1-eps-delta,r-delta), + scalar_work=1-eps-delta,dimension=eps) + slacks=dict(bit_positive=a,complex_above_bit=b-a, + complex_below_one_over32=Q(1,32)-b,beta_positive=beta, + beta_below_one=1-beta,leaf_saving_above_bit=(1-beta)*b-a, + q_positive=q,q_below_internal=1-internal-q,q_below_leaf=1-leaf-q, + c_positive=c,c_below_one=1-c,q_below_reservations=c-q, + lambda_above_tau=lam-tau,lambda_above_sigma=lam-sigma, + lambda_above_internal=lam-internal,lambda_prime_above_lambda=lp-lam, + compact_leaf=lp-leaf,compact_reservations=lp-(1-c), + lambda_prime_below_one=q,epsilon_positive=eps,epsilon_below_one=1-eps, + guard_width=1-eps,K_geometry=1-eps*(1+c),K_dominates_log=eps*c, + record_suffix=1-eps,phase_local=1-eps-delta,phase_boundary=r-delta, + gamma_sublinear=1-eps-r,cell_above_band=eps-(1-r)/2, + prime_interval_packing=1-eps,alpha_positive=r,alpha_below_one=1-r, + alpha_below_one_fourth=Q(1,4)-r,delta_positive=delta, + delta_below_one_eighth=Q(1,8)-delta,short_record_fallback=eps-a, + small_field_exposure=1-eps-minimum, + artificial_boundary=8-eps+r-delta-minimum, + literal_scalar_guard=Q(bridge['semantic']['strict_literal_gap']), + row_product_gap=bridge['rows']['degree_gap']) + slacks.update({name+'_above_kappa':val-kappa for name,val in margins.items()}) + assert all(v>0 for v in slacks.values()),{k:str(v) for k,v in slacks.items() if v<=0} + assert min(margins.values())==minimum + assert margins['original_prefix']-minimum==eta + return dict(parameters=dict(a_bit=a,a_complex=b,tau=tau,sigma=sigma, + eta=eta,beta=beta,q=q,c=c,epsilon=eps,lambda_=lam, + lambda_prime=lp,alpha_squared_power=r,delta=delta, + C0=bridge['semantic']['C0'],C1=1,kappa=kappa), + strict_constraints=slacks,margins=margins,minimum_margin=minimum, + absorption_gap=minimum-kappa, + recurrence=dict(internal=internal,leaf=leaf,reservations=1-c)) diff --git a/research/completed-core-sharing/inputs/research/optimization.py b/research/completed-core-sharing/inputs/research/optimization.py new file mode 100644 index 0000000000..7f37b633d5 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/optimization.py @@ -0,0 +1,187 @@ +"""Historical round-four refinement, superseded by optimization-round5.py. +Independent exact arithmetic refinement of the pinned PR24 histogram. +Only Python stdlib; input is a local JSON file. No downloaded code is imported. +""" +from fractions import Fraction as F +from decimal import Decimal as D, localcontext +from math import factorial +from pathlib import Path +from hashlib import sha256 +import json + +ROOT=Path(__file__).resolve().parents[1] +SOURCE=ROOT/'sources/swapnil/certificates/external/pr24-bit-network.json' + +def ln_interval(x, terms=50): + """Atanh series after dyadic reduction, with exact rational remainder.""" + assert x >= 1 + k=0 + while x>=2: + x/=2 + k+=1 + def series(y): + z=(y-1)/(y+1) + s=sum((z**(2*j+1)/F(2*j+1) for j in range(terms)),F(0))*2 + e=2*z**(2*terms+1)/(F(2*terms+1)*(1-z*z)) + return s,s+e + lo,hi=series(x) + lo2,hi2=series(F(2)) + return lo+k*lo2,hi+k*hi2 + +def ceil_grid(x,g=10**40): + return F(-(-x.numerator*g//x.denominator),g) + +def floor_grid(x,g=10**40): + return F(x.numerator*g//x.denominator,g) + +def exp_interval(x, terms=6): + """Terms 0 through 6, then a geometric upper bound on the tail.""" + assert 0<=x<1 + s=sum((x**j/F(factorial(j)) for j in range(terms+1)),F(0)) + first=x**(terms+1)/factorial(terms+1) + rem=first/(1-x/F(terms+2)) + return s,s+rem + +def inputs(): + data=json.loads(SOURCE.read_text()) + c=data['counts']; W,m,s=c['W'],c['m'],c['total_rank'] + hist=data['child_width_multiplicities'] + assert sum(r*n for r,n in hist)==s + assert W*m-s==c['deficit'] + assert all(1<=r0 for r,n in hist) + logs=[] + for r,n in hist: + lo,hi=ln_interval(F(m,r)) + logs.append((F(r*n,W*m),floor_grid(lo),ceil_grid(hi))) + return data, logs + +def verify_complex(): + """Recheck the regenerated complex histogram and certify its published saving.""" + source=ROOT/'research/complex-h28-source-frames.json' + data=json.loads(source.read_text()) + hist={int(r):n for r,n in data['hist'].items()} + W,m,s=data['W'],data['m'],data['s'] + assert data['checker']['bad']==0 and data['sum_ok'] + assert sum(r*n for r,n in hist.items())==s + assert all(1<=r0 for r,n in hist.items()) + logs=[] + for r,n in hist.items(): + lo,hi=ln_interval(F(m,r)) + logs.append((F(r*n,W*m),floor_grid(lo),ceil_grid(hi))) + a=F(4079603,250000000000) + _,upper=moment_interval(a,logs) + assert upper<1 + return a,data,dict(source=str(source.relative_to(ROOT)),sha256=sha256(source.read_bytes()).hexdigest(), + a_c=str(a),moment_upper_gap=str(1-upper),moment_upper_gap_decimal=dec(1-upper), + input_label_checker=data['checker']) + +def moment_interval(a, logs): + lo=hi=F(0) + for w,L,U in logs: + lo+=w*exp_interval(a*L)[0] + hi+=w*exp_interval(a*U)[1] + return lo,hi + +def dec(q): + with localcontext() as ctx: + ctx.prec=50 + return str(D(q.numerator)/D(q.denominator)) + +def assembly(a,ac,m_c,s_c,beta=F(1,1000)): + """Optimized rational parameters, checked against every round3 row.""" + assert (1-beta)*ac>a + tau=1-a; sigma=1-ac + chi=tau+(1-beta)*max(sigma-tau,F(0)) + leaf=sigma+beta*(1-sigma) + guard_gap=F(1,10**25) + lam=max(tau,sigma,chi)+guard_gap + lamp=max(lam,leaf)+guard_gap + # Explicit integer upper bound on 2+m_c*ln(s_c). + _,ln_s=ln_interval(F(s_c)) + C1=F(2)+ceil_grid(m_c*ln_s,g=1) + eps=F(1,1)/(2-lamp)-F(1,10**25) + x=C1+2 + y=eps + delta=F(1,10**30)/(1+x) + mu=(1-eps)/(2*(1+x)) + poly=(1+x)*delta + constraints={ + 'lambda above tau sigma chi':lam-max(tau,sigma,chi), + 'lambda_prime above lambda and leaf':lamp-max(lam,leaf), + 'lambda_prime below one':1-lamp, + 'beta in (0,1)':min(beta,1-beta), + 'guard eps C1 < 1+x':1+x-eps*C1, + 'precision 2eps+y < 1+x':1+x-2*eps-y, + 'sub-block coupling y>=eps':F(1) if y>=eps else F(-1), + 'reservations':lamp-(2*eps-1)/eps, + 'record regime eps<1':1-eps, + 'record parameter mu positive':mu, + 'record parameter mu<(1-eps)/(1+x)':(1-eps)/(1+x)-mu, + 'delta in (0,1/8)':min(delta,F(1,8)-delta), + } + margins={ + 'prefix moves and top individual round':1-eps, + 'simultaneous butterflies':eps*(1-lamp), + 'fine-bit exposures':1-eps-poly, + 'Gaussian maps':1-eps-poly, + 'chirps twists scalar products':1-eps-poly, + 'packed polynomial products':eps, + 'individually processed reserved axes':1-eps-poly, + 'CRT axis reversal':max(eps,1-eps)*(1-tau), + } + k=floor_grid(min(margins.values())-F(1,10**25),10**21) + assert all(v>0 for v in constraints.values()) + assert all(v>k for v in margins.values()) + simple_k=F(119722292675,10**16) + assert all(v>simple_k for v in margins.values()) + return dict(a_b=str(a),a_c=str(ac),beta=str(beta),kappa=str(k),kappa_decimal=dec(k), + simple_kappa=str(simple_k),simple_kappa_decimal=dec(simple_k), + eps=str(eps),lambda_=str(lam),lambda_prime=str(lamp),x=str(x),y=str(y),delta=str(delta),mu=str(mu),C1=str(C1), + constraints={n:str(v) for n,v in constraints.items()},margins={n:str(v) for n,v in margins.items()},binding=min(margins,key=margins.get)) + +if __name__=='__main__': + data,logs=inputs() + original=ROOT/'research/pr24-original.json' + assert sha256(original.read_bytes()).hexdigest()==data['source']['sha256'] + original_data=json.loads(original.read_text()) + assert all(original_data['bit']['counts'][k]==v for k,v in data['counts'].items()) + assert original_data['bit']['child_width_multiplicities']==data['child_width_multiplicities'] + ac,complex_data,complex_result=verify_complex() + grid=10**22 + lower,upper=119723724000000000,119723730000000000 + assert moment_interval(F(lower,grid),logs)[1]<1 + assert moment_interval(F(upper,grid),logs)[0]>1 + while upper-lower>1: + mid=(upper+lower)//2 + lo,hi=moment_interval(F(mid,grid),logs) + if hi<1: lower=mid + elif lo>1: upper=mid + else: raise ValueError('Need tighter rational bounds') + a_lo,a_hi=F(lower,grid),F(upper,grid) + # kappa < min(eps*a_b,1-eps) implies a_b > kappa/(1-kappa). + # At kappa=2^-16 the required a_b already makes the moment exceed one. + impossible_k=F(1,2**16) + impossible_a=impossible_k/(1-impossible_k) + negative_gap=moment_interval(impossible_a,logs)[0]-1 + assert negative_gap>0 + result={'status':'Historical round-four refinement; superseded by optimization-round5.json', + 'source':data['source'],'moment_root_lower':str(a_lo),'moment_root_upper':str(a_hi), + 'moment_root_lower_decimal':dec(a_lo),'moment_root_upper_decimal':dec(a_hi), + 'moment_gap_at_lower':dec(1-moment_interval(a_lo,logs)[1]), + 'moment_gap_at_upper':dec(moment_interval(a_hi,logs)[0]-1), + 'assembly_ceiling_upper':str(a_hi/(1+a_hi)),'assembly_ceiling_upper_decimal':dec(a_hi/(1+a_hi)), + 'complex':complex_result, + 'negative_control':dict(kappa=str(impossible_k),required_a_b=str(impossible_a), + moment_lower_gap=str(negative_gap),moment_lower_gap_decimal=dec(negative_gap)), + 'assembly':assembly(a_lo,ac,complex_data['m'],complex_data['s'])} + prior=F(59861145819,5*10**15) + k=F(result['assembly']['kappa']) + result['prior_kappa']=str(prior) + result['absolute_improvement']=str(k-prior) + result['relative_improvement_decimal']=dec(k/prior-1) + out=ROOT/'research/optimization.json' + out.write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k not in ('assembly','complex','negative_control')},indent=2)) + print('COMPLEX GAP',complex_result['moment_upper_gap_decimal']) + print('NEGATIVE CONTROL GAP',result['negative_control']['moment_lower_gap_decimal']) + print('ASSEMBLY',result['assembly']['kappa'],result['assembly']['kappa_decimal']) diff --git a/research/completed-core-sharing/inputs/research/pr-foundations-mrp-control.json b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-control.json new file mode 100644 index 0000000000..2981b34936 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-control.json @@ -0,0 +1,16 @@ +{ + "status": "PASS nonorthogonal corruption rejected by actual Gram check, not hash", + "canonical_partition_sha256": "9117d3f010354fa2f32d5c5fb324b280977e82e76060a70a867767a90989ccaa", + "checker_sha256": "5eced9b0b7004a5976d3a6c4da75552f61302551edc5b787f81e0a2e75b55505", + "swapped_groups": [ + 0, + 1 + ], + "swapped_positions": [ + 0, + 0 + ], + "coverage_and_sizes_preserved": true, + "rejection": "non-orthonormal completed group basis", + "canonical_receipt_unchanged": true +} diff --git a/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.json b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.json new file mode 100644 index 0000000000..28561c77f8 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.json @@ -0,0 +1,49 @@ +{ + "status": "PASS PR117 signed-MRP87 completed-core transfer and complete physical child list", + "core_interface_receipt_sha256": "9358825a1b29a770e23e70118cc24a659fb40bc865099ce8f77110ba31881b53", + "physical_scalar_receipt_sha256": "a95f8002acfbd0b98b548c351adad1ec6110bd5133d10fa141072be0c5715f3d", + "partition_sha256": "9117d3f010354fa2f32d5c5fb324b280977e82e76060a70a867767a90989ccaa", + "phase_receipt_sha256": "2ab3ebd4c86d7ae8f2e509f68d2a4bdde86ac2b315be7cc024e87ad7b055cf3b", + "h": 24, + "m": 576, + "v": 2024, + "R": 28705, + "groups": 87, + "W": 13187822, + "rank_mass": 7594323392, + "deficit": 1862080, + "max_child": 529, + "copied_internal_rank_mass": 689472, + "exterior_histogram": { + "384": 229640 + }, + "g_h": 592224, + "G0": 2401613632, + "complete_child_multiplicities": { + "1": 409159696, + "2": 272223952, + "3": 70722608, + "4": 40625728, + "5": 19017504, + "6": 10318352, + "7": 11196768, + "8": 28380528, + "9": 3554144, + "10": 43989616, + "11": 9654480, + "12": 3189824, + "13": 1995664, + "14": 1700160, + "15": 2675728, + "16": 566720, + "17": 1744688, + "18": 5525520, + "19": 5837216, + "20": 2287120, + "22": 48576, + "23": 16483456, + "384": 229640, + "529": 8193152 + }, + "scope": "The unchanged PR117 core interface and new signed partition phase proof are bound separately; exact moments/assembly remain separate" +} diff --git a/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.py b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.py new file mode 100644 index 0000000000..f4200b4175 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-interface.py @@ -0,0 +1,43 @@ +"""Independently rebuild the complete PR117 signed-MRP87 child profile.""" +from pathlib import Path +from collections import Counter +import hashlib,json +HERE=Path(__file__).resolve().parent +read=lambda p:json.loads(p.read_text()) +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +row=read(HERE/'pr117-public/tree/certificates/deferred-product-complex-input.json') +core_path=HERE/'round8-foundations-reuse117-interface.json';core=read(core_path) +ledger_path=HERE/'round8-foundations-reuse117-ledger.json' +assert core['physical_scalar_receipt_sha256']==sha(ledger_path) +assert core['producer_receipt_sha256']==sha(HERE/'round8-optimize-reuse117-producer.json') +assert (row['h'],row['v'],row['R'],row['loss'])==(24,2024,28705,552) +phase_path=HERE/'pr-foundations-mrp-phase.json';phase=read(phase_path) +partition=HERE/'pr-network-mrp24-signed.json' +assert phase['partition_sha256']==sha(partition)=='9117d3f010354fa2f32d5c5fb324b280977e82e76060a70a867767a90989ccaa' +for key in ['all_triples_once','all_actual_Z4_phase_identities','all_complement_bases_explicit', + 'all_tensor_scalar_phases_one','exact_inverse_direction_identity','exact_gaussian_composition', + 'exact_stage2_gauge','wrong_source_sign_negative_control']:assert phase[key] +h=24;v=2024;R=28705;ell=552;m=h*h;N=v*v +H=row['histogram'][:] +assert sum(r*n for r,n in enumerate(H))==h*R+2*ell +assert H[h]==h;H[h]-=h;H[1]+=h +assert sum(r*n for r,n in enumerate(H))==h*R+ell +hist=Counter({r:2*v*n for r,n in enumerate(H) if r and n}) +hist[(h-1)**2]+=2*N;hist[h-1]+=4*N;hist[1]+=N +groups=read(partition)['groups'];assert Counter(map(len,groups))=={24:83,8:4} +for G in groups: + if len(G)(stage,group(b),u), with different stage banks +and no identification of roles inside a core. Every scalar, internal, +center-copy, data-front, macro and endpoint-copy operation is retained. + +Because only completed cores share a stream, the whole-state identity +applies to any transformed dirty input. Their data fibres are disjoint +within each stage. No residual is pushed through internal gates, no free +frame conversion is assumed, and no intermediate dirty input is reset. +The completed core has residual C_A in BOTH stages, using the actual +source inverse in stage two. Each group's complement then restores the +full selected-axis C operation on every newly allocated original role. + +pr-foundations-mrp-interface.py independently rebuilds the complete child +list from PR117's exact row, binds the signed/core and phase receipts, and +checks the following totals: + R=28705; groups=87; W=13187822; + s=7594323392; deficit=1862080; largest child=529. +The only new exterior class is 229640 children of width384. There are +4765030 omitted zero-rank bridges. Internal copied-center mass remains +689472=24R+552; all other child classes are unchanged. + +The increased PR117 scalar bound remains g_h=592224 and G0=2401613632. +The exact odd grid and shared-history height argument are unchanged from +the accepted PR117 transfer audit: completed cores are Gaussian dyadic; +only unfinished calls accumulate divisor21; binary height charges all +children, not an old independent-bank path. Paid binary permutations and +unit signs introduce no new coefficient growth. The largest child falls +from552 to529, which must be reflected in the separate stock/assembly +certificate if using a sharper depth constant. + +Readiness +--------- +There is no unresolved NEW mathematical premise for this signed-MRP87 +composition. Receipt generation and package integration are distinct from +proof obligations. The inherited opposite-bank, stopped transfer, all-size +analytic/physical/tape, field/prime and recovery interfaces remain explicit +conditions. The package must not present an unconditional theorem or claim +a dense execution of every Gaussian transform matrix. The numerical +coupled exponent and all strict inequalities are certified separately. diff --git a/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.json b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.json new file mode 100644 index 0000000000..bae95cc643 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.json @@ -0,0 +1,953 @@ +{ + "status": "PASS signed MRP87 actual phases, explicit paid complement adapters and stage-two signs", + "partition_sha256": "9117d3f010354fa2f32d5c5fb324b280977e82e76060a70a867767a90989ccaa", + "groups": 87, + "group_size_histogram": { + "24": 83, + "8": 4 + }, + "all_triples_once": true, + "all_full_basis_Gram_entries_checked": 50112, + "phase_coefficient_points_per_group": 301, + "all_actual_Z4_phase_identities": true, + "all_complement_bases_explicit": true, + "all_tensor_scalar_phases_one": true, + "exact_inverse_direction_identity": true, + "exact_gaussian_composition": true, + "exact_stage2_gauge": true, + "wrong_source_sign_negative_control": true, + "R": 28705, + "W": 13187822, + "rank_mass": 7594323392, + "deficit": 1862080, + "exterior_histogram": { + "384": 229640 + }, + "zero_rank_bridges_omitted": 4765030, + "records": [ + { + "group": 0, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 1, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 2, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 3, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 4, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 5, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 6, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 7, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 8, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 9, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 10, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 11, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 12, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 13, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 14, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 15, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 16, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 17, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 18, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 19, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 20, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 21, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 22, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 23, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 24, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 25, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 26, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 27, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 28, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 29, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 30, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 31, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 32, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 33, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 34, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 35, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 36, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 37, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 38, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 39, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 40, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 41, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 42, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 43, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 44, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 45, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 46, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 47, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 48, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 49, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 50, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 51, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 52, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 53, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 54, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 55, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 56, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 57, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 58, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 59, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 60, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 61, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 62, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 63, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 64, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 65, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 66, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 67, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 68, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 69, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 70, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 71, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 72, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 73, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 74, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 75, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 76, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 77, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 78, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 79, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 80, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 81, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 82, + "size": 24, + "complement_basis": [], + "negative_C_axes": [], + "positive_C_axes": [], + "tensor_width": 0, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 83, + "size": 8, + "complement_basis": [ + 35, + 37, + 16, + 8, + 2240, + 2368, + 1024, + 512, + 143360, + 151552, + 65536, + 32768, + 9175040, + 9699328, + 4194304, + 2097152 + ], + "negative_C_axes": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13 + ], + "positive_C_axes": [ + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15 + ], + "tensor_width": 384, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 84, + "size": 8, + "complement_basis": [ + 49, + 37, + 2, + 8, + 3136, + 2368, + 128, + 512, + 200704, + 151552, + 8192, + 32768, + 12845056, + 9699328, + 524288, + 2097152 + ], + "negative_C_axes": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13 + ], + "positive_C_axes": [ + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15 + ], + "tensor_width": 384, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 85, + "size": 8, + "complement_basis": [ + 35, + 41, + 16, + 4, + 2240, + 2624, + 1024, + 256, + 143360, + 167936, + 65536, + 16384, + 9175040, + 10747904, + 4194304, + 1048576 + ], + "negative_C_axes": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13 + ], + "positive_C_axes": [ + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15 + ], + "tensor_width": 384, + "tensor_scalar_phase_exponent_mod4": 0 + }, + { + "group": 86, + "size": 8, + "complement_basis": [ + 49, + 41, + 2, + 4, + 3136, + 2624, + 128, + 256, + 200704, + 167936, + 8192, + 16384, + 12845056, + 10747904, + 524288, + 1048576 + ], + "negative_C_axes": [ + 0, + 1, + 4, + 5, + 8, + 9, + 12, + 13 + ], + "positive_C_axes": [ + 2, + 3, + 6, + 7, + 10, + 11, + 14, + 15 + ], + "tensor_width": 384, + "tensor_scalar_phase_exponent_mod4": 0 + } + ], + "scope": "Geometry and phase are standalone; numerical R comes from separately replayed PR117 producer" +} diff --git a/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.py b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.py new file mode 100644 index 0000000000..81db2365c2 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr-foundations-mrp-phase.py @@ -0,0 +1,99 @@ +"""Standalone exact signed-MRP87 phase, complement and Gaussian checks; stdlib.""" +from pathlib import Path +from itertools import combinations +from collections import Counter +import hashlib,json,sys + +path=Path(sys.argv[1]) if len(sys.argv)>1 else Path(__file__).with_name('pr-network-mrp24-signed.json') +raw=path.read_bytes();data=json.loads(raw) +digest=hashlib.sha256(raw).hexdigest() +h=24;triples=list(combinations(range(h),3));masks=[sum(1<>k)&1]) for k in range(3))) + U=tuple(sorted(point(g,factors[0][k][1-((bits>>k)&1)]) for k in range(3))) + G.extend([index[T],index[U]]) + groups.append(G) + +assert Counter(map(len,groups))==Counter({24:83,8:4}) +assert Counter(it.chain.from_iterable(groups))==Counter(range(2024)) +gram_checks=0 +for G in groups: + masks=[sum(1<

>1]) + G.extend(index[tuple(sorted(T))] for T in [(a,c,d),(b,c,d)]) + basis.extend([[a,b,c],[a,b,d], + [point(g,factors[0][1][1-(bits&1)])], + [point(g,factors[0][2][1-(bits>>1)])]]) + signed_groups.append(sorted(G));complements.append(basis) + all_vectors=[sum(1<

", + "tree": { + "sha": "c839635841a1a9dbb4ab7c33dde49581bf626466", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c839635841a1a9dbb4ab7c33dde49581bf626466" + }, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/commits/cbb05ce504d571546d9b7794c186a613c659c3bf", + "comment_count": 0, + "verification": { + "verified": false, + "reason": "unsigned", + "signature": null, + "payload": null, + "verified_at": null + } + }, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/commits/cbb05ce504d571546d9b7794c186a613c659c3bf", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/commit/cbb05ce504d571546d9b7794c186a613c659c3bf", + "comments_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/commits/cbb05ce504d571546d9b7794c186a613c659c3bf/comments", + "author": { + "login": "eumemic", + "id": 94939491, + "node_id": "U_kgDOBaipYw", + "avatar_url": "https://avatars.githubusercontent.com/u/94939491?v=4", + "gravatar_id": "", + "url": "https://api.github.com/users/eumemic", + "html_url": "https://github.com/eumemic", + "followers_url": "https://api.github.com/users/eumemic/followers", + "following_url": "https://api.github.com/users/eumemic/following{/other_user}", + "gists_url": "https://api.github.com/users/eumemic/gists{/gist_id}", + "starred_url": "https://api.github.com/users/eumemic/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/eumemic/subscriptions", + "organizations_url": "https://api.github.com/users/eumemic/orgs", + "repos_url": "https://api.github.com/users/eumemic/repos", + "events_url": "https://api.github.com/users/eumemic/events{/privacy}", + "received_events_url": "https://api.github.com/users/eumemic/received_events", + "type": "User", + "user_view_type": "public", + "site_admin": false + }, + "committer": { + "login": "eumemic", + "id": 94939491, + "node_id": "U_kgDOBaipYw", + "avatar_url": "https://avatars.githubusercontent.com/u/94939491?v=4", + "gravatar_id": "", + "url": "https://api.github.com/users/eumemic", + "html_url": "https://github.com/eumemic", + "followers_url": "https://api.github.com/users/eumemic/followers", + "following_url": "https://api.github.com/users/eumemic/following{/other_user}", + "gists_url": "https://api.github.com/users/eumemic/gists{/gist_id}", + "starred_url": "https://api.github.com/users/eumemic/starred{/owner}{/repo}", + "subscriptions_url": "https://api.github.com/users/eumemic/subscriptions", + "organizations_url": "https://api.github.com/users/eumemic/orgs", + "repos_url": "https://api.github.com/users/eumemic/repos", + "events_url": "https://api.github.com/users/eumemic/events{/privacy}", + "received_events_url": "https://api.github.com/users/eumemic/received_events", + "type": "User", + "user_view_type": "public", + "site_admin": false + }, + "parents": [ + { + "sha": "854ba7dca98651eab2050402384e1a7784534f0a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/commits/854ba7dca98651eab2050402384e1a7784534f0a", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/commit/854ba7dca98651eab2050402384e1a7784534f0a" + } + ], + "stats": { + "total": 14517, + "additions": 14511, + "deletions": 6 + }, + "files": [ + { + "sha": "0b6f8dd385305864d4d94edd1b1c64998419353b", + "filename": ".github/workflows/verify.yml", + "status": "modified", + "additions": 1, + "deletions": 1, + "changes": 2, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/.github%2Fworkflows%2Fverify.yml", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/.github%2Fworkflows%2Fverify.yml", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/.github%2Fworkflows%2Fverify.yml?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -16,7 +16,7 @@ jobs:\n fail-fast: false\n matrix:\n python-version: ['3.11', '3.13', '3.14']\n- group: [community, producers, certificates, ternary, research, tests, strips, clones, positive, joint, pair]\n+ group: [community, producers, certificates, ternary, research, tests, strips, clones, positive, joint, pair, deferred-product]\n steps:\n - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7\n with:" + }, + { + "sha": "9f2cc673123983169f2848d5057ae07462aa09c8", + "filename": "Makefile", + "status": "modified", + "additions": 9, + "deletions": 0, + "changes": 9, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/Makefile", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/Makefile", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/Makefile?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -23,6 +23,7 @@ verify:\n \t$(MAKE) verify-positive\n \t$(MAKE) verify-joint\n \t$(MAKE) verify-pair\n+\t$(MAKE) verify-deferred-product\n \t$(MAKE) verify-tests\n \n verify-community: community-audit-check community-followup-check copied-reversed-producer copied-reversed-check copied-fixed-reversed-producer copied-fixed-reversed-check\n@@ -438,3 +439,11 @@ stopped-product-certificate:\n \tpython3 scripts/stopped_product_network.py\n \n stopped-product-verify: stopped-product-producer stopped-product-certificate\n+\n+.PHONY: deferred-product-verify verify-deferred-product\n+verify-deferred-product: deferred-product-verify\n+deferred-product-verify:\n+\tpython3 scripts/deferred_product_bit_checks.py\n+\tpython3 scripts/deferred_product_complex.py\n+\tpython3 scripts/deferred_product_complex_frames.py\n+\tpython3 scripts/deferred_product_network.py certificates/deferred-product-complex-input.json certificates/deferred-product-network.json" + }, + { + "sha": "f7343a16289ee2691e7dbc592e4c27179eba84ea", + "filename": "NOTICE", + "status": "modified", + "additions": 5, + "deletions": 0, + "changes": 5, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/NOTICE", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/NOTICE", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/NOTICE?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -319,3 +319,8 @@ copied-center proofs. The selected two-stage topology retains Aurel Prosz\n (Paureel), Swapnil Jain and Zhihao Chen's credits; the semantic assembly\n retains PR #21/#23 and RaD's attribution. Paired producers, carrier matching,\n original source notices and each imported license remain unchanged.\n+\n+Deferred product (research/deferred-product, scripts/deferred_product*, certificates/deferred-product-*):\n+copyright 2026 eumemic, Apache-2.0, prepared with Anthropic Claude assistance. The bit word, its ledgers and\n+checks are PR #97's import of Swapnil Jain's round-seven research (research/deferred-signed, its LICENSE and\n+NOTICE retained); scripts/deferred_product/replayed.py adapts PR #104's stopped_product/complex.py (icekylinx)." + }, + { + "sha": "f2e3b79ca2f083db30e382933625f1b2c2737267", + "filename": "README.md", + "status": "modified", + "additions": 9, + "deletions": 0, + "changes": 9, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/README.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/README.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/README.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -3,6 +3,15 @@\n **Community research maintained by Douglas Colkitt \u2014 conditional on the original\n OpenAI #109 framework.**\n \n+## Deferred bit word under stopped-product accounting\n+\n+[research/deferred-product](research/deferred-product/README.md) gives\n+**\u03ba = 1044939/10^10 = 1.044939\u00d710^-4**. It combines Swapnil Jain's round-seven deferred\n+bit word (PR #97, with jacklightChen's ledgers), charged by icekylinx's one-child stopped-product\n+rule (PR #104), with a new h=24 complex producer that uses 28,705 roles in PR #104's framework.\n+Run `make deferred-product-verify`. eumemic prepared the complex producer and the integration\n+with Anthropic Claude assistance.\n+\n ## Stopped product-ring extension\n \n The new construction contributed by **icekylinx**, extending merged" + }, + { + "sha": "a5b0598e4c328acef11baaa32852acdbfc97eeef", + "filename": "certificates/deferred-product-complex-dag.json.gz", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-dag.json.gz", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-dag.json.gz", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fdeferred-product-complex-dag.json.gz?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "92f157e9584017d1af452638abef22e16e206295", + "filename": "certificates/deferred-product-complex-input.json", + "status": "added", + "additions": 55, + "deletions": 0, + "changes": 55, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-input.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-input.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fdeferred-product-complex-input.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,55 @@\n+{\n+ \"h\": 24,\n+ \"v\": 2024,\n+ \"c\": 91770,\n+ \"q\": 8120,\n+ \"baseline_R\": 99890,\n+ \"matched\": 71185,\n+ \"R\": 28705,\n+ \"orientation_changes\": 51863,\n+ \"rank_sum\": 690024,\n+ \"loss\": 552,\n+ \"histogram\": [\n+ 16754,\n+ 100041,\n+ 67249,\n+ 17471,\n+ 10036,\n+ 4698,\n+ 2549,\n+ 2766,\n+ 7011,\n+ 878,\n+ 10867,\n+ 2385,\n+ 788,\n+ 493,\n+ 420,\n+ 661,\n+ 140,\n+ 431,\n+ 1365,\n+ 1442,\n+ 565,\n+ 0,\n+ 12,\n+ 24,\n+ 24\n+ ],\n+ \"central_disjoint\": 24,\n+ \"center_denominator\": 21,\n+ \"dag_sha256\": \"3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b\",\n+ \"scalar_validation\": {\n+ \"ordinary_supports_exact\": true,\n+ \"centers_exact\": true,\n+ \"center_decoder\": \"sum A_i / 21\",\n+ \"scatter_coefficients\": [\n+ \"1/21\",\n+ \"-19/42\"\n+ ],\n+ \"rational_scalar_identity_exact\": true,\n+ \"mixed_center_scatter_exact\": true,\n+ \"binary_frames_nested\": true,\n+ \"binary_frames_nondegenerate\": true\n+ }\n+}" + }, + { + "sha": "6426bc17a99c5c2ee75b984fdc8011a64563bae9", + "filename": "certificates/deferred-product-complex-word.json.gz", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-word.json.gz", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-complex-word.json.gz", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fdeferred-product-complex-word.json.gz?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "fcd087c9fac3f92b676496b4d8367d3f0b95a9c6", + "filename": "certificates/deferred-product-network.json", + "status": "added", + "additions": 478, + "deletions": 0, + "changes": 478, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-network.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fdeferred-product-network.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fdeferred-product-network.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,478 @@\n+{\n+ \"a_complex\": \"26129/250000000\",\n+ \"assembly\": {\n+ \"absorption_gap\": \"622783629289782438948054313869/12502612894847906576432210511290000000000\",\n+ \"margins\": {\n+ \"Gaussian_arithmetic\": \"156777439829236650689342356778948871/1000209031587832526114576840903200000000\",\n+ \"bulk_exposure\": \"26128948871/250000000000000\",\n+ \"compact_phase_layer\": \"130644740435657695478948871/1250261289484790657643221051129\",\n+ \"coordinate_movement\": \"26128948871/250000000000000\",\n+ \"dimension\": \"1249999987500000000000000000000/1250261289484790657643221051129\",\n+ \"original_prefix\": \"13065724304855254338552530321051129/125026128948479065764322105112900000000\",\n+ \"scalar_work\": \"209040337571236629786183259978948871/1000209031587832526114576840903200000000\"\n+ },\n+ \"minimum_margin\": \"130644740435657695478948871/1250261289484790657643221051129\",\n+ \"parameters\": {\n+ \"C0\": 19612721086794747362548571317438973216103734289332153416817836032,\n+ \"C1\": 1,\n+ \"a_bit\": \"26128948871/250000000000000\",\n+ \"a_complex\": \"26129/250000000\",\n+ \"actual_bit_saving\": \"1240189553/10000000000000\",\n+ \"alpha_squared_power\": \"195973362613157669350000000/1250261289484790657643221051129\",\n+ \"beta\": \"1/1000000\",\n+ \"c\": \"130644743048552530321051129/1250000000000000000000000000000\",\n+ \"delta\": \"1/800000000\",\n+ \"epsilon\": \"1249999987500000000000000000000/1250261289484790657643221051129\",\n+ \"eta\": \"1/100000000\",\n+ \"kappa\": \"1044939/10000000000\",\n+ \"lambda_\": \"24997387105139028948871/25000000000000000000000\",\n+ \"lambda_prime\": \"12498693552582578948871/12500000000000000000000\",\n+ \"q\": \"1306447417421051129/12500000000000000000000\",\n+ \"sigma\": \"249973871/250000000\",\n+ \"tau\": \"249973871051129/250000000000000\"\n+ },\n+ \"recurrence\": {\n+ \"internal\": \"249973871051129/250000000000000\",\n+ \"leaf\": \"249973871026129/250000000000000\",\n+ \"reservations\": \"1249869355256951447469678948871/1250000000000000000000000000000\"\n+ },\n+ \"strict_constraints\": {\n+ \"Gaussian_arithmetic_above_kappa\": \"1306542432585020937219459395582349513/25005225789695813152864421022580000000000\",\n+ \"K_dominates_log\": \"13064474174210509983552582578948871/125026128948479065764322105112900000000\",\n+ \"K_geometry\": \"13065724304855254338552530321051129/125026128948479065764322105112900000000\",\n+ \"alpha_below_one\": \"1250065316122177499973871051129/1250261289484790657643221051129\",\n+ \"alpha_below_one_fourth\": \"1249477396034338026965821051129/5001045157939162630572884204516\",\n+ \"alpha_positive\": \"195973362613157669350000000/1250261289484790657643221051129\",\n+ \"artificial_boundary\": \"7001724524350140919410920910485578948871/1000209031587832526114576840903200000000\",\n+ \"beta_below_one\": \"999999/1000000\",\n+ \"beta_positive\": \"1/1000000\",\n+ \"bit_positive\": \"26128948871/250000000000000\",\n+ \"bulk_exposure_above_kappa\": \"5473871/250000000000000\",\n+ \"c_below_one\": \"1249869355256951447469678948871/1250000000000000000000000000000\",\n+ \"c_positive\": \"130644743048552530321051129/1250000000000000000000000000000\",\n+ \"cell_above_band\": \"1249934658877822500026128948871/2500522578969581315286442102258\",\n+ \"compact_leaf\": \"1276128948871/12500000000000000000000\",\n+ \"compact_phase_layer_above_kappa\": \"622783629289782438948054313869/12502612894847906576432210511290000000000\",\n+ \"compact_reservations\": \"1306447417421051129/1250000000000000000000000000000\",\n+ \"complex_above_bit\": \"51129/250000000000000\",\n+ \"complex_below_one_over32\": \"7786371/250000000\",\n+ \"coordinate_movement_above_kappa\": \"5473871/250000000000000\",\n+ \"delta_below_one_eighth\": \"99999999/800000000\",\n+ \"delta_positive\": \"1/800000000\",\n+ \"dimension_above_kappa\": \"12498693428218427052334992950238054313869/12502612894847906576432210511290000000000\",\n+ \"epsilon_below_one\": \"261301984790657643221051129/1250261289484790657643221051129\",\n+ \"epsilon_positive\": \"1249999987500000000000000000000/1250261289484790657643221051129\",\n+ \"gamma_sublinear\": \"65328622177499973871051129/1250261289484790657643221051129\",\n+ \"guard_width\": \"261301984790657643221051129/1250261289484790657643221051129\",\n+ \"lambda_above_internal\": \"26128948871/25000000000000000000000\",\n+ \"lambda_above_sigma\": \"5139028948871/25000000000000000000000\",\n+ \"lambda_above_tau\": \"26128948871/25000000000000000000000\",\n+ \"lambda_prime_above_lambda\": \"26128948871/25000000000000000000000\",\n+ \"lambda_prime_below_one\": \"1306447417421051129/12500000000000000000000\",\n+ \"leaf_saving_above_bit\": \"1/10000000000\",\n+ \"literal_scalar_guard\": \"1031457655662612293186769340668\",\n+ \"original_prefix_above_kappa\": \"125648912577768848203270159426769/12502612894847906576432210511290000000000\",\n+ \"phase_boundary\": \"156777439829236650689342356778948871/1000209031587832526114576840903200000000\",\n+ \"phase_local\": \"209040337571236629786183259978948871/1000209031587832526114576840903200000000\",\n+ \"prime_interval_packing\": \"261301984790657643221051129/1250261289484790657643221051129\",\n+ \"q_below_internal\": \"26128948871/12500000000000000000000\",\n+ \"q_below_leaf\": \"1276128948871/12500000000000000000000\",\n+ \"q_below_reservations\": \"1306447417421051129/1250000000000000000000000000000\",\n+ \"q_positive\": \"1306447417421051129/12500000000000000000000\",\n+ \"record_suffix\": \"261301984790657643221051129/1250261289484790657643221051129\",\n+ \"row_product_gap\": \"1676/5\",\n+ \"scalar_work_above_kappa\": \"2613114876135020414640481975582349513/25005225789695813152864421022580000000000\",\n+ \"short_record_fallback\": \"312467328861691661374974301811795299482174641/312565322371197664410805262782250000000000000\",\n+ \"small_field_exposure\": \"130657244354999947742102258/1250261289484790657643221051129\"\n+ }\n+ },\n+ \"assembly_bit\": \"26128948871/250000000000000\",\n+ \"binding\": \"complex\",\n+ \"bit\": {\n+ \"counts\": {\n+ \"B1\": 51121686,\n+ \"B2\": 51121686,\n+ \"L\": 1792252,\n+ \"N\": 3136441,\n+ \"W\": 108516254,\n+ \"child_multiplicities\": {\n+ \"1\": 239511811,\n+ \"10\": 878416,\n+ \"11\": 1388464,\n+ \"12\": 1080310,\n+ \"13\": 945714,\n+ \"14\": 226688,\n+ \"15\": 2451064,\n+ \"16\": 1508892,\n+ \"17\": 4771074,\n+ \"18\": 2149994,\n+ \"19\": 7367360,\n+ \"2\": 238288050,\n+ \"20\": 8182020,\n+ \"21\": 1466388,\n+ \"22\": 88550,\n+ \"3\": 53377940,\n+ \"4\": 46970462,\n+ \"484\": 6272882,\n+ \"5\": 23632224,\n+ \"506\": 61280142,\n+ \"507\": 545468,\n+ \"508\": 173558,\n+ \"509\": 293986,\n+ \"510\": 580888,\n+ \"511\": 14168,\n+ \"512\": 322322,\n+ \"513\": 17710,\n+ \"514\": 1129898,\n+ \"515\": 127512,\n+ \"516\": 410872,\n+ \"517\": 99176,\n+ \"518\": 1186570,\n+ \"519\": 340032,\n+ \"520\": 322322,\n+ \"521\": 106260,\n+ \"522\": 1583274,\n+ \"523\": 626934,\n+ \"524\": 2854852,\n+ \"525\": 13711082,\n+ \"526\": 4629394,\n+ \"527\": 5653032,\n+ \"528\": 6233920,\n+ \"6\": 7409864,\n+ \"7\": 4105178,\n+ \"8\": 5755750,\n+ \"9\": 2082696\n+ },\n+ \"deficit\": 1344189,\n+ \"dimensions\": [\n+ 23,\n+ 23\n+ ],\n+ \"m\": 529,\n+ \"maxchild\": 528,\n+ \"roles\": 28866,\n+ \"total_rank\": 57403754177\n+ },\n+ \"exponent\": \"4999379477/5000000000\",\n+ \"logarithm_upper_bounds\": {\n+ \"1\": \"1987355562417364065669439618237/316912650057057350374175801344\",\n+ \"10\": \"2515274437229490418617839725263/633825300114114700748351602688\",\n+ \"11\": \"4909728867822167960512763283247/1267650600228229401496703205376\",\n+ \"12\": \"2399714421777289519579293961239/633825300114114700748351602688\",\n+ \"13\": \"4697962657128327885574713503543/1267650600228229401496703205376\",\n+ \"14\": \"1151004910436491358992364195459/316912650057057350374175801344\",\n+ \"15\": \"2258280393397031167285649759463/633825300114114700748351602688\",\n+ \"16\": \"2217374245868088984102352158015/633825300114114700748351602688\",\n+ \"17\": \"4357897653501964928993364503311/1267650600228229401496703205376\",\n+ \"18\": \"4285440755889660536494207989699/1267650600228229401496703205376\",\n+ \"19\": \"1054225602598430741931079593279/316912650057057350374175801344\",\n+ \"2\": \"3535376905093068344529747466859/633825300114114700748351602688\",\n+ \"20\": \"4151880434975661263617415911297/1267650600228229401496703205376\",\n+ \"21\": \"4090031554081046933305076849055/1267650600228229401496703205376\",\n+ \"22\": \"4031060428338848386894499744017/1267650600228229401496703205376\",\n+ \"3\": \"6556765722521218186395115000937/1267650600228229401496703205376\",\n+ \"4\": \"6192085370702817115441231394489/1267650600228229401496703205376\",\n+ \"484\": \"28174651752060127777810254067/316912650057057350374175801344\",\n+ \"5\": \"1477304328485575102713485747439/316912650057057350374175801344\",\n+ \"506\": \"28174651752060127777810254067/633825300114114700748351602688\",\n+ \"507\": \"13461634359740358047256265827/316912650057057350374175801344\",\n+ \"508\": \"51348702935746093527376467017/1267650600228229401496703205376\",\n+ \"509\": \"24427890298974148366428397635/633825300114114700748351602688\",\n+ \"510\": \"46367751143251427268642011075/1267650600228229401496703205376\",\n+ \"511\": \"1371393606332916105007939035/39614081257132168796771975168\",\n+ \"512\": \"20703147159790050056693309941/633825300114114700748351602688\",\n+ \"513\": \"19466414474504369438193979723/633825300114114700748351602688\",\n+ \"514\": \"36464180456598060831658809501/1267650600228229401496703205376\",\n+ \"515\": \"8500082529457066293647807479/316912650057057350374175801344\",\n+ \"516\": \"3942657414643595698964051979/158456325028528675187087900672\",\n+ \"517\": \"7271737386783571020444791587/316912650057057350374175801344\",\n+ \"518\": \"13318691203824549237528752541/633825300114114700748351602688\",\n+ \"519\": \"24192539605019349297275627047/1267650600228229401496703205376\",\n+ \"520\": \"21752402951213312896107403843/1267650600228229401496703205376\",\n+ \"521\": \"19316954363029548999871947393/1267650600228229401496703205376\",\n+ \"522\": \"16886175861292832110759445655/1267650600228229401496703205376\",\n+ \"523\": \"3615012392514444337161355435/316912650057057350374175801344\",\n+ \"524\": \"12038557715820072556759192101/1267650600228229401496703205376\",\n+ \"525\": \"9621682626735229657445885033/1267650600228229401496703205376\",\n+ \"526\": \"901175841480596175664643281/158456325028528675187087900672\",\n+ \"527\": \"2400856280154877413264946061/633825300114114700748351602688\",\n+ \"528\": \"2398582740651589757065655499/1267650600228229401496703205376\",\n+ \"6\": \"1419524320759474653194212865427/316912650057057350374175801344\",\n+ \"7\": \"2741344040614642504793860160533/633825300114114700748351602688\",\n+ \"8\": \"5313416931219497541822967855259/1267650600228229401496703205376\",\n+ \"9\": \"161378412355405628441014735279/39614081257132168796771975168\"\n+ },\n+ \"moment_upper\": \"5136194762828378914240289797743017789/5136194762833176936965807109635571712\",\n+ \"rank_moment\": \"1409269/1409302\",\n+ \"rounding_denominator\": 1267650600228229401496703205376,\n+ \"saving\": \"620523/5000000000\",\n+ \"stopped_adapter\": {\n+ \"atom_exponent\": \"1/1000\",\n+ \"base_ordinary_saving\": \"384599/10000000000\",\n+ \"coarse_toll_exponent\": \"999/1000\",\n+ \"coarse_toll_subordinate_gap\": \"4379477/5000000000\",\n+ \"effective_saving\": \"1240189553/10000000000000\"\n+ },\n+ \"strict_gap\": \"4798022725517311892553923/5136194762833176936965807109635571712\"\n+ },\n+ \"coarse_bit_saving\": \"620523/5000000000\",\n+ \"complex\": {\n+ \"child_width_multiplicities\": [\n+ [\n+ 1,\n+ 409159696\n+ ],\n+ [\n+ 2,\n+ 272223952\n+ ],\n+ [\n+ 3,\n+ 70722608\n+ ],\n+ [\n+ 4,\n+ 40625728\n+ ],\n+ [\n+ 5,\n+ 19017504\n+ ],\n+ [\n+ 6,\n+ 10318352\n+ ],\n+ [\n+ 7,\n+ 11196768\n+ ],\n+ [\n+ 8,\n+ 28380528\n+ ],\n+ [\n+ 9,\n+ 3554144\n+ ],\n+ [\n+ 10,\n+ 43989616\n+ ],\n+ [\n+ 11,\n+ 9654480\n+ ],\n+ [\n+ 12,\n+ 3189824\n+ ],\n+ [\n+ 13,\n+ 1995664\n+ ],\n+ [\n+ 14,\n+ 1700160\n+ ],\n+ [\n+ 15,\n+ 2675728\n+ ],\n+ [\n+ 16,\n+ 566720\n+ ],\n+ [\n+ 17,\n+ 1744688\n+ ],\n+ [\n+ 18,\n+ 5525520\n+ ],\n+ [\n+ 19,\n+ 5837216\n+ ],\n+ [\n+ 20,\n+ 2287120\n+ ],\n+ [\n+ 22,\n+ 48576\n+ ],\n+ [\n+ 23,\n+ 16483456\n+ ],\n+ [\n+ 529,\n+ 8193152\n+ ],\n+ [\n+ 552,\n+ 116197840\n+ ]\n+ ],\n+ \"counts\": {\n+ \"B1\": 58098920,\n+ \"B2\": 58098920,\n+ \"L\": 2234496,\n+ \"N\": 4096576,\n+ \"W\": 124390992,\n+ \"child_multiplicities\": {\n+ \"1\": 409159696,\n+ \"10\": 43989616,\n+ \"11\": 9654480,\n+ \"12\": 3189824,\n+ \"13\": 1995664,\n+ \"14\": 1700160,\n+ \"15\": 2675728,\n+ \"16\": 566720,\n+ \"17\": 1744688,\n+ \"18\": 5525520,\n+ \"19\": 5837216,\n+ \"2\": 272223952,\n+ \"20\": 2287120,\n+ \"22\": 48576,\n+ \"23\": 16483456,\n+ \"3\": 70722608,\n+ \"4\": 40625728,\n+ \"5\": 19017504,\n+ \"529\": 8193152,\n+ \"552\": 116197840,\n+ \"6\": 10318352,\n+ \"7\": 11196768,\n+ \"8\": 28380528,\n+ \"9\": 3554144\n+ },\n+ \"copied_histogram\": [\n+ 16754,\n+ 100065,\n+ 67249,\n+ 17471,\n+ 10036,\n+ 4698,\n+ 2549,\n+ 2766,\n+ 7011,\n+ 878,\n+ 10867,\n+ 2385,\n+ 788,\n+ 493,\n+ 420,\n+ 661,\n+ 140,\n+ 431,\n+ 1365,\n+ 1442,\n+ 565,\n+ 0,\n+ 12,\n+ 24,\n+ 0\n+ ],\n+ \"deficit\": 1862080,\n+ \"dimensions\": [\n+ 24,\n+ 24\n+ ],\n+ \"m\": 576,\n+ \"maxchild\": 552,\n+ \"total_rank\": 71647349312\n+ },\n+ \"enclosure\": \"1+u+u^2/(2(1-u/3))\",\n+ \"exponent\": \"249973871/250000000\",\n+ \"logarithm_upper_bounds\": {\n+ \"1\": \"794513457587/125000000000\",\n+ \"10\": \"2026761283851/500000000000\",\n+ \"11\": \"1979106193949/500000000000\",\n+ \"12\": \"967800252727/250000000000\",\n+ \"13\": \"758231660647/200000000000\",\n+ \"14\": \"3717050331081/1000000000000\",\n+ \"15\": \"1824028729797/500000000000\",\n+ \"16\": \"3583518938457/1000000000000\",\n+ \"17\": \"22018089479/6250000000\",\n+ \"18\": \"8664339757/2500000000\",\n+ \"19\": \"341166868153/100000000000\",\n+ \"2\": \"707870060017/125000000000\",\n+ \"20\": \"1680187693571/500000000000\",\n+ \"22\": \"1632532603669/500000000000\",\n+ \"23\": \"3220613444767/1000000000000\",\n+ \"3\": \"1314373843007/250000000000\",\n+ \"4\": \"4969813299577/1000000000000\",\n+ \"5\": \"2373334874131/500000000000\",\n+ \"529\": \"42559614419/500000000000\",\n+ \"552\": \"42559614419/1000000000000\",\n+ \"6\": \"1141087047867/250000000000\",\n+ \"7\": \"4410197511641/1000000000000\",\n+ \"8\": \"4276666119017/1000000000000\",\n+ \"9\": \"25993019271/6250000000\"\n+ },\n+ \"moment_upper\": \"18843240374007632787574146016054781874229303372624041422947482220006711301370274429947695208980254489816897240548747611244444368743276004072637922808870935882570128680328818549398102450780713937941962148009502862576404939280830970026757843577492332336646723065488256777720033773146986487763286240909696847125138467987925163899059004260396684485872581710426999541532754583126364150054072115355372997092131814707877644608013845328701623183575197641119070403719972578418991013100838433057297005801/18843240374022188813716544876044281641420198178815568353650892358430937800450226684489565657726081944265605298380567945237895333165146352714403020377768596101653776577083920769047814717414992832443374303453601214673790435903462229418347243029115952440677008837427389056462837546815456700841037075627095025847302610157977652099599444263090864581654224459281481215285979205790016268813393751867892110429718325479806730197277547027518014546582984812428424076074828906144073696000000000000000000000\",\n+ \"saving\": \"26129/250000000\",\n+ \"strict_gap\": \"14556026142398859989499767190894806191526930703410138424226499079952254541870448745827454448708057831820333993450964421870348641765097568897660219083647896755102219649712266634278894501412155444098352097385496622631259391589399451623620104030285771939132278742803773668470213077750834717398178722164142170052488200540440002694180095781642748854481673753224622663652118759321636512519113337586510771929085589263701698816391363007787171309353672354856327725082682899161566942702994199/18843240374022188813716544876044281641420198178815568353650892358430937800450226684489565657726081944265605298380567945237895333165146352714403020377768596101653776577083920769047814717414992832443374303453601214673790435903462229418347243029115952440677008837427389056462837546815456700841037075627095025847302610157977652099599444263090864581654224459281481215285979205790016268813393751867892110429718325479806730197277547027518014546582984812428424076074828906144073696000000000000000000000\"\n+ },\n+ \"complex_row_sha256\": \"21f957e6d840e027ffdd1d7d3f95fd7d364c2cdef338c4ca79d25194e24179ca\",\n+ \"finite_bridge\": {\n+ \"bit_coarse\": {\n+ \"W\": 108516254,\n+ \"halving_degree\": 367,\n+ \"m\": 529,\n+ \"maxchild\": 528,\n+ \"wire_bits\": 27\n+ },\n+ \"complex\": {\n+ \"W\": 124390992,\n+ \"halving_degree\": 17,\n+ \"m\": 576,\n+ \"maxchild\": 552,\n+ \"s\": 71647349312,\n+ \"scalar_group_upper\": 2401613632,\n+ \"scalar_terms\": [\n+ {\n+ \"c\": 91770,\n+ \"copied_center_extra_groups\": 48,\n+ \"h\": 24,\n+ \"invocations\": 2024,\n+ \"local_group_upper\": 592224,\n+ \"v\": 2024\n+ },\n+ {\n+ \"c\": 91770,\n+ \"copied_center_extra_groups\": 48,\n+ \"h\": 24,\n+ \"invocations\": 2024,\n+ \"local_group_upper\": 592224,\n+ \"v\": 2024\n+ }\n+ ],\n+ \"wire_bits\": 27\n+ },\n+ \"ordinary_leaf_row_degree\": 252,\n+ \"rows\": {\n+ \"coefficient\": 10620,\n+ \"contract\": \"W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse\",\n+ \"degree\": 22000,\n+ \"degree_gap\": \"1676/5\",\n+ \"suffix_slope\": 88000\n+ },\n+ \"semantic\": {\n+ \"B\": 1031531976569127429157544027776,\n+ \"C0\": 19612721086794747362548571317438973216103734289332153416817836032,\n+ \"C1\": 1,\n+ \"E\": 1031531976569127429085896678464,\n+ \"exact_grid\": \"One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding\",\n+ \"fixed_odd_divisor\": 21,\n+ \"induction_gap\": 48482002898748989170404569305472,\n+ \"literal_charge\": 74320906515135899127337796,\n+ \"strict_literal_gap\": 1031457655662612293186769340668\n+ }\n+ },\n+ \"kappa\": \"1044939/10000000000\",\n+ \"next_kappa_rejection\": \"{'compact_phase_layer_above_kappa': '-31373883009750410934758336863/625130644742395328821610525564500000000'}\",\n+ \"ordinary_bit_saving\": \"1240189553/10000000000000\",\n+ \"status\": \"Conditional stopped product-ring multiplication witness: deferred bit word, selected complex row\"\n+}" + }, + { + "sha": "2b6e7723481daa8a6e28f9e6dc03f688a1fc69a5", + "filename": "certificates/joint-dual-kappa.json", + "status": "modified", + "additions": 1, + "deletions": 1, + "changes": 2, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fjoint-dual-kappa.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fjoint-dual-kappa.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fjoint-dual-kappa.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -842,7 +842,7 @@\n \"scripts/experiments/pin_joint_dual_sources.py\": \"4d31cc0e38b7902709ca5f8f714cba109760d2592346dd7f8dc0b900a2d9fe00\",\n \"scripts/experiments/verify_joint_dual.py\": \"7a31bba1e9c0ded32ae285df2ca9bc91ef20c330f6789fdba361876f3c7a1985\"\n },\n- \"source_manifest_sha256\": \"fd1aab7d75753b4b55b2377f26119dae74f367b0b4fab66cba42d944b3042cc9\",\n+ \"source_manifest_sha256\": \"86f6410e019b72d0675756e1480c607823011e0acfb31ea3dc71bf16cd938797\",\n \"sources\": [\n {\n \"files\": {" + }, + { + "sha": "c72af03fbe41eff594b7add611ee228fc8e3a91a", + "filename": "certificates/joint-dual-validation.json", + "status": "modified", + "additions": 1, + "deletions": 1, + "changes": 2, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fjoint-dual-validation.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/certificates%2Fjoint-dual-validation.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/certificates%2Fjoint-dual-validation.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -226,7 +226,7 @@\n }\n },\n \"bit_saving\": \"2382370177/50000000000000\",\n- \"certificate_sha256\": \"2ed658f05365b28825e24a6e7bac9fc9cc015d5a5d63d9579f4ac6e0640ae559\",\n+ \"certificate_sha256\": \"0c7222cd8184d9f2cf8ac39c72c14acae3b099d25939cecdb2208c2f57811ded\",\n \"kappa\": \"4764513337/100000000000000\",\n \"margins\": 7,\n \"producer_words_regenerated_and_matched\": true," + }, + { + "sha": "a9d3b9856ab18cfdc73d536bb93f97c28c8ec26f", + "filename": "research/deferred-product/PROOF.md", + "status": "added", + "additions": 114, + "deletions": 0, + "changes": 114, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-product%2FPROOF.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-product%2FPROOF.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-product%2FPROOF.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,114 @@\n+# Deferred bit word under one-child accounting: finite certificate and scope\n+\n+## 1. Claim\n+\n+Under the analytic and fixed-tape interfaces retained by PR #104,\n+\n+$$\n+\\kappa=\\frac{1044939}{10^{10}}=1.044939\\times10^{-4}.\n+$$\n+\n+The witness has three parts.\n+\n+- **Bit side.** Swapnil Jain's round-seven deferred word at h = 23 (PR #97 import,\n+ `research/deferred-signed/`), charged by PR #104's one-child rule.\n+- **Complex side.** A new h = 24 producer with all 24 centers disjoint (decoder \u03a3 A_i / 21),\n+ in PR #104's complex framework.\n+- **Assembly.** PR #104's stopped-product assembly at its own PHASE_STOP = 10^-6.\n+\n+`scripts/deferred_product_network.py` checks the claim:\n+\n+- coarse bit saving 620523/(5\u00b710^9), via PR #104's coarse enclosure;\n+- ordinary saving 0.999\u00b7coarse + 0.001\u00b7OLD;\n+- complex saving 26129/(2.5\u00b710^8), via PR #104's sharp moment;\n+- 47 strict constraints and 7 margins;\n+- the next \u03ba grid point is rejected.\n+\n+The complex side binds.\n+\n+## 2. Every bit residual is a projector residual\n+\n+PR #104's rule (`notes/stopped-product-factorization.tex`) makes every proper rank-r projector\n+residual ONE child of width r. It needs one common generic rational basis for the finite list\n+of residuals, together with the opposite-bank convention diag(I, C_n).\n+\n+The round-seven word charges only the following, per stage and invocation. Each is the\n+difference of nested G-orthogonal projectors (G = I \u2212 J/9), or a commuting-idempotent endpoint\n+in the partial-swap form D_A.\n+\n+- Slot chains: start frames, lifted node frames U_n, late-copy intersections, root frames, F.\n+ All are nested and G-nondegenerate (`check_lifted.py`, `check_frames.py` part X).\n+- Slot exteriors:\n+ - stage one: E_1 = I \u2212 (I \u2212 \u03c3_u)\u2297Q, from D_(I\u2212A) D_T = D_(E_1) with A = \u03c3_u\u2297Q \u2264 T = I\u2297Q;\n+ - stage two: E_2 = (I \u2212 P)\u2297I + P\u2297\u03c3_u.\n+ Plain slots have \u03c3_u = 0. The rank is m \u2212 r_u with r_u = h \u2212 dim \u03c3_u (#97 PROOF.md).\n+- Centre copies U_c \u2192 0, of rank h \u2212 1.\n+- y_T chains 0 \u2192 \u03c3 levels \u2192 t_T^\u22a5 and X_S chains \u27e8t_S\u27e9 \u2192 s_i \u2192 F. These are nested in time\n+ order and nondegenerate (`check_frames.py` part Q).\n+- Data connectors (I \u2212 P)\u2297(I \u2212 Q), of rank (h\u22121)\u00b2, and one rank-one copy correction per pair.\n+\n+Garbage readouts y_T \u2212= C_{T,u} z_u are scalar gates at common frames and carry no residual.\n+Nothing else is charged.\n+\n+For each projector the leading principal minors of sizes 1, \u2026, r are nonzero for a generic\n+basis; similarity to diag(I_r, 0) gives a witness. The list is finite, so PR #104's argument\n+gives one common rational basis. Stage two is the complement time-reversal, with the same\n+residual multiset; #97's `round7_literal_frame_ledger.py` checks reflected continuity and the\n+event histogram.\n+\n+## 3. Child list and moment\n+\n+Each stage and invocation contributes:\n+\n+- a child [m \u2212 r_u] for every slot;\n+- a child [r] for every slot chain step and every y_T and X_S chain step;\n+- h children [h \u2212 1] for the centre copies.\n+\n+Globally there are 2N connectors [(h\u22121)\u00b2] and N corrections [1]. With\n+m = 529, v = 1771, R = 28866, N = v\u00b2, W = 2N + 2vR = 108516254 and L = 2vh(h\u22121), the rank sum is\n+\n+ s = Wm \u2212 N + L = 57403754177,\n+\n+as in #97. The largest child is 528, a gauged exterior with r_u = 1. The coarse saving is the\n+largest 10^-10 grid point accepted by PR #104's `coarse_moment` enclosure; the next point fails.\n+PR #104's stopped-adapter conversion then gives the ordinary saving AB.\n+\n+## 4. Complex producer\n+\n+`certificates/deferred-product-complex-dag.json.gz` lists the operand pairs and roots of an\n+h = 24 paired-triple / pair-star / centre-disjoint producer with 91,770 additions.\n+`scripts/deferred_product/replayed.py` recomputes every support, label and rank and runs PR #104's\n+complex checks (root supports, the \u00f721 decoder and scatter identity, nesting, nondegeneracy).\n+\n+PR #104's unchanged matcher then gives:\n+\n+- R = 28,705 roles (PR #104's producer: 44,918);\n+- the histogram in `certificates/deferred-product-complex-input.json`;\n+- a_c = 26129/(2.5\u00b710^8) under PR #104's profile and sharp moment.\n+\n+The 3,308 alternating rank-2 residuals use the one-child Gauss normal form that PR #104\n+already states for all binary residuals. An independent gate-frame replay of the full signed\n+two-stage word gave:\n+\n+- 0 violations once alternating residuals are allowed;\n+- reflected continuity;\n+- a histogram equal to the row.\n+\n+## 5. Bridge, assembly and scope\n+\n+PR #104's bridge is reused with one change. The maximum bit child is 528, so the coarse halving\n+degree is 367, and the product row stock is the smallest multiple of 1000 above (51/25) times\n+the coefficient (p^22000), by `copied_centers_network.py`'s rule. The stock enters only the\n+row-product slack and eventual cutoffs.\n+\n+The assembly bit is min(AB, (1 \u2212 PHASE_STOP)\u00b7a_c \u2212 10^-10), which is complex-bound here.\n+\n+PR #104's written interfaces remain assumptions:\n+\n+- opposite-bank factorization and atom streaming;\n+- ordinary conversion;\n+- the common odd-denominator grid;\n+- the retained analytic and tape transfer.\n+\n+This is a finite conditional certificate. It makes no claim of global optimality, practical\n+speedup, or a formalized theorem." + }, + { + "sha": "5bb63d08557484e442e059c2b0832aeffe407e60", + "filename": "research/deferred-product/README.md", + "status": "added", + "additions": 37, + "deletions": 0, + "changes": 37, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-product%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-product%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-product%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,37 @@\n+# Deferred bit word and a new complex producer under stopped-product accounting\n+\n+**\u03ba = 1044939/10^10 = 1.044939\u00d710^-4**, conditional on PR #104's retained interfaces. This is\n+**+34.06% over PR #104** (7.79476\u00d710^-5).\n+\n+- **Bit side.** Swapnil Jain's round-seven deferred word (PR #97's import, h = 23) is charged\n+ by PR #104's one-child rule. Every residual is a nested projector residual, so each counts\n+ as one child. The coarse saving is 620523/(5\u00b710^9) = 1.2410\u00d710^-4, and the ordinary saving\n+ after stopping is 1.2402\u00d710^-4.\n+- **Complex side.** A new h = 24 producer with all 24 centers disjoint uses 28,705 roles,\n+ against 44,918 for PR #104's producer. That gives a_c = 26129/(2.5\u00b710^8) = 1.0452\u00d710^-4 in\n+ PR #104's framework, and this side binds.\n+- **Assembly.** PR #104's assembly runs at PHASE_STOP = 10^-6. The largest bit child is 528,\n+ so the bit halving degree is 367 and the row stock p^22000.\n+\n+```sh\n+make deferred-product-verify\n+```\n+\n+The target does the following:\n+\n+1. Replays #97's literal ledger (both shears, reflected continuity, event histogram).\n+2. Runs Swapnil Jain's exact frame check.\n+3. Rebuilds the complex row from the shipped DAG with PR #104's unchanged matcher.\n+ It then replays the complete signed two-stage complex word at gate level: nesting, whole\n+ residuals, reflection, and a paid histogram equal to the row's profile. The 3,308\n+ alternating rank-2 residuals use PR #104's one-child Gauss normal form.\n+4. Recomputes the one-child list, both moments and the assembly.\n+\n+[PROOF.md](PROOF.md) lists the preconditions and the scope.\n+\n+Credits:\n+\n+- **Bit network:** Swapnil Jain (round seven).\n+- **Ledgers and integration:** jacklightChen (PR #97).\n+- **Stopped-product accounting, framework and assembly:** icekylinx (PR #104), on its retained lineage.\n+- **Complex producer and this integration:** eumemic, with Anthropic Claude assistance." + }, + { + "sha": "d96717353e80003b5c43c45e966c3afb87c17387", + "filename": "research/deferred-signed/PROOF.md", + "status": "added", + "additions": 245, + "deletions": 0, + "changes": 245, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FPROOF.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FPROOF.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2FPROOF.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,245 @@\n+# Deferred bit endpoints and a signed two-stage complex interface\n+\n+Under the analytic and fixed finite-alphabet multitape interfaces already\n+retained by main, the networks in this package give the conditional bound\n+\n+\\[\n+T(n)=O\\bigl(n(\\log n)^{1-\\kappa}\\bigr),\\qquad\n+\\kappa=63965813/10^{12}>2^{-14}.\n+\\]\n+\n+The finite checks do not formalize these inherited interfaces or establish an\n+unconditional integer-multiplication theorem. Repository integration validation\n+is recorded separately; mathematical certificates and validation receipts have\n+different purposes. This is not a current-record or global-priority claim.\n+\n+The scalar/frame inputs are Swapnil Jain's round7 bit network and round6 complex\n+network, pinned at `741e7aa078392553815df7926ee17ac5e25a8c38`. The original source,\n+notes, licenses and assistance disclosures are preserved in `swapnil-round7/`.\n+That source reports a slightly larger final number under its own analytic\n+stack. We instead use main's retained semantic guard and balanced assembly.\n+Our additions are explicit reflected scheduling, the commuting fan-order\n+clarification, gauged exits, a signed complex endpoint correction and a bridge\n+to the existing main interfaces. No separately researched local role saving is\n+added to these networks without recompilation.\n+\n+## Bit word, geometry and common basis\n+\n+The pinned producer at h=23 has v=1771 and R=28866. Its frozen supports, links,\n+deferred readouts, V leaves and rational frames are checked by the original\n+`check_word.py`, `check_frames.py` and `check_lifted.py`. In particular, the\n+deferred scratch slots are untouched before their deferred readout; their\n+entrance frames lie in every required target hyperplane. These are conditions\n+on the complete physical word, not just its ordinary-input support.\n+\n+`round7_literal_frame_ledger.py` expands that word into 1080616 events and\n+checks the forward shear on all 32408 ordinary/dirty F2 basis vectors. Gates\n+with several fan recipients are expanded in stable order of their starting\n+frame dimension. The recipients are distinct targets of the same unchanged\n+source, so these XORs commute. The separately checked chains prove nesting;\n+rank order alone is insufficient. This changes the internal order of160 fan\n+groups and avoids otherwise uncharged frame retreats, preserving their scalar\n+map and all costs. The imported source is left intact.\n+\n+Reverse time, complement the factor frames and exchange the data banks for\n+stage two. All ordinary gates retain their XOR direction after the exchange.\n+The new ledger checks continuity and the complete opposite shear; a logical\n+transpose alone would not prove this statement. A copied-center scatter is a\n+macro: copy the unchanged center, transport the copy, scatter and discard the\n+copy. Its reflection creates a new copy at the complemented source and moves\n+it to the complemented target. No unknown dirty register is erased.\n+\n+For an idempotent A write D_A=[[I-A,A],[A,I-A]]. Commuting idempotents satisfy\n+D_A D_B=D_(A+B-2AB). Let P,Q be the two rank-one triple projectors, sigma the\n+local auxiliary entrance projector of rank f, m=h\u00b2, and r=h-f. Stage one's\n+incoming gauge is A=sigma tensor Q, its last live frame is T=I tensor Q,\n+and its terminal gauge is I-A. Its exterior is\n+\n+\\[\n+E_1=I-T+A=I-(I-\\sigma)\\otimes Q,\\qquad\\operatorname{rank}E_1=m-r.\n+\\]\n+\n+Direct multiplication gives D_(I-A)D_T=D_E1 and D_(I-A)D_A=D_I. For stage two\n+put B=(I-P) tensor I and lift a factor frame K to B+P tensor K. Its entrance\n+is B, last live frame is I-P tensor sigma, terminal gauge is I-B, and\n+\n+\\[\n+E_2=B+P\\otimes\\sigma,\\qquad\\operatorname{rank}E_2=m-r.\n+\\]\n+\n+Again D_(I-B)D_(I-P tensor sigma)=D_E2 and D_(I-B)D_B=D_I. These are genuine\n+commuting-idempotent exits, not an assumption that all endpoint movements are\n+nested. Scalar dirty restoration and complementary gauges give the full\n+address swap. Both exteriors are charged as block m-2r and the inner(r,h)\n+profile of their complementary small residual.\n+\n+With U=P tensor Q, stage-one data ends at (I tensor Q,(I-P) tensor Q), while\n+stage two begins at (B+U,B). Each connector is (I-P) tensor (I-Q), of rank\n+(h-1)\u00b2, and both are charged. The final F2 scalar shear pair gives (y,x+y);\n+the temporary rank-one correction uses D_U D_I=D_(I-U) to remove the extra\n+term, retaining one paid rank-one child per pair.\n+\n+The common rational tensor basis and inner residual profiles use the preserved\n+`notes/flag-basis.tex`, `notes/partial-swap-batching.tex` and the round7 lifted\n+checks. The staircase corner adds runs h-2,h-5,1^6, alongside the outer block\n+m-4h+2. `check_stair.py` checks its finite witnesses and symbolic cut bounds.\n+The GL_h\u00d7GL_h family acts transitively on line pairs; nonzero polynomial\n+witnesses, together with identically imposed triangular zero conditions, give\n+a common rational point for the finite family. This is an existence argument,\n+not a claim that sampled pairs enumerate the family or that one modular basis\n+is already a common integer basis. Rational enumeration avoiding the finitely\n+many nonzero determinant polynomials is an effective fixed finite choice.\n+Its denominators and required minors exclude finitely many odd primes, as in\n+the retained transfer. All choices are independent of n. The two orientations\n+and newly gauged residuals occur among the checked inner families.\n+\n+The actual event histogram, including exits, connectors and corrections,\n+matches the pinned one with m=529, W=108516254 and s=57403754177. An independent\n+rational moment enclosure proves saving a_b=31987/500000000.\n+\n+## Complex scalar word and phases\n+\n+For the h24 paired triple-exclusion producer, let M be its invertible role\n+mixer, V the source injection and A the complete signed readout. The retained\n+totals are T and E_i=sum of triples avoiding i, for i=s+E and direct leaves obey A(e)<=8e. Prefix kernels and\n+outer normalization add at most18e, below the C0e allowance. Thus the same\n+fixed fine-grid proof yields C1=1; it does not concatenate temporary internal\n+excess of already completed children. E and C0 are large but fixed.\n+\n+The actual maximum child and width determine each least halving degree d_j\n+and bitlength w_j. Reserve the product W_c^D_c W_b^D_b, with\n+D_j=d_j ceil(log2(e)), rather than the maximum of the two stocks. The existing\n+physically preceding transformed prefix and one complete-row padding supply\n+the recomputed stock; nested bit stock is restored before another complex\n+child. Sequential temporary copies use this existing row field and do not\n+introduce a separately live recursive row reservation. The certificate gives\n+the exact coefficient and sufficient stock degree. These operations preserve\n+the fixed alphabet, fixed tape count and polynomial descriptor bounds of the\n+inherited interfaces; the number of fixed-role streams is not the number of\n+physical tapes.\n+\n+## Final exact combination\n+\n+Use beta=1/10 and eta=10^-8. The stopped complex saving (1-beta)a_c exceeds\n+a_b. Put q=a_b(1-2eta), c=q(1+eta), epsilon=(1-eta)/(1+c+q), lambda'=1-q,\n+lambda=((1-a_b)+lambda')/2, g=epsilon*q,\n+r=(g+1-epsilon)/2 and delta=eta/8. The inherited balanced combination now\n+has all47 strict constraints and all7 margins above63965813/10^12; the\n+next10^-12 grid point is rejected. This includes the recomputed scalar\n+charge, product-row gap, compact reservations, phase-cell separation, prime\n+packing and exact recovery allowances. A second moment implementation\n+checks both complete recursive histograms with exact rational logarithm and\n+exponential enclosures. Passing arithmetic does not by itself establish any\n+of the physical or analytic lemmas above.\n+\n+## Attribution and scope\n+\n+Zhihao Chen (jacklightChen): explicit reflected event ledgers, commuting\n+fan-order clarification, nonzero auxiliary endpoint proof, signed complex\n+phase controls and corrected rank-one endpoint, and integration with the\n+retained balanced semantic assembly, with Codex assistance. Subsequent work\n+using these specific contributions should explicitly acknowledge Zhihao Chen.\n+Historical GPT-6 Astra assistance attribution on PR7/PR23/PR29 remains;\n+no claim about the current runtime model is made.\n+\n+Swapnil Jain supplies deferred readouts, V leaves, lifted frames, the h24\n+producer, common flag/staircase family and frozen witnesses, with the original\n+Claude assistance disclosure. Avi Eisenberg/ikeboy PR62 supplies interval\n+strips and core-aware pair assembly; RaD/hipotures PR41 supplies alternating\n+order/links, and Rohan Arun PR44 the weighted-link precedent. Aurel Prosz/\n+Paureel supplies two-stage/complement scheduling; icekylinx PR36 supplies\n+copied-center and bridge precedents; James Chang PR34 supplies balanced\n+combination and reversed geometry; Zhihao Chen PR23/PR29 and RaD supply\n+semantic precision, bulk routing and transfer. All earlier author, license\n+and AI disclosures in the preserved source and main remain in force." + }, + { + "sha": "58791689052f575743783a830ce7a2638968bd91", + "filename": "research/deferred-signed/README.md", + "status": "added", + "additions": 54, + "deletions": 0, + "changes": 54, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,54 @@\n+# Deferred endpoints and signed complex transfer\n+\n+This package integrates Swapnil Jain's pinned round7 bit network and round6\n+complex network with main's balanced semantic assembly, yielding the conditional\n+certificate **\u03ba=63965813/10^12 > 2^-14**. See [PROOF.md](PROOF.md) for the\n+complete changed-interface argument and inherited assumptions. This package\n+does not replace the repository's maintainer-reviewed release.\n+\n+New work by Zhihao Chen (jacklightChen), with Codex assistance, supplies explicit\n+reflected schedules, a commuting fan-order clarification, nonzero auxiliary\n+endpoint accounting, signed complex phase correction, and the enlarged semantic\n+and row-stock bridge. The original source and all author/license/AI disclosures\n+remain under `swapnil-round7/`; predecessor credit is detailed in the proof.\n+Future research using these specific additions should acknowledge Zhihao Chen.\n+Historical GPT-6 Astra assistance remains attributed to the earlier contributions;\n+no current runtime model or global-first claim is made.\n+\n+Swapnil's preserved source reports a slightly larger final value under its own\n+analytic stack. Our contribution is the explicit interface audit and integration\n+with the retained main assumptions, not a claim to surpass that reported value.\n+Previously explored local terminal-sharing/minimal-frame gains are not added\n+to this package without recompilation.\n+\n+From the repository root:\n+\n+```sh\n+make deferred-signed-verify\n+python3 research/deferred-signed/verify.py --replay-own\n+python3 research/deferred-signed/verify.py --replay\n+make verify\n+```\n+\n+The first command checks all source pins, the exact moments, saved finite\n+evidence and independently regenerates the complete assembly. `--replay-own`\n+reconstructs both literal ledgers and the exact tensor/signed controls;\n+`--replay` additionally runs the original finite bit geometry and staircase\n+checks. Replay uses temporary directories and leaves frozen evidence intact.\n+The rational tensor control requires SymPy; the other new drivers use the\n+standard library. CI installs the pinned dependency for replay.\n+\n+`validation-prior/` preserves the original executed audit sources and measured\n+native receipts. The portability checker permits only two documented path\n+substitutions; it does not silently treat different mathematical code as an\n+already-passed check. Machine elapsed times are excluded from regenerated\n+mathematical-output comparisons. The `new_multiplication_bound: false` fields\n+in these historical receipts accurately record their scope when run; the\n+conditional integration argument is supplied separately by this package.\n+\n+The common rational bit basis is established by nonvanishing polynomial\n+witnesses on a finite irreducible family, not by pretending sampled modular\n+pairs are an enumeration. Complex dirty restoration follows the exact h24\n+support identity and invertible commutator argument, with full small controls\n+and a full h24 physical event/frame ledger. There is no dense h24 coefficient\n+matrix replay and no claim that finite tests formalize the entire theorem." + }, + { + "sha": "3521d3c5cdba3a93b29cd7e9b2603caa37f4b705", + "filename": "research/deferred-signed/SOURCE.json", + "status": "added", + "additions": 144, + "deletions": 0, + "changes": 144, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FSOURCE.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FSOURCE.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2FSOURCE.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,144 @@\n+{\n+ \"base_main\": \"56b66d58297deca1d7dd130247d720e960f77a37\",\n+ \"foreign_head\": \"741e7aa078392553815df7926ee17ac5e25a8c38\",\n+ \"files\": {\n+ \".github/workflows/verify.yml\": \"f167d3877ffd324cc920b0373101fca29a72def7684de1824a40c627acf204ba\",\n+ \"Makefile\": \"d3da97587cfa850d826bbb450f13121ff46e4e87bc91681e669279557562494a\",\n+ \"README.md\": \"5fe2101e1bd639a1739e4986c807f3a659b463a8a5873126e11727e8e63298a1\",\n+ \"research/deferred-signed/PROOF.md\": \"cf5cced8cecace5f4308647523bc86a0869daeb1aa49c382bec03411674a1741\",\n+ \"research/deferred-signed/README.md\": \"b1d761d02a5bb3413f705c9fac321a96e9b42f4bfd949c175131af97316b7463\",\n+ \"research/deferred-signed/check_complex_identity.py\": \"8a31abe1d46ab3aa76b954cb87004e28d4974cce5eea2dea17d6283992902e7d\",\n+ \"research/deferred-signed/round6-complex-interface-controls.json\": \"7f4375ff2baefd6455d5353968d4c1a38666cda7f417ebd21286f09e16131d22\",\n+ \"research/deferred-signed/round6-complex-literal-ledger/result.json\": \"db1d41515236c2710b4caeb22d91eea63cf1deeb0d659346d0661da71ed07baa\",\n+ \"research/deferred-signed/round6_complex_interface_controls.py\": \"7ca3e245c7bdd814d6315f2b32ef5e0d4610834dd9e3190cc551a182c87bf5ed\",\n+ \"research/deferred-signed/round6_complex_literal_ledger.py\": \"a1384fb5283d9d11775942b91e31887fa05ddcd50c6a50fa3f11902b32f73c36\",\n+ \"research/deferred-signed/round7-balanced-assembly-candidate.json\": \"bcf0623dc4eab9fdb858f4375a5a183b72b150853e8da030005d8fcd0b83f2ae\",\n+ \"research/deferred-signed/round7-literal-ledger/result.json\": \"65343d92f68d0d7756bb4c5adbdcb43171b00ce7fa7398e951245cf2ab119c0f\",\n+ \"research/deferred-signed/round7-tensor-endpoint-controls.json\": \"8383f9afa241ad495941b3d724286f0d94e4c4adee71d8ea744d88d813acec4c\",\n+ \"research/deferred-signed/round7_balanced_assembly_candidate.py\": \"0e3b13922295c0ece6e6354d7ba93529b3c51e70ece15a20d089f65f134e33b7\",\n+ \"research/deferred-signed/round7_literal_frame_ledger.py\": \"02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59\",\n+ \"research/deferred-signed/round7_tensor_endpoint_controls.py\": \"f1487b01167ef37cd180a0d969c815bcf26e627f3c264b89ccd974b63478ae91\",\n+ \"research/deferred-signed/swapnil-round7/.gitignore\": \"e4142bca62926744f1a60693914db92bb41be0b9ea4fbd4dd73e3af2178b0c8b\",\n+ \"research/deferred-signed/swapnil-round7/IMPORT.json\": \"4b5f15981e846084b6def674ce0903c2d4ef0c930ea0c40093a2a8584164102d\",\n+ \"research/deferred-signed/swapnil-round7/LICENSE\": \"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4\",\n+ \"research/deferred-signed/swapnil-round7/Makefile\": \"42714be051b771e6ea414d3f7da4b9beb93990d5d6e1521dc665b3b2718a888a\",\n+ \"research/deferred-signed/swapnil-round7/NOTICE\": \"058a663112e633ab5349ce33b6119bacca2b9fd6c0a89918c4c0435d6dd7a008\",\n+ \"research/deferred-signed/swapnil-round7/README.md\": \"07409d6f8ca1becb0cf1f7bf7f485b879bfb53663c93becefc8f4e44de6f50b9\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/complex-source-frames.pdf\": \"f102b238e86a650190e2c94232fbafd3f50d30693151019a7d7b5b4addf620fd\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/copied-centres.pdf\": \"bbd2333d9049b8f42565e2b24d6faa5c69fcc4e67b873a7bef1f6e607e4979f4\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/data-edge-batching.pdf\": \"9f712eb870cfad37af333acefce5162754f85087afc9647e2d86b30a70ba5c03\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/deferred-readout.pdf\": \"ca659ffa1dccdb05ebbcb95c8ca6342704bcc98656a57be9a05aa71faafe0bdb\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/fine-field-lemma.pdf\": \"648168584f12381f1756156aea22a3fff108b94de36c62652b75558b81c0a118\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/flag-basis.pdf\": \"35cbcff404998f4e66c026e98c72f895bd8f8f2b90ba8d60b390af1d150b2cf7\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/partial-swap-batching.pdf\": \"2a76b1ce513c08d408a7524d825e922cc7a3939a772237d3a08f9683f2235289\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/round3-combination.pdf\": \"cc56ddcff426818b0fb096a47f837fceb98b928d31c428f6dccaca53aff4b3c7\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/segmented-inverse.pdf\": \"cb33411a0b9b552ec881b884498567997c10f9cb9d63cb7d5a864277ccebdfb0\",\n+ \"research/deferred-signed/swapnil-round7/artifacts/stack-notes.pdf\": \"3c1181d1e3b6a55d8092d39e37c7b0ef712d8ace0b76dc8f493578bef6006eae\",\n+ \"research/deferred-signed/swapnil-round7/certificates/external/pr24-bit-network.json\": \"f9ddc6c33dda1abdaf05d0fff651d02e9a04557ebbb1b8da11d4d6de8de08d91\",\n+ \"research/deferred-signed/swapnil-round7/certificates/identities.json\": \"76b35a0fdb1bf1926325bf33648dbae3e0de34699ce6dd1e95a23a09f762cd44\",\n+ \"research/deferred-signed/swapnil-round7/certificates/round7/deferred_23.json.gz\": \"8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c\",\n+ \"research/deferred-signed/swapnil-round7/certificates/round7/witness_23.json.gz\": \"b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588\",\n+ \"research/deferred-signed/swapnil-round7/certificates/witness.json\": \"ffb5ac42a64969dae7d19012e5102d7aeb66c3eee529bde9812bd182cb9eafa1\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/README.md\": \"b1e790d7a268716b62d19f1e6617b9f55f81bbfbd0c474a3a0801918b5ba6a7b\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/bc.py\": \"056ca643666dff4405eecfb6f0f8a33da3a50244c65d9bc2e28fa95ea32956e1\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_cert.py\": \"c4b0d8b9cdb7dceb881747826356fb6eedd5ad465c483ed7cda0ba2a8d2d90d4\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_hist.py\": \"dbfa0844ff605abfe386f30f3bf9859c3f1b040eae019e184668c82439d788d1\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/labels.py\": \"4edb0206c6f44081c1be434a529fce3527a46a35fee3e874a97898d60eabbe20\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/roles.py\": \"499e4f7ea700a917e7c3991b91ac99e1b0eb7eb51fb6d362b395d0056b64bdee\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/side.py\": \"90703356b485a21bbcf2f4dca9c1cc7109767a16afd2a04ac113b2c6e1d569ce\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_labels.py\": \"f1a2ff1e6aa68e3052d77d664744d85ac76c31f7b779bd66be018ee82ea0aec7\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_sim.py\": \"ef9c47f92ef46aa7f701493aab95d65f930d4d31db214bc83b683cf7ddb7868b\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_trace.py\": \"688e609cc0adbfba17dd74984d382121ce6741afc7e2da548ee553ea15c4d3c9\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-twostage/cert.py\": \"f9352729213b8441d076708b738d158093caa34d050fa2d838b61e07eb3a298b\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-twostage/frames.py\": \"8629850bd465250cdf298b47b86504f2ac507d5fa044f8c0d2a20b451d19aa0f\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-twostage/hist.py\": \"e20d077acfc95e2f8239fcdcc03146cc15607996e2734eb2d00b68ed7d43ec64\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-twostage/producer.py\": \"e1715616ac8cafa8f63b7c0a2e7deacdba7daea94662e0a84626d5374fd27b5c\",\n+ \"research/deferred-signed/swapnil-round7/independent/complex-twostage/run.py\": \"fff6190b4f197689aad55077be882e8c95e0b699d366eadee5882cf8ff08be44\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/check_frames.py\": \"1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/check_lifted.py\": \"c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/check_stair.py\": \"5b684020b394869d1b899dfffbdf1518de6b3b3562c0f5a2a81a2f43ced42d40\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/check_word.py\": \"c31a321e28556c9d9cb3397e48292e8ecefc0b08e233243d7849bd585213af65\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/deferred.py\": \"e92ac1db9fce8608cf5302336f05750fa327eda99f7170ed32e7323220ffc164\",\n+ \"research/deferred-signed/swapnil-round7/independent/deferred-readout/linalg.py\": \"56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b\",\n+ \"research/deferred-signed/swapnil-round7/independent/partial-swap/README.md\": \"8f9bb3c2e7037e5c601b740e195cc5207bf3eec906fdea9c6f4ee73a7ca98da0\",\n+ \"research/deferred-signed/swapnil-round7/independent/partial-swap/factor.py\": \"a246d8d4b4d110125406648f9fb49725894c3652102049caf3555ab191fc0e7b\",\n+ \"research/deferred-signed/swapnil-round7/independent/partial-swap/frames.py\": \"6931781fc7097daf44327de262ef9df68d95f3ebab3b2a6c22422066c1e7ea1a\",\n+ \"research/deferred-signed/swapnil-round7/independent/partial-swap/moment.py\": \"a1c5fa749b41d483dafb66d7ba56d2e77a8735befbbcac8391b8e1d8ce1ee2d3\",\n+ \"research/deferred-signed/swapnil-round7/independent/partial-swap/test_factor.py\": \"0c1da25c545e1e7cdd6eca5140579a6b6273789de39171487624c7ff6490dec6\",\n+ \"research/deferred-signed/swapnil-round7/independent/pr7-role-counts/README.md\": \"ef301c65851d91dc7ea0e920b33de4d36ee1249f768a504c8e5b3a29dd4abf7c\",\n+ \"research/deferred-signed/swapnil-round7/independent/pr7-role-counts/complexside.py\": \"6ae9a08122efbad803b375dd5696485c6911ff799111dcf09811fd88bcc71539\",\n+ \"research/deferred-signed/swapnil-round7/independent/pr7-role-counts/export.py\": \"de3fb97184ac8a9a654190023913b1eb2158a8ff70bb069ec8353092e6483de9\",\n+ \"research/deferred-signed/swapnil-round7/independent/pr7-role-counts/global.cpp\": \"7312be680d8026b5b9730a7e531f7a2cc6a7d445a65d14bb18ec4e3c2f393f1a\",\n+ \"research/deferred-signed/swapnil-round7/independent/pr7-role-counts/local.py\": \"75362c04f5fd538dc8491b913d89cba7d9c30933b9e475372e75a79ce56353bd\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/bruhat8.py\": \"e703992629634ff50337828d6fc1ec23daf2bc1e5f742adb62878fe3a5a85951\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/cert_rt.py\": \"b15adc5aa1ea5761fb7dd5873c4dd44d28f15705c6ab2b1df87d3bd4b69e9a77\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkgm.py\": \"73281a2fe6506cf17934497a476e2fff97bf994b1b950e0f735b3dfd6510916b\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkside.py\": \"92465c6b1fb5f4830d56af1d54222f917cab8cbfd67b1eb4e707dc0d8c5076a8\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/corners.py\": \"f4c5d20e62967a2a7484bea59f44366daa82ca4c169691e9003e7fee76273c2b\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/flag_existence.py\": \"aa4205b2c59bb50faaff2f01bac8fb9b62dbb855638ea8cde678f801de30ad08\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/flagbasis.py\": \"b3b6df4f3d024aba1de9b54903a41e4163feb397f0e412d3c9c60f7558204b5d\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/gmside.py\": \"a8cda0c24718980bd02b7983d340b0b97ce91f2241b81ef4127042ba81932847\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/moment.py\": \"4ca6b15fa6cf799b7252d9a70d5c66dcbe86f3cc16b03b7c6f03ccda66df41be\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/orders.py\": \"ff0f0515eda0f4dc995d07436e65663c553bfa01748fa2eeec96dcee8d0a34c3\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/rtgm.py\": \"1cdb902014b3c9d2a72deda999905dd04fbd555f7813d4664ca0e16355b42fdc\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/side_chains.py\": \"98c8b33d5761a6135238983a05b81a4250c0a9f02979096ae110d1104c77970d\",\n+ \"research/deferred-signed/swapnil-round7/independent/two-stage-bit/sidegen.py\": \"e97ec987bd20d86e73c92f940f2ba2650f39209db14dc5f00b88436481fa4e28\",\n+ \"research/deferred-signed/swapnil-round7/lean/Round5.lean\": \"bb45184861572975a9d9f9d3f515c9897794a30fdab4efd81b074da16629ac56\",\n+ \"research/deferred-signed/swapnil-round7/lean/Round6.lean\": \"27a4b348551cb8cce209864c08096230dba5e9f4ab04e469fcfedb61bca9b78a\",\n+ \"research/deferred-signed/swapnil-round7/lean/Round7.lean\": \"fc897ba78f0b4e429104bef7e15d728c9095f1b948f9e51b76252a368819631d\",\n+ \"research/deferred-signed/swapnil-round7/lean/dump.py\": \"5cd0ec7494bbe5441c44ab6b9f2155172e1e9a75852ecdcd7aef0ebc5a36d11f\",\n+ \"research/deferred-signed/swapnil-round7/lean/dump6.py\": \"f32e6de60a389803f2226b2229944404ea9e09a9291f83c8eefae54b2dc158f2\",\n+ \"research/deferred-signed/swapnil-round7/lean/dump7.py\": \"068cfb9e4139ddbcff8d3b987b92415ed0ddee20e5a4ccdf2fed5c116d52834e\",\n+ \"research/deferred-signed/swapnil-round7/lean/gen.py\": \"e4c7051a4051989bb659553884773d06dd3f09e34ba2710ad5142b702294cfc4\",\n+ \"research/deferred-signed/swapnil-round7/lean/round5-histograms.json\": \"88e0befd88833b9c67f84a2cfcb47f07101c95a2aa4d72b8a72df837cb954168\",\n+ \"research/deferred-signed/swapnil-round7/lean/round6-histograms.json\": \"e1d955df15523fd0f83c82e2a4bc080bf378ee50deb3003fce4771ac30f4ed26\",\n+ \"research/deferred-signed/swapnil-round7/lean/round7-histograms.json\": \"8fd0abe6c230980b9a0c4a175e06ca1808b0fe5ead0cf9f268496111c2e11d2c\",\n+ \"research/deferred-signed/swapnil-round7/notes/complex-source-frames.tex\": \"942a4369dd843736732a5ec27a1616e3ae1c2f2f8cc00b67e4a88759548a15e0\",\n+ \"research/deferred-signed/swapnil-round7/notes/copied-centres.tex\": \"7b7fe97b021e00bfb2139d15e41be9ba8579803884ac2082c2b7f6ab53879aba\",\n+ \"research/deferred-signed/swapnil-round7/notes/data-edge-batching.tex\": \"31e7ef597a439945fd74fcfb0d8fc8fdc01d0baa7d00f69caf9aab66c7c93dc5\",\n+ \"research/deferred-signed/swapnil-round7/notes/deferred-readout.tex\": \"953963b0a986bed4ac7c5c8d0ec0cd593f6525691bec9ea55a058d60669ec411\",\n+ \"research/deferred-signed/swapnil-round7/notes/fine-field-lemma.tex\": \"838204a16fff7dc4bc575107a5745ba28d93f4928b7e1a9100ba2c12f7b63b8d\",\n+ \"research/deferred-signed/swapnil-round7/notes/flag-basis.tex\": \"0f00ee0558ca661e4a793322e6336d9a6189f7d8e1be4e90be6232bb9327d59f\",\n+ \"research/deferred-signed/swapnil-round7/notes/partial-swap-batching.tex\": \"f82e5ff671a7532308c0b4e5424f76a80653e0d170779b27c9e72b3c8311de21\",\n+ \"research/deferred-signed/swapnil-round7/notes/round3-combination.tex\": \"1f3eab33880c137591b6f984aa3220ca8fbc1e833a91c2aeea430f3c62580b74\",\n+ \"research/deferred-signed/swapnil-round7/notes/segmented-inverse.tex\": \"cce6dcb88dc507c679691786909251cf79f681c673716c89524a15dbc1e97436\",\n+ \"research/deferred-signed/swapnil-round7/notes/stack-notes.tex\": \"0f7725b97b6c85adc6fc38045703ca39b52ddfa9e76d14e446dbe948c47faae8\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate.py\": \"dbce6f0d3cc3cbd076686f2adf4a592fac8850abc0fd718a0933694770e9167c\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate_round3.py\": \"53deb36c0f5daffc68ee02dabf189d2700f39a2bb3f01b55c663c49cd315b9ae\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate_round4.py\": \"a6113295a7af30b581d1230e630bba3dc7759be7807d8b2628aeaca31cddf441\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate_round5.py\": \"6c948d995fdc60df70a36f1fe658b9dd06960fafd48badfce2144fc764a3d2b9\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate_round6.py\": \"f1d65865357b535ddd4d98b0f3bfc1947b9a434993e7c5ba1536d3a62439948f\",\n+ \"research/deferred-signed/swapnil-round7/scripts/certificate_round7.py\": \"6f858bb8b601967e45f73eafe698cf8c5f0417182a8b1c1541c1e96b7a0f5107\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_fine_field.py\": \"93710f045ab8e8c0d4881380368405214484759e63f9f933a5c5c0f85871bd4c\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_gs_path.py\": \"9f39eeda5fed8920fffaa3309df3531e1ff3a30c3b8659745ab583012e0669ec\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_identities.py\": \"27a91fe1fab8a0171ec59edf697c0e41fd5747792a0385e2e9f3b38beaa5b91a\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_reuse_inverse.py\": \"f038a6cb823711434620412753b885962613c377cf1d0568ff6f20be09edf8d9\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_segmented_inverse.py\": \"0fe5d5597c9925921979d22654ec60d45049178e423f1a54fdd63e3fe5853da3\",\n+ \"research/deferred-signed/swapnil-round7/scripts/check_subblock_inverse.py\": \"49fb7c2bd29bd714929e4397ea9e11a0b5e258be8ef665e33d573faded600479\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_round3.py\": \"7d9af1fb8b48c4eae029e2b37daf460c8cb727308ed840b0197f40593b618886\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_round4.py\": \"b21bc2654452b04f8404670c42adc9fcd8e46ede578b5cb0aa88c7243a89ad20\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_round5.py\": \"cd0c77f9e6af31fa8a6c4efe27cfca200183322cf9128e4c6ed1d675cd0c52c4\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_round6.py\": \"58bd299b361c8119c2ffa1381582346ef8f1a0cf448d847c19ec9bdbe19f78c3\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_round7.py\": \"c0e988d363f9d989275693b340e97b59dc16e4d8835e1e9ea3d4c589da277a0f\",\n+ \"research/deferred-signed/swapnil-round7/tests/test_witness.py\": \"8cc1b358bd92a31d454c7dc9a2739d1d9cb53f19e3f88035aa4cd6babf11cb77\",\n+ \"research/deferred-signed/validation-prior/complex-prior-replay.json\": \"04201d7df9fe95f10859d482a2386b65fdcba5f8d7347e7837866de88ff75de4\",\n+ \"research/deferred-signed/validation-prior/frames-replay.log\": \"3895170eb8078f6d7c9f0d814f54cc24b01309abcbe183a361d101e634a99998\",\n+ \"research/deferred-signed/validation-prior/lifted-replay.log\": \"e24e6b3e793f49808dc14c36799a11140938d6fb53ba7bdce92a99f89b277671\",\n+ \"research/deferred-signed/validation-prior/round6_complex_interface_controls.py\": \"7ca3e245c7bdd814d6315f2b32ef5e0d4610834dd9e3190cc551a182c87bf5ed\",\n+ \"research/deferred-signed/validation-prior/round6_complex_literal_ledger.py\": \"b973d467d949912edc1cf65ee22703f9692431de72e3d87d82f442a6f7a61a1c\",\n+ \"research/deferred-signed/validation-prior/round7_balanced_assembly_candidate.py\": \"e10abe35cc8b536d78eda3e234ef48a6a7e49019893ec3d920779f2ac66443fd\",\n+ \"research/deferred-signed/validation-prior/round7_literal_frame_ledger.py\": \"02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59\",\n+ \"research/deferred-signed/validation-prior/round7_tensor_endpoint_controls.py\": \"f1487b01167ef37cd180a0d969c815bcf26e627f3c264b89ccd974b63478ae91\",\n+ \"research/deferred-signed/validation-prior/stair-replay.log\": \"8a7cad5cb0ff905203c46da45642224d178cfd8c9d7d97a1502f1195705f0231\",\n+ \"research/deferred-signed/validation-prior/stair_control-replay.log\": \"82bf3dda4e3f5ec4e3ca796a5544364e2864a28a877642773132e902da4755d6\",\n+ \"research/deferred-signed/validation-prior/swapnil-round7-full-basis.json\": \"1bcd74316f11ebc2c36f0c9b5638f314a3982c97e96c572816602087169f0e42\",\n+ \"research/deferred-signed/validation-prior/swapnil-round7-moment-audit.json\": \"92567c2050caeaf987358acee5dde5d8610e0f12bff6385899e3c043d6cefb89\",\n+ \"research/deferred-signed/validation-prior/swapnil-round7-validation-job.json\": \"bb9488bd2c19423e4ccff4cd8e5052f0848a5b107a133a31179c020d26a7465e\",\n+ \"research/deferred-signed/verify.py\": \"cebcddbdfc553c37da7ab6b66b7e94c1dcd0610b82e79453ed937831c400c418\",\n+ \"scripts/structured_bulk_assembly.py\": \"e99467e14211fba699878ed036e1e2362eb8e395dc22f9ecdcecc7fbf2cc736d\",\n+ \"research/deferred-signed/VALIDATION.json\": \"c267be2b45769619b1fcb078b5aaa40f24ce1f0345161d180f138d297cd19264\",\n+ \"research/joint-dual/SOURCE.json\": \"0f2bc2e6d72534ab3884d050abdc328b112cbc4296e6cc04516f65ab87ee96b2\",\n+ \"certificates/joint-dual-kappa.json\": \"6dff7f3bd3bf149714e9f161892c944d8788d0894ff0c4056610a3283368253e\",\n+ \"certificates/joint-dual-validation.json\": \"9af3bb95c2dacb7ffb410936f284ca5b0c288fc8ce492a97b349161dfc978113\"\n+ }\n+}" + }, + { + "sha": "a221c78912e406d2535f5a9ceee58f94999c7eb8", + "filename": "research/deferred-signed/VALIDATION.json", + "status": "added", + "additions": 699, + "deletions": 0, + "changes": 699, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FVALIDATION.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2FVALIDATION.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2FVALIDATION.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,699 @@\n+{\n+ \"status\": \"Passed all required make verify coverage in staged continuations\",\n+ \"monolithic_make_verify_exit_success\": false,\n+ \"base_main\": \"56b66d58297deca1d7dd130247d720e960f77a37\",\n+ \"focused\": \"verify.py --replay-own passed both literal ledgers, tensor/signed controls, complex support identity, moments and assembly\",\n+ \"first_run\": {\n+ \"started_at\": \"2026-10-08T21:55:01.370957+00:00\",\n+ \"finished_at\": \"2026-10-08T22:14:28.470679+00:00\",\n+ \"elapsed\": 1167.1125114160823,\n+ \"exit\": 2,\n+ \"stop\": \"Apple clang rejected -fopenmp in skip-suffix producer after both axis reconstructions passed\"\n+ },\n+ \"compiler_recovery\": {\n+ \"scope\": \"Exact unexecuted producer suffix after already-passed axis checks; source unchanged.\",\n+ \"source_sha256\": \"7b71554b1bb1a375c072196152979e91545f6eecf6516dfbf214b978762e37f4\",\n+ \"original_log_sha256\": \"ea3526f143fe24ab7228433efc9b91dc2692b85324d65d7447efd66fbc27c8fe\",\n+ \"resumed_first_source_line\": 186,\n+ \"CXX\": \"/usr/local/bin/g++-14\",\n+ \"receipt\": {\n+ \"data_corners\": {\n+ \"pairs\": 4073300,\n+ \"good\": 4073290,\n+ \"fallback\": 10,\n+ \"nonzero_pivots\": 191444880\n+ },\n+ \"exact_recovery\": [\n+ {\n+ \"pair\": [\n+ 0,\n+ 9,\n+ 10,\n+ 14,\n+ 18,\n+ 20\n+ ],\n+ \"primary_failed_row\": 26,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"1257473477600655419/1257360043121049600\",\n+ \"697637898272342204364754225328501/898378192091765621530873036800\",\n+ \"4862910615710407729752452/413821272486424062729765\",\n+ \"-211879701118736765516260639861416/69965631010509871166615364966895\",\n+ \"-1040817578056012397961768075264/140132077459481987775304655993\",\n+ \"348004811934793728/2909385858910392337\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 0,\n+ 11,\n+ 12,\n+ 6,\n+ 8,\n+ 10\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-30425585565647987/8112000278200320\",\n+ \"-6915016711890063397419754697651/61258776880172525541811814400\",\n+ \"58034460589224410256212/377247763587426343740975\",\n+ \"-24460859725227921591208225587816/99865714290552512474992173653\",\n+ \"-5616114623039263977852817637376/566223604750646333129820036755\",\n+ \"4872067367087112192/31397326122812625191\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 0,\n+ 15,\n+ 18,\n+ 6,\n+ 13,\n+ 18\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"4563332038527041/1849058886942720\",\n+ \"1030267061084400635268816075773/88677071305420843701963325440\",\n+ \"141023493761411438700418729418/901812840135500013365092325\",\n+ \"-21321669502882733419935472733424/4583263547245871757763608706085\",\n+ \"-1116902841526537767162419871744/148067149325574537638440782871\",\n+ \"11941341585997824/76521229264169315\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 1,\n+ 15,\n+ 17,\n+ 12,\n+ 13,\n+ 18\n+ ],\n+ \"primary_failed_row\": 24,\n+ \"pivots\": [\n+ \"-1\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"180266839724041558033/214729419128832000\",\n+ \"7610766866275211859845587710009457/91225004199975729599379229900800\",\n+ \"180511342085017711541659444495092/17320816718878497632784678447905\",\n+ \"-131823672742917787774579438372/47037560476604573572456599045\",\n+ \"-1951065151249491660685757644800/1351192645614907324689439243313\",\n+ \"37649224820588544/320811225178453325\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-7488/1315\",\n+ \"-156/25\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 2,\n+ 11,\n+ 18,\n+ 4,\n+ 7,\n+ 22\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"29673673201714633/298235304345600\",\n+ \"-23913591558588697625337951705601/720793055432462852241122918400\",\n+ \"127561257323707299126849029250724/9197535214841806778976135271385\",\n+ \"-13319307909562049233127667637376/2453101102378986521670173639437\",\n+ \"23943650449470601604575002624/40021958862866734474542270545\",\n+ \"-25847059709952/194420976488309\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"7098/425\",\n+ \"144/35\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 4,\n+ 7,\n+ 22,\n+ 6,\n+ 11,\n+ 18\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"4563332038527041/1849058886942720\",\n+ \"1030267061084400635268816075773/88677071305420843701963325440\",\n+ \"141023493761411438700418729418/901812840135500013365092325\",\n+ \"-21321669502882733419935472733424/4583263547245871757763608706085\",\n+ \"-1116902841526537767162419871744/148067149325574537638440782871\",\n+ \"11941341585997824/76521229264169315\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 4,\n+ 11,\n+ 20,\n+ 2,\n+ 17,\n+ 20\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"29673673201714633/298235304345600\",\n+ \"-23913591558588697625337951705601/720793055432462852241122918400\",\n+ \"127561257323707299126849029250724/9197535214841806778976135271385\",\n+ \"-13319307909562049233127667637376/2453101102378986521670173639437\",\n+ \"23943650449470601604575002624/40021958862866734474542270545\",\n+ \"-25847059709952/194420976488309\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"7098/425\",\n+ \"144/35\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 5,\n+ 7,\n+ 21,\n+ 6,\n+ 11,\n+ 12\n+ ],\n+ \"primary_failed_row\": 24,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"180266839724041558033/214729419128832000\",\n+ \"7610766866275211859845587710009457/91225004199975729599379229900800\",\n+ \"180511342085017711541659444495092/17320816718878497632784678447905\",\n+ \"-131823672742917787774579438372/47037560476604573572456599045\",\n+ \"-1951065151249491660685757644800/1351192645614907324689439243313\",\n+ \"37649224820588544/320811225178453325\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-7488/1315\",\n+ \"-156/25\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 10,\n+ 11,\n+ 22,\n+ 14,\n+ 16,\n+ 18\n+ ],\n+ \"primary_failed_row\": 25,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-30425585565647987/8112000278200320\",\n+ \"-6915016711890063397419754697651/61258776880172525541811814400\",\n+ \"58034460589224410256212/377247763587426343740975\",\n+ \"-24460859725227921591208225587816/99865714290552512474992173653\",\n+ \"-5616114623039263977852817637376/566223604750646333129820036755\",\n+ \"4872067367087112192/31397326122812625191\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ },\n+ {\n+ \"pair\": [\n+ 12,\n+ 13,\n+ 22,\n+ 4,\n+ 6,\n+ 10\n+ ],\n+ \"primary_failed_row\": 26,\n+ \"pivots\": [\n+ \"-1\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"18/31\",\n+ \"18/31\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"-24/5\",\n+ \"1257473477600655419/1257360043121049600\",\n+ \"697637898272342204364754225328501/898378192091765621530873036800\",\n+ \"4862910615710407729752452/413821272486424062729765\",\n+ \"-211879701118736765516260639861416/69965631010509871166615364966895\",\n+ \"-1040817578056012397961768075264/140132077459481987775304655993\",\n+ \"348004811934793728/2909385858910392337\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"39/68\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-26/5\",\n+ \"-68016/1925\",\n+ \"936/545\"\n+ ],\n+ \"ordered_zero_checks\": 346\n+ }\n+ ]\n+ }\n+ },\n+ \"second_run\": {\n+ \"started_at\": \"2026-10-08T22:16:45.151686+00:00\",\n+ \"finished_at\": \"2026-10-08T22:23:00.045528+00:00\",\n+ \"elapsed\": 374.8928947080858,\n+ \"exit\": 2,\n+ \"completed\": [\n+ \"skip-suffix producer tail\",\n+ \"skip-suffix-check\",\n+ \"verify-clones\",\n+ \"verify-positive\",\n+ \"skip-frame-verify\"\n+ ],\n+ \"stop\": \"joint-dual source check detected changed root Makefile and README pins; native pin script refreshed exactly these two entries\"\n+ },\n+ \"final_run\": {\n+ \"started_at\": \"2026-10-08T22:25:08.438718+00:00\",\n+ \"finished_at\": \"2026-10-08T22:34:00.594564+00:00\",\n+ \"elapsed\": 532.1481093750335,\n+ \"commands\": [\n+ [\n+ \"make\",\n+ \"joint-dual-verify\"\n+ ],\n+ [\n+ \"python3\",\n+ \"scripts/audit_joint_candidate.py\",\n+ \"--check\",\n+ \"docs/research/community-round2-arithmetic.json\"\n+ ],\n+ [\n+ \"make\",\n+ \"verify-pair\",\n+ \"deferred-signed-verify\",\n+ \"verify-tests\"\n+ ]\n+ ],\n+ \"all_exit_zero\": true\n+ },\n+ \"inherited_changes_only\": {\n+ \"research/joint-dual/SOURCE.json\": [\n+ \"Makefile\",\n+ \"README.md\"\n+ ],\n+ \"certificates/joint-dual-kappa.json\": [\n+ \"source_manifest_sha256\"\n+ ],\n+ \"certificates/joint-dual-validation.json\": [\n+ \"certificate_sha256\"\n+ ]\n+ },\n+ \"log_sha256\": {\n+ \"submission-regression.log\": \"ea3526f143fe24ab7228433efc9b91dc2692b85324d65d7447efd66fbc27c8fe\",\n+ \"submission-regression-resume.log\": \"e79a96b8a35f74b0cca7252b58b099227b317c6ff48f08748b96af933a4e9240\",\n+ \"submission-regression-final.log\": \"352cf4cd9f5ff1f4b8e4242636c9ac9cb32677719270c9cfa25a612c95b5ae5f\",\n+ \"submission-focused.log\": \"3ae6ef97fa283745f28e3532a7b641677fa30d29967a9ced64c6843d1a0286e9\"\n+ },\n+ \"total_regression_seconds\": 2074.1535154992016,\n+ \"reproduce\": \"make verify; OpenMP-capable CXX is required by inherited skip-suffix producer. On this macOS host CXX=/usr/local/bin/g++-14 was used for that unchanged producer tail.\",\n+ \"scope\": \"Finite conditional checks and inherited regression coverage; not formal verification of the complete multiplication theorem.\"\n+}" + }, + { + "sha": "833fbded74951c775043573f19f5288e8f7c2de3", + "filename": "research/deferred-signed/check_complex_identity.py", + "status": "added", + "additions": 35, + "deletions": 0, + "changes": 35, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fcheck_complex_identity.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fcheck_complex_identity.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fcheck_complex_identity.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,35 @@\n+#!/usr/bin/env python3\n+\"\"\"Exact h24 AMV=I and retained-total support identity, on every coefficient.\n+Zhihao Chen / Codex; repeats the preserved earlier check without path coupling.\n+\"\"\"\n+import sys\n+from pathlib import Path\n+from collections import defaultdict\n+HERE=Path(__file__).resolve().parent\n+sys.path.insert(0,str(HERE/'swapnil-round7/independent/complex-twostage'))\n+from producer import NStar3\n+def main():\n+ assert __debug__\n+ c=NStar3(24);v=len(c.triples);packed={}\n+ for n in sorted(c.active):\n+ if c.args[n]:\n+ a,b=c.args[n];assert not c.sup[a]&c.sup[b]\n+ assert c.sup[n]==c.sup[a]|c.sup[b];packed[n]=packed[a]+packed[b]\n+ else:packed[n]=1<<(8*(n-1))\n+ terms=defaultdict(list)\n+ for T,n,cf in c.pieces:terms[T].append((n,cf))\n+ totals=dict(c.retained);star=packed[totals[('*',)]]\n+ assert c.sup[totals[('*',)]]==(1<>i&1 and q>>j&1)\n+ def parity(a):return a.bit_count()&1\n+ def tq(z):return sum(q<<(i*h) for i in range(h) if parity((z>>(i*h))&q))\n+ def pi(z):\n+ col=0\n+ for j in range(h):\n+ if parity(sum(((z>>(i*h+j))&1)<>i&1)\n+ bad_no_inverse=bad_no_wrapper=0\n+ # Fourth roots represented exactly as Gaussian integer pairs.\n+ units=((1,0),(0,1),(-1,0),(0,-1))\n+ def mul(a,b):return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0])\n+ add=lambda a,b:(a[0]+b[0],a[1]+b[1])\n+ neg=lambda a:(-a[0],-a[1])\n+ for z in range(1<=v and t<2*v and d==2);del omitted[idx]\n+ assert not replay(v,k['size'],omitted)[0]\n+ rows.append(dict(h=h,roles=k['size'],formal_basis=2*v+k['size'],events=len(ops),forward=True,inverse_opposite=True,coefficient_bound=max(ba,bb),negative_controls=2))\n+ out=dict(rows=rows,phase=phases(),elapsed=time.monotonic()-st,limit_seconds=120,\n+ scope='Complete exact dyadic small scalar words and all-address tensor phase controls. General commutator/phase argument in report. No h24 physical trace, precision/tape or final assembly certification.',new_multiplication_bound=False)\n+ (HERE/'round6-complex-interface-controls.json').write_text(json.dumps(out,indent=2)+'\\n');print(json.dumps(out,indent=2));signal.alarm(0)\n+if __name__=='__main__':main()" + }, + { + "sha": "9f1b5b3e3a4daa1f42ae29af073fc07661880095", + "filename": "research/deferred-signed/round6_complex_literal_ledger.py", + "status": "added", + "additions": 129, + "deletions": 0, + "changes": 129, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fround6_complex_literal_ledger.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fround6_complex_literal_ledger.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fround6_complex_literal_ledger.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,129 @@\n+#!/usr/bin/env python3\n+\"\"\"Actual h24 signed events, copied centers, reflected frames and paid ranks.\n+Zhihao Chen / Codex audit of Swapnil Jain's Apache-2.0 pinned round6 producer.\n+Frame labels are binary subspaces; complex phases use the separately proved\n+q_U and inverse-rank-one endpoint identities, not XOR cancellation.\n+\"\"\"\n+import sys,json,time,signal,gzip,hashlib\n+from pathlib import Path\n+from collections import Counter\n+from array import array\n+HERE=Path(__file__).resolve().parent\n+sys.path.insert(0,str(HERE/'swapnil-round7/independent/complex-twostage'))\n+from producer import NStar3,compile_roles\n+from frames import Checker,echelon,perp_in,ok_res\n+\n+def main():\n+ st=time.monotonic()\n+ def stop(*_):raise TimeoutError('180s event ledger limit')\n+ signal.signal(signal.SIGALRM,stop);signal.alarm(180)\n+ h=24;c=NStar3(h);k=compile_roles(c);ch=Checker(c)\n+ v=len(c.triples);R=k['size'];size=2*v+R;off=2*v;m=h*h\n+ bases=[];ids={};dims=[]\n+ def key(b):\n+ b=tuple(sorted(echelon(b).values()))\n+ if b not in ids:ids[b]=len(bases);bases.append(b);dims.append(len(b))\n+ return ids[b]\n+ zero=key([]);F=key([1<0\n+ events.extend((0,reg,old,f,r));H['aux' if reg>=off else 'data'][r]+=1;cur[reg]=f\n+ def add(t,s,n=1,d=1):\n+ assert cur[t]==cur[s];events.extend((1,t,s,n,d))\n+ def mix(mode,inverse=False):\n+ for n,ins,outs in reversed(k['gates']) if inverse else k['gates']:\n+ f=zero if mode=='low' else F if mode=='high' else nk[n]\n+ for q in sorted(set(ins+outs)):move(off+q,f)\n+ if inverse:\n+ for q in reversed(outs[1:]):add(off+q,off+outs[0],-1)\n+ if len(ins)==2:add(off+ins[0],off+ins[1],-1)\n+ else:\n+ if len(ins)==2:add(off+ins[0],off+ins[1])\n+ for q in outs[1:]:add(off+q,off+outs[0])\n+ def inject(sign,high):\n+ for i,(T,n,cf) in enumerate(c.pieces):\n+ t=c.tid[T];s=off+k['pout'][i];f=hyper[t] if high else zero\n+ move(s,f);move(v+t,f);add(v+t,s,sign*cf,2)\n+ terms={name:[] for name in k['rout']}\n+ for j,T in enumerate(c.triples):\n+ if h-1 not in T:\n+ terms[('*',)].append((v+j,2));selected=T;sg=-1\n+ else:\n+ terms[('*',)].append((v+j,5-h));selected=[i for i in range(h-1) if i not in T];sg=1\n+ for i in selected:terms[('E',i)].append((v+j,sg))\n+ def center(sign,copied=False):\n+ for name,sl in k['rout'].items():\n+ reg=off+sl\n+ for t,n in terms[name]:assert cur[t]==zero\n+ if copied:\n+ # Fresh copy retains its source frame and is moved to zero;\n+ # original arbitrary-dirty role remains at its live frame.\n+ f=cur[reg];assert ok_res(list(bases[f]));r=dims[f]\n+ copies.append(dict(source=reg,frame=f,target_frame=zero,terms=terms[name]))\n+ events.extend((2,reg,f,len(copies)-1,r));H['center'][r]+=1\n+ else:\n+ move(reg,zero)\n+ for t,n in terms[name]:add(t,reg,sign*n,2)\n+ def source(sign,high):\n+ for T,sl in k['src'].items():\n+ t=c.tid[T];f=F if high else line[t]\n+ move(off+sl,f);move(t,f);add(off+sl,t,sign)\n+ mix('low');center(-1);inject(-1,False);mix('low',True)\n+ source(1,False);mix('label');center(1,True);inject(1,True)\n+ mix('high',True);source(-1,True)\n+ for s in range(R):move(off+s,F)\n+ assert cur[:v]==[F]*v and cur[v:off]==hyper and cur[off:]==[F]*R\n+ assert sum(r*n for r,n in H['aux'].items())==R*h\n+ assert sum(r*n for r,n in H['data'].items())==2*v*(h-1)\n+ assert sum(r*n for r,n in H['center'].items())==(h-1)**2+h\n+ # Explicit time-reversed signed word with complement labels and bank swap.\n+ bank=lambda s:s+v if s=s+E\n+ bit=json.loads((HERE/'round7-literal-ledger/result.json').read_text());bh={int(t):n for t,n in bit['histogram'].items()}\n+ bm=529;bW=108516254;br=max(bh)\n+ db,dc=halving(bm,br),halving(m,r);co=bW.bit_length()*db+W.bit_length()*dc\n+ degree=1000*((co*51)//25000+1)\n+ bridge=dict(bit=dict(m=bm,W=bW,maxchild=br,halving_degree=db),complex=dict(m=m,W=W,s=s,maxchild=r,halving_degree=dc),\n+ semantic=dict(E=E,literal_charge=charge,strict_literal_gap=E-charge,B=B,C0=C0,C1=1),rows=dict(coefficient=co,degree=degree,degree_gap=Q(degree)-Q(co*51,25)))\n+ ab=Q(31987,500000000);ac=Q(36926111,500000000000);eta=Q(1,10**8)\n+ q=ab*(1-2*eta);cc=q*(1+eta);eps=(1-eta)/(1+cc+q)\n+ upper=eps*q;kap=Q((upper*10**12).__floor__(),10**12)\n+ cert=assembly(ab,ac,bridge,kap,eta=eta,beta=Q(1,10));assert kap>Q(1,16384)\n+ rejected=False\n+ try:assembly(ab,ac,bridge,kap+Q(1,10**12),eta=eta,beta=Q(1,10))\n+ except AssertionError:rejected=True\n+ assert rejected\n+ out=dict(candidate_kappa=kap,dyadic_gap=kap-Q(1,16384),literal_word_events=word,scalar_group_bound=G,\n+ scalar_coefficient_max=Q(19,2),bridge=bridge,assembly=cert,next_grid_rejected=rejected,\n+ strict_constraint_count=len(cert['strict_constraints']),margin_count=len(cert['margins']),\n+ source_assembly_sha256=hashlib.sha256((HERE.parents[1]/'scripts/structured_bulk_assembly.py').read_bytes()).hexdigest(),\n+ status='Arithmetic candidate only. New complex literal/phase checks, full h24 physical accounting, finite bridge applicability and inherited analytic/tape conditions require integration proof before a multiplication claim.',new_multiplication_bound=False)\n+ (HERE/'round7-balanced-assembly-candidate.json').write_text(json.dumps(js(out),indent=2)+'\\n')\n+ print(json.dumps(js({k:out[k] for k in ['candidate_kappa','dyadic_gap','literal_word_events','scalar_group_bound','strict_constraint_count','margin_count','next_grid_rejected','new_multiplication_bound']}),indent=2))\n+if __name__=='__main__':main()" + }, + { + "sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "filename": "research/deferred-signed/round7_literal_frame_ledger.py", + "status": "added", + "additions": 166, + "deletions": 0, + "changes": 166, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fround7_literal_frame_ledger.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fround7_literal_frame_ledger.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fround7_literal_frame_ledger.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,166 @@\n+#!/usr/bin/env python3\n+\"\"\"Explicit forward and reflected frame/event ledger of pinned round-seven.\n+Zhihao Chen / Codex audit. Exact nesting of the supplied chains is inherited\n+from the separately run frame/lifted checkers, not inferred from ranks here.\n+Copied-center moves are temporary macros, not erased arbitrary scratch.\n+\"\"\"\n+import sys,json,signal,time,hashlib,gzip\n+from pathlib import Path\n+from collections import defaultdict,Counter\n+from array import array\n+HERE=Path(__file__).resolve().parent;ROOT=HERE/'swapnil-round7'\n+sys.path.insert(0,str(ROOT/'independent/deferred-readout'))\n+import deferred as dr\n+\n+def main():\n+ started=time.monotonic()\n+ def stop(*_):raise TimeoutError('180 second literal ledger limit')\n+ signal.signal(signal.SIGALRM,stop);signal.alarm(180)\n+ W,D=dr.load(23);S=dr.Schedule(W,D);v,R,h=S.v,S.R,S.h;size=2*v+R\n+ co=S.adjoint();sel=S.sel;ops=S.ops;prev={};pred=defaultdict(list);last={}\n+ for i,op in enumerate(ops):\n+ for s in S.touch(op):\n+ if s in prev:pred[i].append(prev[s])\n+ prev[s]=i;last[s]=i\n+ ph=set();stack=[last[s] for s in S.ret]\n+ while stack:\n+ i=stack.pop()\n+ if i in ph:continue\n+ ph.add(i);stack.extend(pred[i])\n+ assert not any(set(S.touch(ops[i]))&sel for i in ph)\n+ keys=[];ids={};dims=[]\n+ def norm(k):\n+ if k[0]=='out':return ('out',0,tuple(k[2]))\n+ return k\n+ def key(k):\n+ k=norm(k)\n+ if k not in ids:\n+ ids[k]=len(keys);keys.append(k);dims.append(S.dim(k))\n+ return ids[k]\n+ z,F=key(('0',)),key(('F',))\n+ paths=[None]*size\n+ for n,ss in S.xs:paths[n-1]=[key(('n',n))]+[key(('v',s)) for s in ss]+[F]\n+ y=[[] for _ in range(v)]\n+ for s in S.readout:\n+ for t,c in co[s].items():\n+ if c&1:y[t].append(key(('sigma',s)))\n+ for t,T in enumerate(S.trip):paths[v+t]=[z]+y[t]+[key(('out',0,T))]\n+ for s in range(R):paths[2*v+s]=[key(k) for k in S.chain_keys(s)]\n+ assert all(p and all(dims[b]>=dims[a] for a,b in zip(p,p[1:])) for p in paths)\n+ pos=[0]*size;current=[p[0] for p in paths];initial=current[:]\n+ # Fixed-width event records: kind, register/destination, source-or-old,\n+ # new-or-common, rank. kind=0 move,1 xor,2 temporary copied-center macro.\n+ events=array('i');rank_hist={k:Counter() for k in ('aux','data','center')}\n+ bits=[1<=0\n+ emit(0,s,a,b,r);rank_hist['aux' if s>=2*v else 'data'][r]+=1\n+ pos[s]+=1;current[s]=b\n+ def xor(t,s):\n+ assert current[t]==current[s],('gate frames',t,s,keys[current[t]],keys[current[s]])\n+ emit(1,t,s,current[t]);bits[t]^=bits[s]\n+ def readout(s):\n+ aux=2*v+s;f=key(('sigma',s)) if s in sel else z\n+ assert current[aux]==f\n+ for t,c in sorted(co[s].items()):\n+ if c&1:move(v+t,f);xor(v+t,aux)\n+ def source(s,active):\n+ frame=key(('v',s)) if active else F\n+ move(2*v+s,frame);move(S.srcop[s]-1,frame);xor(2*v+s,S.srcop[s]-1)\n+ reordered_fans=[]\n+ def operation(i,active):\n+ op=ops[i]\n+ if op[0]=='add':\n+ _,p,o,n=op;frame=key(('n',n)) if active else F\n+ move(2*v+p,frame);move(2*v+o,frame);xor(2*v+p,2*v+o)\n+ elif op[0]=='fan':\n+ # Scalar fan targets commute. The archive groups copies whose\n+ # physical start frames differ; execute them in frame-chain order.\n+ targets=sorted(op[2],key=lambda s:S.dim(S.start_key(s))) if active else op[2]\n+ if active and tuple(targets)!=tuple(op[2]):reordered_fans.append(i)\n+ for s in targets:\n+ frame=key(S.start_key(s)) if active else F\n+ move(2*v+op[1],frame);move(2*v+s,frame);xor(2*v+s,2*v+op[1])\n+ for s in range(R):\n+ if s not in sel:readout(s)\n+ early=sorted(set(S.srcop)-sel,key=lambda s:(S.srcop[s],len(S.vstart[s]),s))\n+ for s in early:source(s,True)\n+ first=[i for i in range(len(ops)) if i in ph and ops[i][0]!='src']\n+ rest=[i for i in range(len(ops)) if i not in ph and ops[i][0]!='src']\n+ centers={}\n+ for i in first:operation(i,True)\n+ for s,c in S.ret.items():\n+ a=2*v+s;f=key(('ret',c));move(a,f)\n+ targets=[v+t for t,T in enumerate(S.trip) if c in T]\n+ assert all(current[t]==z for t in targets)\n+ centers[a]=targets;emit(2,a,f,z,h-1);rank_hist['center'][h-1]+=1\n+ for t in targets:bits[t]^=bits[a]\n+ for s in S.readout:readout(s)\n+ for s in S.late_v:source(s,True)\n+ for i in rest:operation(i,True)\n+ for s,(c,T) in S.out.items():\n+ t=S.tid[T];f=key(('out',0,T));move(2*v+s,f);move(v+t,f);xor(v+t,2*v+s)\n+ for i in reversed(first+rest):operation(i,False)\n+ for s in S.srcop:source(s,False)\n+ for s in range(R):move(2*v+s,F)\n+ assert all(bits[i]==((1<=h-3) for i in range(h)]))\n+ K=s.kronecker_product;m=h*h;J=s.eye(m);U=K(P,Q);B=K(I-P,I);T=K(I,Q)\n+ C=K(I-P,I-Q)\n+ X1=T;Y1=K(I-P,Q);X2=B+U;Y2=B\n+ assert X2-X1==Y2-Y1==C and C*C==C and C.rank()==(h-1)**2\n+ assert D(X2)*D(X1)==D(C) and D(Y2)*D(Y1)==D(C)\n+ assert D(U)*D(J)==D(J-U)\n+ for f in range(h+1):\n+ sigma=proj(I[:,:f]);A=K(sigma,Q)\n+ exit1=J-T+A;end1=J-A\n+ live2=J-K(P,sigma);end2=J-B;exit2=B+K(P,sigma)\n+ assert exit1*exit1==exit1 and exit2*exit2==exit2\n+ assert exit1.rank()==exit2.rank()==m-h+f\n+ assert D(end1)*D(T)==D(exit1)\n+ assert D(end2)*D(live2)==D(exit2)\n+ assert D(end1)*D(A)==D(J) and D(end2)*D(B)==D(J)\n+ if f:\n+ assert D(end1)*D(T)!=D(J-T);bad_controls+=1\n+ rows.append(dict(h=h,sigma_rank=f,exterior_rank=m-h+f,all_identities=True))\n+ out=dict(rows=rows,negative_omitted_sigma_rejected=bad_controls,\n+ data_connectors_per_pair=2,connector_rank_formula='(h-1)^2',correction_rank=1,\n+ elapsed=time.monotonic()-st,limit_seconds=120,\n+ scope='Exact rational finite controls of general tensor identities; not a full all-size compiler, complex phase/precision or final multiplication theorem.',new_multiplication_bound=False)\n+ (HERE/'round7-tensor-endpoint-controls.json').write_text(json.dumps(out,indent=2)+'\\n')\n+ signal.alarm(0);print(json.dumps(out,indent=2))\n+if __name__=='__main__':main()" + }, + { + "sha": "fcaeafddb14b5916950724f02f3be328f0c36ddf", + "filename": "research/deferred-signed/swapnil-round7/.gitignore", + "status": "added", + "additions": 2, + "deletions": 0, + "changes": 2, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2F.gitignore", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2F.gitignore", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2F.gitignore?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,2 @@\n+__pycache__/\n+*.pdf.tmp" + }, + { + "sha": "0167c6fda13daee13d1bbf9b885e13bb09d90aaa", + "filename": "research/deferred-signed/swapnil-round7/IMPORT.json", + "status": "added", + "additions": 111, + "deletions": 0, + "changes": 111, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FIMPORT.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FIMPORT.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2FIMPORT.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,111 @@\n+{\n+ \"repo\": \"Swapnil-jain/integer-mult-kappa\",\n+ \"head\": \"741e7aa078392553815df7926ee17ac5e25a8c38\",\n+ \"author\": \"Swapnil Jain\",\n+ \"assistance\": \"Claude (Anthropic), upstream attribution\",\n+ \"archive_sha256\": \"a623fcadb5f8628a574a1bffe0db8bcdedf85090c9bdbbab582831506caa741d\",\n+ \"files\": {\n+ \"LICENSE\": \"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4\",\n+ \"Makefile\": \"42714be051b771e6ea414d3f7da4b9beb93990d5d6e1521dc665b3b2718a888a\",\n+ \"NOTICE\": \"058a663112e633ab5349ce33b6119bacca2b9fd6c0a89918c4c0435d6dd7a008\",\n+ \"README.md\": \"07409d6f8ca1becb0cf1f7bf7f485b879bfb53663c93becefc8f4e44de6f50b9\",\n+ \".gitignore\": \"e4142bca62926744f1a60693914db92bb41be0b9ea4fbd4dd73e3af2178b0c8b\",\n+ \"artifacts/copied-centres.pdf\": \"bbd2333d9049b8f42565e2b24d6faa5c69fcc4e67b873a7bef1f6e607e4979f4\",\n+ \"artifacts/data-edge-batching.pdf\": \"9f712eb870cfad37af333acefce5162754f85087afc9647e2d86b30a70ba5c03\",\n+ \"artifacts/complex-source-frames.pdf\": \"f102b238e86a650190e2c94232fbafd3f50d30693151019a7d7b5b4addf620fd\",\n+ \"artifacts/fine-field-lemma.pdf\": \"648168584f12381f1756156aea22a3fff108b94de36c62652b75558b81c0a118\",\n+ \"artifacts/round3-combination.pdf\": \"cc56ddcff426818b0fb096a47f837fceb98b928d31c428f6dccaca53aff4b3c7\",\n+ \"artifacts/partial-swap-batching.pdf\": \"2a76b1ce513c08d408a7524d825e922cc7a3939a772237d3a08f9683f2235289\",\n+ \"artifacts/deferred-readout.pdf\": \"ca659ffa1dccdb05ebbcb95c8ca6342704bcc98656a57be9a05aa71faafe0bdb\",\n+ \"artifacts/stack-notes.pdf\": \"3c1181d1e3b6a55d8092d39e37c7b0ef712d8ace0b76dc8f493578bef6006eae\",\n+ \"artifacts/flag-basis.pdf\": \"35cbcff404998f4e66c026e98c72f895bd8f8f2b90ba8d60b390af1d150b2cf7\",\n+ \"artifacts/segmented-inverse.pdf\": \"cb33411a0b9b552ec881b884498567997c10f9cb9d63cb7d5a864277ccebdfb0\",\n+ \"lean/dump7.py\": \"068cfb9e4139ddbcff8d3b987b92415ed0ddee20e5a4ccdf2fed5c116d52834e\",\n+ \"lean/gen.py\": \"e4c7051a4051989bb659553884773d06dd3f09e34ba2710ad5142b702294cfc4\",\n+ \"lean/dump6.py\": \"f32e6de60a389803f2226b2229944404ea9e09a9291f83c8eefae54b2dc158f2\",\n+ \"lean/round7-histograms.json\": \"8fd0abe6c230980b9a0c4a175e06ca1808b0fe5ead0cf9f268496111c2e11d2c\",\n+ \"lean/round6-histograms.json\": \"e1d955df15523fd0f83c82e2a4bc080bf378ee50deb3003fce4771ac30f4ed26\",\n+ \"lean/Round7.lean\": \"fc897ba78f0b4e429104bef7e15d728c9095f1b948f9e51b76252a368819631d\",\n+ \"lean/Round6.lean\": \"27a4b348551cb8cce209864c08096230dba5e9f4ab04e469fcfedb61bca9b78a\",\n+ \"lean/dump.py\": \"5cd0ec7494bbe5441c44ab6b9f2155172e1e9a75852ecdcd7aef0ebc5a36d11f\",\n+ \"lean/Round5.lean\": \"bb45184861572975a9d9f9d3f515c9897794a30fdab4efd81b074da16629ac56\",\n+ \"lean/round5-histograms.json\": \"88e0befd88833b9c67f84a2cfcb47f07101c95a2aa4d72b8a72df837cb954168\",\n+ \"tests/test_round4.py\": \"b21bc2654452b04f8404670c42adc9fcd8e46ede578b5cb0aa88c7243a89ad20\",\n+ \"tests/test_round5.py\": \"cd0c77f9e6af31fa8a6c4efe27cfca200183322cf9128e4c6ed1d675cd0c52c4\",\n+ \"tests/test_witness.py\": \"8cc1b358bd92a31d454c7dc9a2739d1d9cb53f19e3f88035aa4cd6babf11cb77\",\n+ \"tests/test_round6.py\": \"58bd299b361c8119c2ffa1381582346ef8f1a0cf448d847c19ec9bdbe19f78c3\",\n+ \"tests/test_round7.py\": \"c0e988d363f9d989275693b340e97b59dc16e4d8835e1e9ea3d4c589da277a0f\",\n+ \"tests/test_round3.py\": \"7d9af1fb8b48c4eae029e2b37daf460c8cb727308ed840b0197f40593b618886\",\n+ \"certificates/witness.json\": \"ffb5ac42a64969dae7d19012e5102d7aeb66c3eee529bde9812bd182cb9eafa1\",\n+ \"certificates/identities.json\": \"76b35a0fdb1bf1926325bf33648dbae3e0de34699ce6dd1e95a23a09f762cd44\",\n+ \"notes/round3-combination.tex\": \"1f3eab33880c137591b6f984aa3220ca8fbc1e833a91c2aeea430f3c62580b74\",\n+ \"notes/fine-field-lemma.tex\": \"838204a16fff7dc4bc575107a5745ba28d93f4928b7e1a9100ba2c12f7b63b8d\",\n+ \"notes/complex-source-frames.tex\": \"942a4369dd843736732a5ec27a1616e3ae1c2f2f8cc00b67e4a88759548a15e0\",\n+ \"notes/data-edge-batching.tex\": \"31e7ef597a439945fd74fcfb0d8fc8fdc01d0baa7d00f69caf9aab66c7c93dc5\",\n+ \"notes/copied-centres.tex\": \"7b7fe97b021e00bfb2139d15e41be9ba8579803884ac2082c2b7f6ab53879aba\",\n+ \"notes/segmented-inverse.tex\": \"cce6dcb88dc507c679691786909251cf79f681c673716c89524a15dbc1e97436\",\n+ \"notes/flag-basis.tex\": \"0f00ee0558ca661e4a793322e6336d9a6189f7d8e1be4e90be6232bb9327d59f\",\n+ \"notes/stack-notes.tex\": \"0f7725b97b6c85adc6fc38045703ca39b52ddfa9e76d14e446dbe948c47faae8\",\n+ \"notes/partial-swap-batching.tex\": \"f82e5ff671a7532308c0b4e5424f76a80653e0d170779b27c9e72b3c8311de21\",\n+ \"notes/deferred-readout.tex\": \"953963b0a986bed4ac7c5c8d0ec0cd593f6525691bec9ea55a058d60669ec411\",\n+ \"scripts/check_identities.py\": \"27a91fe1fab8a0171ec59edf697c0e41fd5747792a0385e2e9f3b38beaa5b91a\",\n+ \"scripts/check_gs_path.py\": \"9f39eeda5fed8920fffaa3309df3531e1ff3a30c3b8659745ab583012e0669ec\",\n+ \"scripts/certificate.py\": \"dbce6f0d3cc3cbd076686f2adf4a592fac8850abc0fd718a0933694770e9167c\",\n+ \"scripts/certificate_round7.py\": \"6f858bb8b601967e45f73eafe698cf8c5f0417182a8b1c1541c1e96b7a0f5107\",\n+ \"scripts/certificate_round3.py\": \"53deb36c0f5daffc68ee02dabf189d2700f39a2bb3f01b55c663c49cd315b9ae\",\n+ \"scripts/certificate_round6.py\": \"f1d65865357b535ddd4d98b0f3bfc1947b9a434993e7c5ba1536d3a62439948f\",\n+ \"scripts/check_subblock_inverse.py\": \"49fb7c2bd29bd714929e4397ea9e11a0b5e258be8ef665e33d573faded600479\",\n+ \"scripts/certificate_round5.py\": \"6c948d995fdc60df70a36f1fe658b9dd06960fafd48badfce2144fc764a3d2b9\",\n+ \"scripts/check_segmented_inverse.py\": \"0fe5d5597c9925921979d22654ec60d45049178e423f1a54fdd63e3fe5853da3\",\n+ \"scripts/certificate_round4.py\": \"a6113295a7af30b581d1230e630bba3dc7759be7807d8b2628aeaca31cddf441\",\n+ \"scripts/check_reuse_inverse.py\": \"f038a6cb823711434620412753b885962613c377cf1d0568ff6f20be09edf8d9\",\n+ \"scripts/check_fine_field.py\": \"93710f045ab8e8c0d4881380368405214484759e63f9f933a5c5c0f85871bd4c\",\n+ \"certificates/round7/deferred_23.json.gz\": \"8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c\",\n+ \"certificates/round7/witness_23.json.gz\": \"b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588\",\n+ \"certificates/external/pr24-bit-network.json\": \"f9ddc6c33dda1abdaf05d0fff651d02e9a04557ebbb1b8da11d4d6de8de08d91\",\n+ \"independent/partial-swap/test_factor.py\": \"0c1da25c545e1e7cdd6eca5140579a6b6273789de39171487624c7ff6490dec6\",\n+ \"independent/partial-swap/moment.py\": \"a1c5fa749b41d483dafb66d7ba56d2e77a8735befbbcac8391b8e1d8ce1ee2d3\",\n+ \"independent/partial-swap/README.md\": \"8f9bb3c2e7037e5c601b740e195cc5207bf3eec906fdea9c6f4ee73a7ca98da0\",\n+ \"independent/partial-swap/frames.py\": \"6931781fc7097daf44327de262ef9df68d95f3ebab3b2a6c22422066c1e7ea1a\",\n+ \"independent/partial-swap/factor.py\": \"a246d8d4b4d110125406648f9fb49725894c3652102049caf3555ab191fc0e7b\",\n+ \"independent/pr7-role-counts/complexside.py\": \"6ae9a08122efbad803b375dd5696485c6911ff799111dcf09811fd88bcc71539\",\n+ \"independent/pr7-role-counts/local.py\": \"75362c04f5fd538dc8491b913d89cba7d9c30933b9e475372e75a79ce56353bd\",\n+ \"independent/pr7-role-counts/export.py\": \"de3fb97184ac8a9a654190023913b1eb2158a8ff70bb069ec8353092e6483de9\",\n+ \"independent/pr7-role-counts/README.md\": \"ef301c65851d91dc7ea0e920b33de4d36ee1249f768a504c8e5b3a29dd4abf7c\",\n+ \"independent/pr7-role-counts/global.cpp\": \"7312be680d8026b5b9730a7e531f7a2cc6a7d445a65d14bb18ec4e3c2f393f1a\",\n+ \"independent/deferred-readout/check_lifted.py\": \"c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c\",\n+ \"independent/deferred-readout/check_stair.py\": \"5b684020b394869d1b899dfffbdf1518de6b3b3562c0f5a2a81a2f43ced42d40\",\n+ \"independent/deferred-readout/linalg.py\": \"56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b\",\n+ \"independent/deferred-readout/deferred.py\": \"e92ac1db9fce8608cf5302336f05750fa327eda99f7170ed32e7323220ffc164\",\n+ \"independent/deferred-readout/check_word.py\": \"c31a321e28556c9d9cb3397e48292e8ecefc0b08e233243d7849bd585213af65\",\n+ \"independent/deferred-readout/check_frames.py\": \"1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8\",\n+ \"independent/complex-network/bc.py\": \"056ca643666dff4405eecfb6f0f8a33da3a50244c65d9bc2e28fa95ea32956e1\",\n+ \"independent/complex-network/fullbatch_cert.py\": \"c4b0d8b9cdb7dceb881747826356fb6eedd5ad465c483ed7cda0ba2a8d2d90d4\",\n+ \"independent/complex-network/labels.py\": \"4edb0206c6f44081c1be434a529fce3527a46a35fee3e874a97898d60eabbe20\",\n+ \"independent/complex-network/roles.py\": \"499e4f7ea700a917e7c3991b91ac99e1b0eb7eb51fb6d362b395d0056b64bdee\",\n+ \"independent/complex-network/README.md\": \"b1e790d7a268716b62d19f1e6617b9f55f81bbfbd0c474a3a0801918b5ba6a7b\",\n+ \"independent/complex-network/sourceframe_trace.py\": \"688e609cc0adbfba17dd74984d382121ce6741afc7e2da548ee553ea15c4d3c9\",\n+ \"independent/complex-network/fullbatch_hist.py\": \"dbfa0844ff605abfe386f30f3bf9859c3f1b040eae019e184668c82439d788d1\",\n+ \"independent/complex-network/sourceframe_sim.py\": \"ef9c47f92ef46aa7f701493aab95d65f930d4d31db214bc83b683cf7ddb7868b\",\n+ \"independent/complex-network/sourceframe_labels.py\": \"f1a2ff1e6aa68e3052d77d664744d85ac76c31f7b779bd66be018ee82ea0aec7\",\n+ \"independent/complex-network/side.py\": \"90703356b485a21bbcf2f4dca9c1cc7109767a16afd2a04ac113b2c6e1d569ce\",\n+ \"independent/complex-twostage/run.py\": \"fff6190b4f197689aad55077be882e8c95e0b699d366eadee5882cf8ff08be44\",\n+ \"independent/complex-twostage/hist.py\": \"e20d077acfc95e2f8239fcdcc03146cc15607996e2734eb2d00b68ed7d43ec64\",\n+ \"independent/complex-twostage/producer.py\": \"e1715616ac8cafa8f63b7c0a2e7deacdba7daea94662e0a84626d5374fd27b5c\",\n+ \"independent/complex-twostage/cert.py\": \"f9352729213b8441d076708b738d158093caa34d050fa2d838b61e07eb3a298b\",\n+ \"independent/complex-twostage/frames.py\": \"8629850bd465250cdf298b47b86504f2ac507d5fa044f8c0d2a20b451d19aa0f\",\n+ \"independent/two-stage-bit/checkgm.py\": \"73281a2fe6506cf17934497a476e2fff97bf994b1b950e0f735b3dfd6510916b\",\n+ \"independent/two-stage-bit/flagbasis.py\": \"b3b6df4f3d024aba1de9b54903a41e4163feb397f0e412d3c9c60f7558204b5d\",\n+ \"independent/two-stage-bit/gmside.py\": \"a8cda0c24718980bd02b7983d340b0b97ce91f2241b81ef4127042ba81932847\",\n+ \"independent/two-stage-bit/moment.py\": \"4ca6b15fa6cf799b7252d9a70d5c66dcbe86f3cc16b03b7c6f03ccda66df41be\",\n+ \"independent/two-stage-bit/orders.py\": \"ff0f0515eda0f4dc995d07436e65663c553bfa01748fa2eeec96dcee8d0a34c3\",\n+ \"independent/two-stage-bit/cert_rt.py\": \"b15adc5aa1ea5761fb7dd5873c4dd44d28f15705c6ab2b1df87d3bd4b69e9a77\",\n+ \"independent/two-stage-bit/sidegen.py\": \"e97ec987bd20d86e73c92f940f2ba2650f39209db14dc5f00b88436481fa4e28\",\n+ \"independent/two-stage-bit/corners.py\": \"f4c5d20e62967a2a7484bea59f44366daa82ca4c169691e9003e7fee76273c2b\",\n+ \"independent/two-stage-bit/side_chains.py\": \"98c8b33d5761a6135238983a05b81a4250c0a9f02979096ae110d1104c77970d\",\n+ \"independent/two-stage-bit/checkside.py\": \"92465c6b1fb5f4830d56af1d54222f917cab8cbfd67b1eb4e707dc0d8c5076a8\",\n+ \"independent/two-stage-bit/flag_existence.py\": \"aa4205b2c59bb50faaff2f01bac8fb9b62dbb855638ea8cde678f801de30ad08\",\n+ \"independent/two-stage-bit/bruhat8.py\": \"e703992629634ff50337828d6fc1ec23daf2bc1e5f742adb62878fe3a5a85951\",\n+ \"independent/two-stage-bit/rtgm.py\": \"1cdb902014b3c9d2a72deda999905dd04fbd555f7813d4664ca0e16355b42fdc\"\n+ }\n+}" + }, + { + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "filename": "research/deferred-signed/swapnil-round7/LICENSE", + "status": "added", + "additions": 201, + "deletions": 0, + "changes": 201, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FLICENSE", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FLICENSE", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2FLICENSE?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,201 @@\n+ Apache License\n+ Version 2.0, January 2004\n+ http://www.apache.org/licenses/\n+\n+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n+\n+ 1. Definitions.\n+\n+ \"License\" shall mean the terms and conditions for use, reproduction,\n+ and distribution as defined by Sections 1 through 9 of this document.\n+\n+ \"Licensor\" shall mean the copyright owner or entity authorized by\n+ the copyright owner that is granting the License.\n+\n+ \"Legal Entity\" shall mean the union of the acting entity and all\n+ other entities that control, are controlled by, or are under common\n+ control with that entity. For the purposes of this definition,\n+ \"control\" means (i) the power, direct or indirect, to cause the\n+ direction or management of such entity, whether by contract or\n+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\n+ outstanding shares, or (iii) beneficial ownership of such entity.\n+\n+ \"You\" (or \"Your\") shall mean an individual or Legal Entity\n+ exercising permissions granted by this License.\n+\n+ \"Source\" form shall mean the preferred form for making modifications,\n+ including but not limited to software source code, documentation\n+ source, and configuration files.\n+\n+ \"Object\" form shall mean any form resulting from mechanical\n+ transformation or translation of a Source form, including but\n+ not limited to compiled object code, generated documentation,\n+ and conversions to other media types.\n+\n+ \"Work\" shall mean the work of authorship, whether in Source or\n+ Object form, made available under the License, as indicated by a\n+ copyright notice that is included in or attached to the work\n+ (an example is provided in the Appendix below).\n+\n+ \"Derivative Works\" shall mean any work, whether in Source or Object\n+ form, that is based on (or derived from) the Work and for which the\n+ editorial revisions, annotations, elaborations, or other modifications\n+ represent, as a whole, an original work of authorship. For the purposes\n+ of this License, Derivative Works shall not include works that remain\n+ separable from, or merely link (or bind by name) to the interfaces of,\n+ the Work and Derivative Works thereof.\n+\n+ \"Contribution\" shall mean any work of authorship, including\n+ the original version of the Work and any modifications or additions\n+ to that Work or Derivative Works thereof, that is intentionally\n+ submitted to Licensor for inclusion in the Work by the copyright owner\n+ or by an individual or Legal Entity authorized to submit on behalf of\n+ the copyright owner. For the purposes of this definition, \"submitted\"\n+ means any form of electronic, verbal, or written communication sent\n+ to the Licensor or its representatives, including but not limited to\n+ communication on electronic mailing lists, source code control systems,\n+ and issue tracking systems that are managed by, or on behalf of, the\n+ Licensor for the purpose of discussing and improving the Work, but\n+ excluding communication that is conspicuously marked or otherwise\n+ designated in writing by the copyright owner as \"Not a Contribution.\"\n+\n+ \"Contributor\" shall mean Licensor and any individual or Legal Entity\n+ on behalf of whom a Contribution has been received by Licensor and\n+ subsequently incorporated within the Work.\n+\n+ 2. Grant of Copyright License. Subject to the terms and conditions of\n+ this License, each Contributor hereby grants to You a perpetual,\n+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n+ copyright license to reproduce, prepare Derivative Works of,\n+ publicly display, publicly perform, sublicense, and distribute the\n+ Work and such Derivative Works in Source or Object form.\n+\n+ 3. Grant of Patent License. Subject to the terms and conditions of\n+ this License, each Contributor hereby grants to You a perpetual,\n+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n+ (except as stated in this section) patent license to make, have made,\n+ use, offer to sell, sell, import, and otherwise transfer the Work,\n+ where such license applies only to those patent claims licensable\n+ by such Contributor that are necessarily infringed by their\n+ Contribution(s) alone or by combination of their Contribution(s)\n+ with the Work to which such Contribution(s) was submitted. If You\n+ institute patent litigation against any entity (including a\n+ cross-claim or counterclaim in a lawsuit) alleging that the Work\n+ or a Contribution incorporated within the Work constitutes direct\n+ or contributory patent infringement, then any patent licenses\n+ granted to You under this License for that Work shall terminate\n+ as of the date such litigation is filed.\n+\n+ 4. Redistribution. You may reproduce and distribute copies of the\n+ Work or Derivative Works thereof in any medium, with or without\n+ modifications, and in Source or Object form, provided that You\n+ meet the following conditions:\n+\n+ (a) You must give any other recipients of the Work or\n+ Derivative Works a copy of this License; and\n+\n+ (b) You must cause any modified files to carry prominent notices\n+ stating that You changed the files; and\n+\n+ (c) You must retain, in the Source form of any Derivative Works\n+ that You distribute, all copyright, patent, trademark, and\n+ attribution notices from the Source form of the Work,\n+ excluding those notices that do not pertain to any part of\n+ the Derivative Works; and\n+\n+ (d) If the Work includes a \"NOTICE\" text file as part of its\n+ distribution, then any Derivative Works that You distribute must\n+ include a readable copy of the attribution notices contained\n+ within such NOTICE file, excluding those notices that do not\n+ pertain to any part of the Derivative Works, in at least one\n+ of the following places: within a NOTICE text file distributed\n+ as part of the Derivative Works; within the Source form or\n+ documentation, if provided along with the Derivative Works; or,\n+ within a display generated by the Derivative Works, if and\n+ wherever such third-party notices normally appear. The contents\n+ of the NOTICE file are for informational purposes only and\n+ do not modify the License. You may add Your own attribution\n+ notices within Derivative Works that You distribute, alongside\n+ or as an addendum to the NOTICE text from the Work, provided\n+ that such additional attribution notices cannot be construed\n+ as modifying the License.\n+\n+ You may add Your own copyright statement to Your modifications and\n+ may provide additional or different license terms and conditions\n+ for use, reproduction, or distribution of Your modifications, or\n+ for any such Derivative Works as a whole, provided Your use,\n+ reproduction, and distribution of the Work otherwise complies with\n+ the conditions stated in this License.\n+\n+ 5. Submission of Contributions. Unless You explicitly state otherwise,\n+ any Contribution intentionally submitted for inclusion in the Work\n+ by You to the Licensor shall be under the terms and conditions of\n+ this License, without any additional terms or conditions.\n+ Notwithstanding the above, nothing herein shall supersede or modify\n+ the terms of any separate license agreement you may have executed\n+ with Licensor regarding such Contributions.\n+\n+ 6. Trademarks. This License does not grant permission to use the trade\n+ names, trademarks, service marks, or product names of the Licensor,\n+ except as required for reasonable and customary use in describing the\n+ origin of the Work and reproducing the content of the NOTICE file.\n+\n+ 7. Disclaimer of Warranty. Unless required by applicable law or\n+ agreed to in writing, Licensor provides the Work (and each\n+ Contributor provides its Contributions) on an \"AS IS\" BASIS,\n+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n+ implied, including, without limitation, any warranties or conditions\n+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n+ PARTICULAR PURPOSE. You are solely responsible for determining the\n+ appropriateness of using or redistributing the Work and assume any\n+ risks associated with Your exercise of permissions under this License.\n+\n+ 8. Limitation of Liability. In no event and under no legal theory,\n+ whether in tort (including negligence), contract, or otherwise,\n+ unless required by applicable law (such as deliberate and grossly\n+ negligent acts) or agreed to in writing, shall any Contributor be\n+ liable to You for damages, including any direct, indirect, special,\n+ incidental, or consequential damages of any character arising as a\n+ result of this License or out of the use or inability to use the\n+ Work (including but not limited to damages for loss of goodwill,\n+ work stoppage, computer failure or malfunction, or any and all\n+ other commercial damages or losses), even if such Contributor\n+ has been advised of the possibility of such damages.\n+\n+ 9. Accepting Warranty or Additional Liability. While redistributing\n+ the Work or Derivative Works thereof, You may choose to offer,\n+ and charge a fee for, acceptance of support, warranty, indemnity,\n+ or other liability obligations and/or rights consistent with this\n+ License. However, in accepting such obligations, You may act only\n+ on Your own behalf and on Your sole responsibility, not on behalf\n+ of any other Contributor, and only if You agree to indemnify,\n+ defend, and hold each Contributor harmless for any liability\n+ incurred by, or claims asserted against, such Contributor by reason\n+ of your accepting any such warranty or additional liability.\n+\n+ END OF TERMS AND CONDITIONS\n+\n+ APPENDIX: How to apply the Apache License to your work.\n+\n+ To apply the Apache License to your work, attach the following\n+ boilerplate notice, with the fields enclosed by brackets \"[]\"\n+ replaced with your own identifying information. (Don't include\n+ the brackets!) The text should be enclosed in the appropriate\n+ comment syntax for the file format. We also recommend that a\n+ file or class name and description of purpose be included on the\n+ same \"printed page\" as the copyright notice for easier\n+ identification within third-party archives.\n+\n+ Copyright [yyyy] [name of copyright owner]\n+\n+ Licensed under the Apache License, Version 2.0 (the \"License\");\n+ you may not use this file except in compliance with the License.\n+ You may obtain a copy of the License at\n+\n+ http://www.apache.org/licenses/LICENSE-2.0\n+\n+ Unless required by applicable law or agreed to in writing, software\n+ distributed under the License is distributed on an \"AS IS\" BASIS,\n+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n+ See the License for the specific language governing permissions and\n+ limitations under the License." + }, + { + "sha": "fdff0234e8d7adbc975c8487e7fb6a17820518df", + "filename": "research/deferred-signed/swapnil-round7/Makefile", + "status": "added", + "additions": 47, + "deletions": 0, + "changes": 47, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FMakefile", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FMakefile", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2FMakefile?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,47 @@\n+.PHONY: verify roles round4 round7 lean notes\n+verify:\n+\tpython3 scripts/check_identities.py\n+\tpython3 scripts/check_segmented_inverse.py\n+\tpython3 scripts/check_subblock_inverse.py\n+\tpython3 scripts/check_reuse_inverse.py\n+\tpython3 scripts/check_reuse_inverse.py 113 128 8 120 50\n+\t! python3 scripts/check_reuse_inverse.py 241 256 17 150 60 1\n+\tpython3 scripts/check_gs_path.py\n+\tpython3 scripts/check_fine_field.py\n+\tpython3 scripts/certificate.py\n+\tpython3 -m unittest discover -s tests -v\n+\n+roles:\n+\tcd independent/pr7-role-counts && python3 export.py 26 /tmp/local26.txt && clang++ -O2 -std=c++17 global.cpp -o /tmp/global && /tmp/global 28 /tmp/local26.txt && python3 complexside.py 28\n+\n+round4:\n+\tpython3 independent/complex-network/fullbatch_hist.py 28 /tmp/fb28sf.json sf\n+\tpython3 scripts/certificate_round4.py /tmp/fb28sf.json\n+\tpython3 independent/two-stage-bit/checkside.py 47\n+\n+round7:\n+\tpython3 scripts/certificate_round7.py\n+\tpython3 independent/deferred-readout/check_word.py 23\n+\tpython3 independent/deferred-readout/check_frames.py 23\n+\tpython3 independent/deferred-readout/check_lifted.py 23\n+\tpython3 independent/deferred-readout/check_stair.py 23\n+\tpython3 independent/deferred-readout/check_stair.py 23 --control | grep -q 'certified=False'\n+\n+lean:\n+\tpython3 lean/gen.py\n+\tlean lean/Round5.lean\n+\tpython3 lean/gen.py round6-histograms.json Round6.lean\n+\tlean lean/Round6.lean\n+\tpython3 lean/dump7.py\n+\tpython3 lean/gen.py round7-histograms.json Round7.lean\n+\tlean lean/Round7.lean\n+\n+notes:\n+\ttectonic -X compile --outdir artifacts notes/segmented-inverse.tex\n+\ttectonic -X compile --outdir artifacts notes/stack-notes.tex\n+\ttectonic -X compile --outdir artifacts notes/fine-field-lemma.tex\n+\ttectonic -X compile --outdir artifacts notes/partial-swap-batching.tex\n+\ttectonic -X compile --outdir artifacts notes/round3-combination.tex\n+\ttectonic -X compile --outdir artifacts notes/data-edge-batching.tex\n+\ttectonic -X compile --outdir artifacts notes/complex-source-frames.tex\n+\ttectonic -X compile --outdir artifacts notes/deferred-readout.tex" + }, + { + "sha": "be2e7e5a9838fe7e284aff3babc864455c2281d2", + "filename": "research/deferred-signed/swapnil-round7/NOTICE", + "status": "added", + "additions": 36, + "deletions": 0, + "changes": 36, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FNOTICE", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FNOTICE", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2FNOTICE?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,36 @@\n+Past the a_b/2 ceiling for integer multiplication\n+Copyright 2026 Swapnil Jain\n+\n+This work builds on, and does not modify, the following:\n+\n+- OpenAI, \"Integer multiplication below n log n\" (September 23, 2026), pinned at\n+ commit adc7f1241b42e322a6451854ab7e4b4c146bf78a of github.com/openai/math.\n+- Douglas Colkitt, github.com/CrocSwap/integer-mult-bounds (Apache-2.0), commit\n+ 6e564879f51ae16f23d392e9e196c605f36d90df: compact controls and the conditional\n+ 83/10^12 witness.\n+- Prior published results this witness assumes and cites (citations of prior work,\n+ not collaborators), from open pull requests on that repository:\n+ #3 and #5 (eumemic: compressed complex network, fast Gaussian resampling),\n+ #4 (dleen), #6 (eumemic), #7 (Zhihao Chen / jacklightChen: ternary five-subset\n+ networks, a_b = 3/(4*10^8), a_c = 39/10^9),\n+ #10 (icekylinx: batched recursion, controlled projector basis, whole-residual\n+ complex children, Gaussian input-error correction),\n+ #13 (eumemic: auxiliary source frames, third whole-residual complex class),\n+ #15 (eumemic, head a17cab3: full complex batching of every residual rank),\n+ #18 (icekylinx, head f2ab41a: partial-swap networks, producers and common rational basis),\n+ #21 (jacklightChen, head 5ba6cf0: translated partial-swap frames; it also contains, independently\n+ and earlier in public, the complex source-frame translation we use),\n+ #16 (jacklightChen: nested controlled bases) and #29 (jacklightChen: controlled inner basis compiling local\n+ edges as blocks), related to our flag basis and side-role batching, which were developed independently,\n+ #36 (icekylinx: copied retained centres, used on both our interchanges in rounds six and seven),\n+ #62 (ikeboy: interval strips and core-aware pair assembly; its producer builds our round-seven side program),\n+ #41 (RaD / hipotures: the alternating order and links, used in that side program),\n+ #44 (rohanarun: weighted matching, which our moment-weighted choice of links follows),\n+ #24 (icekylinx, head ed90fd9: endpoint-gauge bit network; certificates/external/pr24-bit-network.json\n+ extracts its published counts and child-width multiplicities, Apache-2.0).\n+- Aurel Prosz (Paureel), github.com/Paureel/integer-mult-bounds commit c82d09e:\n+ the two-stage motif with partial-swap frames and charged endpoint correction, and its complement-frame\n+ construction, which our lifted frames follow in round seven.\n+\n+Research, implementation and drafting were done with assistance from Claude\n+(Anthropic). AI assistance is not independent review." + }, + { + "sha": "09708066640450a0aea89976579b5aba82098ac1", + "filename": "research/deferred-signed/swapnil-round7/README.md", + "status": "added", + "additions": 211, + "deletions": 0, + "changes": 211, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,211 @@\n+# Integer multiplication: a conditional witness above 2^-14\n+\n+**Conditional research draft by Swapnil Jain.**\n+\n+This draft builds on OpenAI's *Integer multiplication below n log n* and on Douglas\n+Colkitt's [integer-mult-bounds](https://github.com/CrocSwap/integer-mult-bounds). In\n+that model (a fixed finite alphabet and a fixed number of one-dimensional tapes),\n+it gives the conditional witness\n+\n+$$\n+T(n)=O\\!\\left(n(\\log n)^{1-\\kappa}\\right),\\qquad\n+\\boxed{\\kappa=\\frac{1599247689723}{2.5\\times10^{16}}\\approx6.39699\\times10^{-5}>2^{-14}}.\n+$$\n+\n+That is about 1.74 times our round-six witness `3.66657e-5`, 4.13 times our round-five witness `1.54788e-5`,\n+5.34 times our round-four witness `1.19722e-5`, and about 8500 times our first witness `7499/10^12`. These figures\n+compare asymptotic exponents, not practical runtimes.\n+\n+## Round seven\n+\n+`scripts/certificate_round7.py` rebuilds the bit side's child-width histogram from a frozen schedule\n+(`certificates/round7/`, about 2.3 MB compressed) and certifies it; the complex side is round six's. The bit side at\n+`h = 23` (`notes/deferred-readout.tex`):\n+\n+- **PR #62's producer** (interval strips and core-aware pair assembly), with PR #41's alternating order and links\n+ and a moment-weighted choice of links after PR #44's weighted matching, builds the side program\n+ (`R = 28866` slots).\n+- **Lifted frames and late copies.** Every addition acts at `M_n = span(n) + (U_n cap F_j)`, after Paureel's\n+ complement-frame construction, and a node with several free uses copies itself late, at the intersection of the\n+ frames of its remaining users, so the copy starts higher up its chain.\n+- **Deferred readouts (B-defer).** The second pass of stage one runs in two phases: first everything the retained\n+ totals need (their copies then read every target at `0`), then every slot that phase did not touch reads its\n+ garbage out at a nonzero frame `sigma_u` inside its start frame and every target's `t_T^perp`. Only the order of\n+ the word changes; it is still a mirror. Readouts go in increasing `dim sigma_u`, which keeps every target's frame\n+ sequence nested.\n+- **V leaves.** Each use of a leaf gets its own `V` gate on the data wire `X_S`, as a late copy there: the use slot\n+ starts at the intersection `s_i` of the frames of the remaining uses, and the deferred `V` gates follow in\n+ increasing dimension.\n+\n+The rank sum is exactly round six's budget `s = Wm - N + L`. With the staircase data-entrance corner (runs\n+`h-2, h-5, 1^6`) this certifies `a_b = 31987/(5*10^8)` and `kappa = 1599247689723/(2.5*10^16)`; with the\n+round-six entrance corner, `a_b = 12599/(2*10^8)` and `kappa = 6299103187973/10^17 > 2^-14`.\n+\n+The checks are standard-library Python, one process each (`make round7`, about 25 minutes and at most 1.2 GB of memory):\n+\n+- `independent/deferred-readout/check_word.py` replays the reordered word over F2 and over Z with arbitrary\n+ scratch, checks that the schedule computes the side DAG, the phase split and the ordering rule, with negative\n+ controls;\n+- `check_frames.py` rebuilds every frame exactly over Q and checks the deferred and V-leaf frames, the nesting of\n+ every target and data chain in time order, G-nondegeneracy, the side lemma on every new high-rank step, and the\n+ histogram, with negative controls;\n+- `check_lifted.py` checks the base side program: DAG, compilation, dirty-scratch replay, exact frame dimensions,\n+ nesting facts, G-nondegeneracy and the side lemma on all of its high-rank steps;\n+- `check_stair.py` certifies the staircase entrance corner at the same integer point.\n+\n+Stage two is the complement time-reversal of stage one, as in round six; this is assumed, not machine-checked. The\n+moment certificates and both assemblies are also checked in Lean 4's kernel (`lean/Round7.lean`, `make lean`).\n+\n+## Round six (previous witness, `3666565558019/10^17`)\n+\n+`scripts/certificate_round6.py` (bit side) and `independent/complex-twostage/` (complex side) assemble the witness:\n+\n+- **Copied centres** (`notes/copied-centres.tex`), after PR #36's copied retained-centre schedule. A centre must be\n+ read at `D0` by the second scatter and then gathered at `D1`; instead, a temporary copy goes down to `D0` for the\n+ reads and is erased, and the original never leaves `D1`. Each centre loses one rank-`h` return per stage, the rank\n+ budget becomes `s = Wm - N + L`, and the deficit `v(v - 2h^2)` is positive at much smaller `h`. On our bit\n+ interchange (flag basis, gm side circuit, side roles batched one level down, data-entrance run) this certifies\n+ `a_b = 34919/10^9` at `h = 25`.\n+- **Retained point totals** replace the direct centre wires: each total is a side role built from existing side\n+ nodes, its copy pays rank `h-1` and the original rank `1`, so the loss per centre drops from `h` to `h-1` and the\n+ centre roles leave `W` (`independent/two-stage-bit/rtgm.py`). This certifies `a_b = 36667/10^9` at `h = 23`.\n+- **The two-stage complex interchange** with our pair-exclusion producer, copied retained centres, complex data-edge\n+ batching and every residual batched as one whole-residual child, certifies `a_c = 36926111/(5*10^11)` at `h = 24`\n+ (`cd independent/complex-twostage && python3 run.py 24`: rank sum exact, labels 0 bad, `a_c >= 73861113/10^12`).\n+\n+The bit side binds: `kappa = 3666565558019/10^17`. Both moment certificates and the assembly are also checked in\n+Lean 4's kernel (`lean/Round6.lean`, `make lean`), as in round five.\n+\n+## Round five (previous witness, `309575208081/(2*10^16)`)\n+\n+`scripts/certificate_round5.py` assembles the witness from our own two-stage bit interchange (Paureel's\n+two-stage motif), with no outside bit network:\n+\n+- **A common flag basis** (`notes/flag-basis.tex`). One rational basis makes the corners of every auxiliary and\n+ centre edge of the two-stage motif lower triangular, in both stages at once, so each role's `h` corner\n+ transpositions become one contiguous run instead of `h` singleton calls. The same basis gives the data edges\n+ their batched profiles one level down, including one run of width `h-2` inside the data-entrance corner (a\n+ triangular corner plus a rank-one term). `independent/two-stage-bit/flagbasis.py` checks every edge class\n+ exactly, and `flag_existence.py` checks the nonvanishing conditions at the working dimensions `h = 46, 47`.\n+- **A cheaper side circuit** (`independent/two-stage-bit/gmside.py`): a global matching of the points shares\n+ pair sums and exclusion chains between centres, cutting the side roles at `h = 47` from 418678 to 403248;\n+ `checkgm.py` re-derives every support and output exactly.\n+- PR #7's complex network, fully batched with complex source frames, as in round four.\n+\n+- **Side roles batched one level down.** In the flag basis every side-role edge has the form `pi (x) P_b`, whose\n+ profile is that of the `h x h` idempotent `pi`: an edge of rank `r > h/2` becomes `h-r` singletons and one\n+ block of width `2r-h`. `independent/two-stage-bit/side_chains.py` derives every side role's frame chain from\n+ the compiled side program.\n+\n+The two moment certificates are also checked in Lean 4's kernel (`lean/Round5.lean`, `make lean`, core Lean\n+only): both child-width histograms sum to their total rank, the rational upper bounds on `ln(m/w)` are computed from\n+their series, the moment bound holds at the claimed savings, and the assembly (every constraint row and cost margin of\n+`scripts/certificate_round3.py`, with the guard constant bounded through the same ln series) gives the headline\n+`kappa`. The analytic facts behind those bounds (the atanh\n+tail and `(m/w)^a <= 1/(1 - a ln(m/w))`) are stated premises, not formalised.\n+\n+Together these certify `a_b = 15479/10^9` at `h = 47` and `kappa = 309575208081/(2*10^16) > 2^-16`.\n+\n+## Round four (previous witness, `59861145819/(5*10^15)`)\n+\n+`scripts/certificate_round4.py` assembles the witness from:\n+\n+- the stack below, which drives `eps` toward 1 (the bit side binds);\n+- PR #24's endpoint-gauge bit network, built on PR #18's partial-swap networks. We take its published\n+ counts and child-width multiplicities (`certificates/external/pr24-bit-network.json`), check the rank sum\n+ and deficit, and certify `a_b = 4788949/(4*10^11)` with our own moment bisection;\n+- PR #7's complex network at `h=28`, fully batched, with **complex source frames**\n+ (`notes/complex-source-frames.tex`): starting each stage-two auxiliary role in the phase frame of `D0`\n+ merges its entrance and exit into one child of rank `m-h`. Our histogram certifies\n+ `a_c = 4079603/(2.5*10^11)`, more than the bit side needs. PR #21 contains the same translation,\n+ independently and in a more complete form.\n+\n+The same script also reports a witness using only our own bit side: the two-stage interchange with\n+**data-edge batching** (`notes/data-edge-batching.tex`, `independent/two-stage-bit`). Both stage-two data\n+entrances have idempotent difference `Q1 (x) Q2`, of rank `(h-1)^2 > m/2`, so the partial-swap batching\n+lemma applies to them too; at `h=47` this certifies `a_b = 10033/10^9` and `kappa = 1003289933971/10^17`.\n+\n+## Round three (previous witness, `13086957581/(3.125*10^15)`)\n+\n+`notes/round3-combination.tex` assembles the witness from four components:\n+\n+- the stack below, which drives `eps` toward 1;\n+- a batched two-stage bit interchange, using the partial-swap batching lemma in\n+ `notes/partial-swap-batching.tex` (`a_b = 22157/(5*10^9)`);\n+- PR #7's complex network at `h=28`, fully batched as in PR #15 (every residual edge is one\n+ whole-residual child), rebuilt and certified independently in `independent/complex-network`\n+ (`a_c = 1048009/(2.5*10^11)`; this side binds);\n+- a coefficient-depth guard that needs no path-topology assumption.\n+\n+`scripts/certificate_round3.py` checks every row and constraint exactly.\n+\n+## The ceiling and how this gets past it\n+\n+After the recent pull requests, every witness is capped at about half the\n+bit-network saving, `kappa < a_b/2`. Three costs each tie a saving to either the\n+number of axes `d` or the axis width `l`, and `d*l ~ log n`:\n+\n+- the butterflies save on `d`;\n+- the chunk layout and the axis layout save on `l`.\n+\n+On top of that, the Gaussian precision budget `~8d^2` must fit in `O(log n)`.\n+\n+Five changes remove those caps.\n+\n+| Change | What it does | Note |\n+| --- | --- | --- |\n+| D. Longer digits | Digits of `(log n)^(1+x)` bits separate the precision budget from the address length. The volume stays `Theta(n)`. | `notes/stack-notes.tex` \u00a71 |\n+| B. Segmented inverse | Inside any wrap-free block, the Gaussian correction `N` is exactly `D_c T_c D_c^{-1}` for any centre `c`, and every `T_c` is a geometric rescaling of one Toeplitz matrix. Recentred sub-blocks keep the chirp precision bounded. Gohberg\u2013Semencul inverts each block, and Woodbury couples the cuts and wraps. With oversampling `1/(4 d L^eps)`, this replaces PR #5's `O(d)` Neumann terms per output (its counts are at most `30d`; the burn-in alone is about `1/theta = 4d`) with `O(1)` work per output. | `notes/segmented-inverse.tex` |\n+| C. One chunk per axis | `K = l - 1` is possible once compact controls remove the `K^tau` factor. The transform layout then needs no exchanges. | `notes/stack-notes.tex` \u00a72 |\n+| A. Fine-bit exposure | Only `O(log L)` low bits of an axis move innermost for resampling. The line passes stream over slabs. | `notes/stack-notes.tex` \u00a73 |\n+| E'. Permuted selected-bit swaps | Colkitt's selected-bit addition with a permuted pairing reverses the CRT axis order at cost `l (d log p)^tau`. | `notes/stack-notes.tex` \u00a74 |\n+\n+Only the combination moves the headline. D alone, for example, leaves PR #5's\n+Gaussian row capping `eps < 1/2`. The binding constraint is now the butterfly row,\n+`eps(1-lambda')`, at `eps = 0.9999`.\n+\n+## Evidence and scope\n+\n+| Component | Evidence |\n+| --- | --- |\n+| Parameters, margins, side constraints | Exact rational certificate (`scripts/certificate.py`) with negative controls |\n+| Closed form `X = n(n+2 beta_j)`, segment and recentred factorisations, cross-wrap bound `X >= 2` | Exact rational checks on five `(s,t)` pairs (`scripts/check_identities.py`) |\n+| Segmented inverse | Written proof (`notes/segmented-inverse.tex`); 260-digit comparisons against a direct solve, with cyclic indices, for whole segments (`scripts/check_segmented_inverse.py`), recentred sub-blocks (`scripts/check_subblock_inverse.py`), and the reuse path, which uses one stored inverse rescaled per block, elimination without pivoting, and a fixed-point negative control that must fail (`scripts/check_reuse_inverse.py`) |\n+| A, C, D, E' | Written arguments, each attacked by a refute-by-default check, with the resulting fixes in the notes |\n+| Prior results from PR #3, #5 and #7 on integer-mult-bounds (networks, chirped Gaussian lemma) | Assumed, and unmerged there. We recomputed PR #7's W, m, N, L, s, eta and their complex counterparts exactly from its formulas. An independent re-implementation (`independent/pr7-role-counts`, `make roles`) reproduces its h=28 role counts, 11840940 and 93838, exactly. The finite-alphabet version of the interchange lemmas that its ternary payloads need is proved in `notes/stack-notes.tex`, Appendix A. |\n+| Partial-swap batching (bit side) | Written proof (`notes/partial-swap-batching.tex`); exact Bruhat profiles on random, sparse and adversarial idempotents, and two-stage frames at h=6,7,8 (`independent/partial-swap`) |\n+| Fully batched complex saving | Independent rebuild of PR #7's producer, exact label checks (0 bad edges at h=28), the residual rank of every edge with an exact sum check against s, and a certified moment bisection (`independent/complex-network`) |\n+| PR #24's bit network | Its published counts and child-width multiplicities, pinned by commit and SHA-256; we check that the widths sum to the total rank, the deficit, and that every child is narrower than m, and certify the moment ourselves. We also re-derived its frame identities and confirmed it is compatible with our stack (separate bit and complex arities, crude guard, payload and prime choice); its producers and common basis are assumed |\n+| Data-edge batching (bit side) | Written proof (`notes/data-edge-batching.tex`): closed form `Q1 (x) Q2` checked in exact rationals; corners invertible under one common basis for every auxiliary edge and every data pair at h=6,7,8 (all 3136 pairs at h=8, `corners.py`); exact Bruhat profiles (`bruhat8.py`) |\n+| Two-stage side circuit at h=47 | Our generator (`independent/two-stage-bit/sidegen.py`) reproduces the published h=32 count, 123157, and an exact checker (`checkside.py`) verifies supports, disjoint children, common points and every output at h=28 to 50; `moment.py` builds the child histogram role by role and checks it sums to s |\n+| Complex source frames | Written proof (`notes/complex-source-frames.tex`); exact label and phase checks of every endpoint case (`independent/complex-network/sourceframe_labels.py`); a three-stage scalar simulation of PR #7's network with source frames, arbitrary scratch and a negative control (`sourceframe_sim.py`); the histogram option `sf` keeps the exact rank sum s |\n+| Round-seven bit side (deferred readouts, V leaves, lifted frames, late copies) | Frozen schedule and frames (`certificates/round7/`); stdlib replays over F2 and Z with arbitrary scratch, exact frame checks over Q, side lemma at one integer point, histogram rebuilt from the schedule, negative controls (`independent/deferred-readout/`); Lean kernel check of the moment certificates and assembly. Stage two as the complement time-reversal of stage one is assumed |\n+| Topology-free guard | Written argument (docstring of `scripts/certificate_round3.py`); the witness is stated with this guard |\n+| Prior results from PR #10, #13 and #15, and the two-stage motif | Assumed. We reproduced their rank moments, certified at least PR #15's fully batched saving from our own histogram, and found controlled-basis witnesses for PR #10 at h=8 to 14 |\n+| Full upstream multiplication theorem | Assumed |\n+| Independent review / formalisation | Not supplied |\n+\n+## Reproduce\n+\n+Requires Python 3.9 or newer, standard library only.\n+\n+```sh\n+python3 independent/complex-network/fullbatch_hist.py 28 /tmp/fb28sf.json sf # ~4 min\n+python3 scripts/certificate_round4.py /tmp/fb28sf.json\n+python3 independent/two-stage-bit/checkside.py 47\n+make verify # exact checks, numerical inverse checks, certificate, tests\n+make roles # independent recount of PR #7's role counts (clang++, ~1 GB)\n+make round7 # round-seven certificate and checks (~25 min)\n+make lean # Lean 4 kernel checks of rounds five to seven\n+make notes # PDF notes (tectonic)\n+```\n+\n+The PDFs are in `artifacts/`.\n+\n+## Attribution\n+\n+Author: **Swapnil Jain**. Research, implementation and drafting were done with\n+assistance from Claude (Anthropic). This builds on OpenAI's manuscript and Douglas\n+Colkitt's framework. It also uses published results from open pull requests on\n+Colkitt's repository, cited in `NOTICE`; those are citations of prior work, not\n+collaborators. Licensed under Apache-2.0." + }, + { + "sha": "68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0", + "filename": "research/deferred-signed/swapnil-round7/artifacts/complex-source-frames.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcomplex-source-frames.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcomplex-source-frames.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcomplex-source-frames.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "c290bc5431382e6af840895e6892fba1dc165c7a", + "filename": "research/deferred-signed/swapnil-round7/artifacts/copied-centres.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcopied-centres.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcopied-centres.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fcopied-centres.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "cb94268721cc71fe42eb54c76b43fff566492d37", + "filename": "research/deferred-signed/swapnil-round7/artifacts/data-edge-batching.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdata-edge-batching.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdata-edge-batching.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdata-edge-batching.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "7aa9fb30817c371cc2b9a717965925168bf18e96", + "filename": "research/deferred-signed/swapnil-round7/artifacts/deferred-readout.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdeferred-readout.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdeferred-readout.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fdeferred-readout.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "ff5bd622016110694ff79aa283e25b52953d8832", + "filename": "research/deferred-signed/swapnil-round7/artifacts/fine-field-lemma.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Ffine-field-lemma.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Ffine-field-lemma.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Ffine-field-lemma.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5", + "filename": "research/deferred-signed/swapnil-round7/artifacts/flag-basis.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fflag-basis.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fflag-basis.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fflag-basis.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "a03f30c451a2baf59a69f8d5b30d12687f9ffdfc", + "filename": "research/deferred-signed/swapnil-round7/artifacts/partial-swap-batching.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fpartial-swap-batching.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fpartial-swap-batching.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fpartial-swap-batching.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "0706f9d115468ca9314c47503b190346be67a0c9", + "filename": "research/deferred-signed/swapnil-round7/artifacts/round3-combination.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fround3-combination.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fround3-combination.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fround3-combination.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "65a2e177778547c4029570aee05237d1e69dcf3d", + "filename": "research/deferred-signed/swapnil-round7/artifacts/segmented-inverse.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fsegmented-inverse.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fsegmented-inverse.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fsegmented-inverse.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "827f07e6b5be63d903f8f5becc1a57cf99355db0", + "filename": "research/deferred-signed/swapnil-round7/artifacts/stack-notes.pdf", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fstack-notes.pdf", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fstack-notes.pdf", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fartifacts%2Fstack-notes.pdf?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "4e212f628196ee434aa67b09a1cedcd8d4d72e85", + "filename": "research/deferred-signed/swapnil-round7/certificates/external/pr24-bit-network.json", + "status": "added", + "additions": 138, + "deletions": 0, + "changes": 138, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fexternal%2Fpr24-bit-network.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fexternal%2Fpr24-bit-network.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fexternal%2Fpr24-bit-network.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,138 @@\n+{\n+ \"source\": {\n+ \"repository\": \"github.com/CrocSwap/integer-mult-bounds pull request #24 (icekylinx)\",\n+ \"commit\": \"ed90fd940279c336ebc45968631bdebfb087b505\",\n+ \"file\": \"certificates/endpoint-gauge-network.json\",\n+ \"sha256\": \"0ccbc892174915e3a7559cc116eaf42b288dae4d933b1332520e0710ffff5f96\",\n+ \"license\": \"Apache-2.0\",\n+ \"extract\": \"bit side: counts and child-width multiplicities only\"\n+ },\n+ \"counts\": {\n+ \"B1\": 4680040601600,\n+ \"B2\": 4642714752000,\n+ \"B3\": 4813691904000,\n+ \"E\": 133651302400,\n+ \"L\": 113840729600,\n+ \"N\": 198959488000,\n+ \"W\": 9854325632000,\n+ \"deficit\": 170237516800,\n+ \"dimensions\": [\n+ 32,\n+ 30,\n+ 40\n+ ],\n+ \"m\": 38400,\n+ \"singletons\": 629339590854400,\n+ \"total_rank\": 378405934031283200\n+ },\n+ \"child_width_multiplicities\": [\n+ [\n+ 1,\n+ 629339590854400\n+ ],\n+ [\n+ 2,\n+ 520055584000\n+ ],\n+ [\n+ 4,\n+ 535654515200\n+ ],\n+ [\n+ 6,\n+ 537511296000\n+ ],\n+ [\n+ 8,\n+ 583899225600\n+ ],\n+ [\n+ 10,\n+ 550774176000\n+ ],\n+ [\n+ 12,\n+ 522502086400\n+ ],\n+ [\n+ 14,\n+ 617933335200\n+ ],\n+ [\n+ 16,\n+ 644506096800\n+ ],\n+ [\n+ 18,\n+ 763624344000\n+ ],\n+ [\n+ 20,\n+ 652872441600\n+ ],\n+ [\n+ 22,\n+ 689629485600\n+ ],\n+ [\n+ 24,\n+ 1691371634400\n+ ],\n+ [\n+ 26,\n+ 1558994438400\n+ ],\n+ [\n+ 28,\n+ 1018295520000\n+ ],\n+ [\n+ 30,\n+ 5192627235200\n+ ],\n+ [\n+ 32,\n+ 342595792000\n+ ],\n+ [\n+ 34,\n+ 1125691840000\n+ ],\n+ [\n+ 36,\n+ 283134656000\n+ ],\n+ [\n+ 38,\n+ 796643456000\n+ ],\n+ [\n+ 40,\n+ 134456806400\n+ ],\n+ [\n+ 838,\n+ 397918976000\n+ ],\n+ [\n+ 882,\n+ 397918976000\n+ ],\n+ [\n+ 36402,\n+ 397918976000\n+ ],\n+ [\n+ 38256,\n+ 4680040601600\n+ ],\n+ [\n+ 38320,\n+ 133651302400\n+ ],\n+ [\n+ 38340,\n+ 4642714752000\n+ ]\n+ ]\n+}\n\\ No newline at end of file" + }, + { + "sha": "a87f969d341e04fa60fd48eff7cbd639bda955b1", + "filename": "research/deferred-signed/swapnil-round7/certificates/identities.json", + "status": "added", + "additions": 62, + "deletions": 0, + "changes": 62, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fidentities.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fidentities.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fidentities.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,62 @@\n+[\n+ {\n+ \"s\": 113,\n+ \"t\": 128,\n+ \"theta\": \"15/113\",\n+ \"checks\": {\n+ \"closed_form\": 20340,\n+ \"segment\": 2226,\n+ \"cross\": 18114,\n+ \"recentred\": 4914\n+ },\n+ \"min_cross_exponent\": \"228/113\"\n+ },\n+ {\n+ \"s\": 241,\n+ \"t\": 256,\n+ \"theta\": \"15/241\",\n+ \"checks\": {\n+ \"closed_form\": 43380,\n+ \"segment\": 10896,\n+ \"cross\": 32484,\n+ \"recentred\": 28620\n+ },\n+ \"min_cross_exponent\": \"484/241\"\n+ },\n+ {\n+ \"s\": 1009,\n+ \"t\": 1024,\n+ \"theta\": \"15/1009\",\n+ \"checks\": {\n+ \"closed_form\": 181620,\n+ \"segment\": 139770,\n+ \"cross\": 41850,\n+ \"recentred\": 411030\n+ },\n+ \"min_cross_exponent\": \"2020/1009\"\n+ },\n+ {\n+ \"s\": 1019,\n+ \"t\": 1024,\n+ \"theta\": \"5/1019\",\n+ \"checks\": {\n+ \"closed_form\": 183420,\n+ \"segment\": 169470,\n+ \"cross\": 13950,\n+ \"recentred\": 505650\n+ },\n+ \"min_cross_exponent\": \"2040/1019\"\n+ },\n+ {\n+ \"s\": 4093,\n+ \"t\": 4096,\n+ \"theta\": \"3/4093\",\n+ \"checks\": {\n+ \"closed_form\": 736740,\n+ \"segment\": 728370,\n+ \"cross\": 8370,\n+ \"recentred\": 2183454\n+ },\n+ \"min_cross_exponent\": \"8188/4093\"\n+ }\n+]\n\\ No newline at end of file" + }, + { + "sha": "4a4431bd425aa4499f25e67df4e0d2cddd7df15c", + "filename": "research/deferred-signed/swapnil-round7/certificates/round7/deferred_23.json.gz", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fdeferred_23.json.gz", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fdeferred_23.json.gz", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fdeferred_23.json.gz?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "3d86f83b871ba07c3b1562aa6d953ae86b9750ba", + "filename": "research/deferred-signed/swapnil-round7/certificates/round7/witness_23.json.gz", + "status": "added", + "additions": 0, + "deletions": 0, + "changes": 0, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fwitness_23.json.gz", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fwitness_23.json.gz", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fround7%2Fwitness_23.json.gz?ref=cbb05ce504d571546d9b7794c186a613c659c3bf" + }, + { + "sha": "94339ac381b3a3eea3f5edfb0638bbd06d617282", + "filename": "research/deferred-signed/swapnil-round7/certificates/witness.json", + "status": "added", + "additions": 32, + "deletions": 0, + "changes": 32, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fwitness.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fwitness.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fcertificates%2Fwitness.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,32 @@\n+{\n+ \"kappa\": \"7499/1000000000000\",\n+ \"kappa_float\": 7.499e-09,\n+ \"min_margin\": \"374952501/50000000000000000\",\n+ \"gap\": \"2501/50000000000000000\",\n+ \"binding\": \"simultaneous butterflies\",\n+ \"c1\": \"24189/10000\",\n+ \"constraints\": {\n+ \"lambda above tau, sigma, chi\": \"1/10000000000000\",\n+ \"lambda_prime above lambda\": \"1/10000000000000\",\n+ \"lambda_prime above leaf\": \"60001/5000000000000\",\n+ \"lambda_prime below one\": \"37499/5000000000000\",\n+ \"guard: eps C1 < 1 + x\": \"158134189/100000000\",\n+ \"precision: 2 eps + y < 1 + x\": \"10003/10000\",\n+ \"sub-block coupling: y >= eps\": \"1\",\n+ \"reservations below layer: (2eps-1)/eps < lambda_prime\": \"4999625047499/49995000000000000\",\n+ \"record regime: eps < 1\": \"1/10000\",\n+ \"delta < 1/8\": \"124999/1000000\",\n+ \"prime intervals via PNT: eps < 1\": \"1/10000\"\n+ },\n+ \"margins\": {\n+ \"prefix moves and top individual round\": \"1/10000\",\n+ \"simultaneous butterflies\": \"374952501/50000000000000000\",\n+ \"fine-bit exposures (A)\": \"3/31250\",\n+ \"Gaussian maps (B)\": \"3/31250\",\n+ \"chirps, twists, scalar products\": \"3/31250\",\n+ \"packed polynomial products\": \"9999/10000\",\n+ \"individually processed reserved axes\": \"3/31250\",\n+ \"CRT axis reversal, best of E and pairwise swaps\": \"29997/4000000000000\"\n+ },\n+ \"assumptions\": \"PR #7 networks (a_b=3/(4*10^8), a_c=39/10^9); pinned upstream interfaces\"\n+}\n\\ No newline at end of file" + }, + { + "sha": "95a5da44ed26c34d3cb8dec581894a873ab5ade3", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/README.md", + "status": "added", + "additions": 22, + "deletions": 0, + "changes": 22, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,22 @@\n+# Fully batched complex saving of the PR #7 network\n+\n+An independent rebuild of the complex side used by the round-three witness:\n+\n+- `side.py`: the PR #7 complex producer (pieces, pair stars, optional PR #4 retained totals).\n+- `labels.py`: exact binary label checks over F2^h for every edge of the producer.\n+- `roles.py`: role-level compile (addition, piece and retained-total slots).\n+- `fullbatch_hist.py`: the three-stage invocation schedule with h+1 centre wires; it records the rank of\n+ every nonzero residual edge and checks that the ranks sum to s exactly.\n+- `fullbatch_cert.py`: treats every residual edge as one whole-residual child (PR #15's full batching),\n+ certifies a_c by exact bisection on the moment equation with certified upper bounds on ln (`bc.py`),\n+ reports the path bound, and evaluates kappa with `scripts/certificate_round3.py`.\n+\n+```sh\n+python3 fullbatch_hist.py 28 /tmp/fb28.json # ~4 min; label check, ranks, sum_ok\n+python3 fullbatch_cert.py /tmp/fb28.json\n+```\n+\n+At h=28 (m = 21952, R = 93867 with the centre wires, s = 45772350635112192) the labels check has 0 bad\n+edges, the rank sum equals s, and the certified saving is a_c = 1048009/(2.5*10^11) ~ 4.192e-6. With the\n+batched two-stage bit interchange (a_b = 22157/(5*10^9)) this gives kappa = 13086957581/(3.125*10^15)\n+~ 4.1878e-6 under both guards, with the simultaneous butterflies binding." + }, + { + "sha": "53e00de297d6f693c19c88425292647f594dac63", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/bc.py", + "status": "added", + "additions": 21, + "deletions": 0, + "changes": 21, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fbc.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fbc.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fbc.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,21 @@\n+\"\"\"Certified bounds on exp and ln, in exact rationals.\"\"\"\n+from fractions import Fraction as Q\n+from math import comb\n+from decimal import Decimal as D, getcontext\n+getcontext().prec = 80\n+\n+def exp_lower(U, k=10, terms=30):\n+ # positive Taylor partial sum of exp(U/2^k), squared k times, rounded down: rigorous lower bound\n+ x = U / 2**k; s = Q(0); t = Q(1)\n+ for j in range(1, terms): s += t; t = t * x / j\n+ for _ in range(k):\n+ s = s * s; s = Q(s.numerator * 10**40 // s.denominator, 10**40)\n+ return s\n+\n+def ln_upper(x, rel=Q(1, 10**9)):\n+ # rational U with exp(U) > x (so U > ln x), within ~rel of ln x\n+ lx = D(x.numerator).ln() - D(x.denominator).ln()\n+ den = 10**12\n+ U = Q(int(lx * den) + 1, den) * (1 + rel)\n+ assert exp_lower(U) > x\n+ return U" + }, + { + "sha": "103bbb7d271c2bfd05206a35aabd14986eaf9c0e", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_cert.py", + "status": "added", + "additions": 41, + "deletions": 0, + "changes": 41, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Ffullbatch_cert.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Ffullbatch_cert.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Ffullbatch_cert.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,41 @@\n+\"\"\"Certified fully batched complex saving from a residual histogram, and kappa on our stack with the\n+batched two-stage bit interchange (a_b = 22157/(5*10^9)).\"\"\"\n+import sys, json, math, os\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, HERE); sys.path.insert(0, os.path.join(HERE, '..', '..', 'scripts'))\n+from fractions import Fraction as Q\n+from bc import ln_upper, exp_lower\n+from certificate_round3 import evaluate\n+\n+def ln_up(x): # certified U > ln x, tight\n+ return ln_upper(Q(x), rel=Q(1,10**13))\n+\n+def cert(hist,W,m,s,grid=10**12):\n+ ws=[(Q(r*c,W*m), ln_up(Q(m,r))) for r,c in hist.items()]\n+ assert sum(r*c for r,c in hist.items())==s\n+ mom=lambda a: sum(w/(1-a*U) for w,U in ws)\n+ lo,hi=0,10**8\n+ assert mom(Q(hi,grid))>1\n+ while hi-lo>1:\n+ mid=(lo+hi)//2\n+ if all(Q(mid,grid)*U<1 for _,U in ws) and mom(Q(mid,grid))<1: lo=mid\n+ else: hi=mid\n+ return Q(lo,grid), 1-mom(Q(lo,grid))\n+\n+def sqrt_up(x,g=10**12):\n+ n=math.isqrt(x.numerator*g*g//x.denominator)+1; r=Q(n,g); assert r*r>x; return r\n+\n+def path_bound(m,h,A):\n+ q=m+6*h; assert Adim: s.desc.append(o-dim)\n+ s.dim[r]=dim\n+\n+def invocation(c,k,dims,stage,inverse,sf=False):\n+ h=c.h; m=h**3; v=len(c.triples); R=k['size']\n+ x={t:i for i,t in enumerate(c.triples)}; y={t:v+i for i,t in enumerate(c.triples)}\n+ side=lambda sl:2*v+sl\n+ ncent=h+1\n+ cent=tuple(range(2*v+R,2*v+R+ncent))\n+ a=h**(stage-1); low,high=(a-1)*h,a*h\n+ tr=Trace([a]*v+[a-1]*v+[h if stage==3 else 0]*(R+ncent))\n+ # Source frames (stage two only, notes/complex-source-frames.tex): an auxiliary role starts in D0, of dim\n+ # low, and its exit child to the sink wt+q_D0 has rank (m+low) - last dim. Input-pivot slots are left\n+ # at source 0: their first stage-two gate is the copy in the data frame, not a frame above D0, so\n+ # starting them at D0 would charge a descent and break the rank sum.\n+ keep=set(k['src'].values())|set(k['rout'].values())\n+ sfr={2*v+sl for sl in range(R) if sf and stage==2 and sl not in keep}\n+ for r in sfr: tr.dim[r]=low\n+ pieces={t:[] for t in c.triples}\n+ for i,sl in k['pout'].items(): pieces[c.pieces[i][0]].append(side(sl))\n+ def mix(md,rev=False):\n+ for n,ins,outs in (reversed(k['gates']) if rev else k['gates']):\n+ f={'low':low,'high':high,'label':low+dims[n],'complement':high-dims[n]}[md]\n+ tr.gate([side(q) for q in ins+outs],f)\n+ def inject(b,f):\n+ for t in c.triples: tr.gate([b[t]]+pieces[t],f)\n+ def copy(b,f):\n+ for t,sl in k['src'].items(): tr.gate((b[t],side(sl)),f)\n+ def central(b,f): tr.gate(tuple(b.values())+cent,f)\n+ if True:\n+ if not inverse:\n+ mix('low'); inject(y,low); mix('low',True); central(y,low)\n+ copy(x,low+1); central(x,high); central(y,low)\n+ mix('label'); inject(y,high-1); mix('high',True)\n+ central(x,high); copy(x,high)\n+ else:\n+ copy(y,a-1); central(y,low); mix('low'); inject(x,low+1)\n+ mix('complement',True); central(x,high); central(y,low)\n+ copy(y,high-1); central(x,high); mix('high'); inject(x,high)\n+ mix('high',True)\n+ for r in x.values(): tr.gate((r,),high)\n+ for r in y.values(): tr.gate((r,),high-1)\n+ for r in range(2*v,len(tr.dim)): tr.gate((r,),(m+low) if r in sfr else (h if stage==1 else m))\n+ return tr.hist, tr.desc\n+\n+def run(h,sf=False):\n+ c=Side(h)\n+ k=compile_roles(c); ch=Checker(c); chk=ch.run()\n+ dims={n:len(ch.label(n)) for n in c.active}\n+ H=Counter(); D=[]\n+ for st,inv in ((1,False),(2,True),(3,False)):\n+ hh,dd=invocation(c,k,dims,st,inv,sf); H.update(hh); D.append(sorted(Counter(dd).items()))\n+ v=len(c.triples); m=h**3; N=v**3; Rb=k['size']+h+1\n+ loss=h*(h+1)\n+ W=2*N+2*v*v*Rb; L=3*v*v*loss; s=W*m-2*N+2*L\n+ hist={r:n*v*v for r,n in sorted(H.items())}\n+ tot=sum(r*n for r,n in hist.items())\n+ return dict(h=h,checker=chk,R=Rb,W=W,s=s,m=m,sum_ok=(tot==s),tot=tot,desc=D,hist=hist)\n+\n+if __name__=='__main__':\n+ h=int(sys.argv[1]); out=sys.argv[2] if len(sys.argv)>2 else f'/tmp/fullbatch_hist_{h}.json'\n+ r=run(h,sf=len(sys.argv)>3 and sys.argv[3]=='sf')\n+ json.dump({**r,'hist':{str(a):b for a,b in r['hist'].items()}},open(out,'w'))\n+ print({k:v for k,v in r.items() if k!='hist'}); print(r['hist'])" + }, + { + "sha": "ec70ed13a59851c16202665dd34f667fde54708d", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/labels.py", + "status": "added", + "additions": 94, + "deletions": 0, + "changes": 94, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Flabels.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Flabels.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Flabels.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,94 @@\n+\"\"\"Exact binary label checks over F2^h (dot product) for a Side circuit.\n+labels: input -> ; node whose triples share one common pair and >=2 triples\n+-> span of its indicators (pair-star label); otherwise coordinate space of covered points.\"\"\"\n+import sys\n+from side import Side\n+\n+def echelon(vs):\n+ b={}\n+ for x in vs:\n+ for p,y in b.items():\n+ if x&p: x^=y\n+ if not x: continue\n+ p=x&-x\n+ for q in list(b):\n+ if b[q]&p: b[q]^=x\n+ b[p]=x\n+ return b\n+def red(b,x):\n+ for p,y in b.items():\n+ if x&p: x^=y\n+ return x\n+def dot(a,b): return bin(a&b).count('1')&1\n+def perp_in(V,U):\n+ \"\"\"basis of V \u2229 U^perp (V,U lists of basis vectors)\"\"\"\n+ k=len(U); rows=[]\n+ for i,v in enumerate(V):\n+ rows.append((sum(dot(v,u)<>i&1: x^=v\n+ out.append(x)\n+ return out\n+def nondeg(B):\n+ g=[sum(dot(a,b)<=2: B=list(echelon([s.tvec(i) for i in idx]).values()); assert len(B)==len(idx)\n+ else: X=c.cover(n); B=[1<

>p&1]\n+ B=sorted(echelon(B).values()); assert nondeg(B); s.lab[n]=B; return B\n+ def edge(s,U,V):\n+ key=(tuple(U),tuple(V))\n+ if key not in s.cache:\n+ bV=echelon(V); good=all(red(bV,u)==0 for u in U)\n+ s.cache[key]=good and ok_res(perp_in(V,U))\n+ return s.cache[key]\n+ def run(s):\n+ c=s.c; bad=0; n_e=0\n+ F=[1<

) perp ( (x) L (x) ),\n+so D0 = V(0), D1 = V(F). For an aux role with source frame q_D0 and sink frame wt + q_D0:\n+ entrance q_{V(L1)} - q_D0 should equal q_{(x)L1(x)} (rank dim L1)\n+ exit wt + q_D0 - q_{V(L2)} should equal q_G, G = D0 perp V(L2)^perp (rank m - dim L2)\n+G must be nondegenerate and nonalternating (orthonormal basis). Checked at random y, plus ranks.\"\"\"\n+import sys, random\n+from itertools import combinations\n+h = int(sys.argv[1]); m = h**3; rnd = random.Random(h)\n+def idx(i, j, k): return (i * h + j) * h + k\n+def tens(a, b, c): # bit vectors over F_2^h -> F_2^m\n+ x = 0\n+ for i in range(h):\n+ if a >> i & 1:\n+ for j in range(h):\n+ if b >> j & 1:\n+ for k in range(h):\n+ if c >> k & 1: x |= 1 << idx(i, j, k)\n+ return x\n+def dot(x, y): return bin(x & y).count('1') & 1\n+def span_basis(vs):\n+ b = {}\n+ for x in vs:\n+ for piv, y in b.items():\n+ if x >> piv & 1: x ^= y\n+ if x:\n+ piv = x.bit_length() - 1\n+ for q in list(b):\n+ if b[q] >> piv & 1: b[q] ^= x\n+ b[piv] = x\n+ return list(b.values())\n+class Proj:\n+ \"\"\"orthogonal projection onto span(basis) for the dot form; asserts nondegenerate\"\"\"\n+ def __init__(s, B):\n+ s.B = B; n = len(B)\n+ G = [sum(dot(a, b) << j for j, b in enumerate(B)) | (1 << (n + i)) for i, a in enumerate(B)]\n+ for col in range(n): # invert Gram (symmetric) by Gauss-Jordan\n+ r = next((r for r in range(col, n) if G[r] >> col & 1), None)\n+ assert r is not None, 'degenerate'\n+ G[col], G[r] = G[r], G[col]\n+ for rr in range(n):\n+ if rr != col and G[rr] >> col & 1: G[rr] ^= G[col]\n+ s.Gi = [g >> n for g in G]\n+ def __call__(s, x):\n+ c = sum(dot(b, x) << j for j, b in enumerate(s.B)); out = 0\n+ for i, b in enumerate(s.B):\n+ if bin(s.Gi[i] & c).count('1') & 1: out ^= b\n+ return out\n+def q(P, x): return bin(P(x)).count('1') % 4\n+def perp(B, n=m):\n+ \"\"\"basis of complement of span(B) in F_2^m (B nondegenerate): kernel of x -> (b.x)\"\"\"\n+ rows = list(B); piv = []\n+ # solve: vectors x with b.x=0 for all b; use reduced rows\n+ R = span_basis(rows); pivs = {r.bit_length() - 1: r for r in R}\n+ out = []\n+ for f in range(n):\n+ if f in pivs: continue\n+ x = 1 << f\n+ for pv, r in pivs.items():\n+ if dot(r, x): x ^= 1 << pv # r has its leading bit pv; adjust coordinate pv\n+ out.append(x)\n+ assert all(dot(r, x) == 0 for r in R for x in out) and len(out) == n - len(R)\n+ return out\n+T = [sum(1 << i for i in t) for t in combinations(range(h), 3)]\n+Fh = (1 << h) - 1\n+units = [1 << i for i in range(h)]\n+ok = True\n+for trial in range(3):\n+ tA, tB = rnd.choice(T), rnd.choice(T)\n+ Aperp = [u ^ (tA if dot(u, tA) else 0) for u in units] # spans t_A^perp (h-1 dim)\n+ Aperp = span_basis(Aperp)\n+ D0 = span_basis([tens(a, u, tB) for a in Aperp for u in units]); assert len(D0) == (h - 1) * h\n+ t = rnd.choice(T); tperp = span_basis([u ^ (t if dot(u, t) else 0) for u in units])\n+ cases = {'L=F (generic aux)': units, 'L=t^perp (piece)': tperp, 'L=0 (retained)': [], 'L=': [t]}\n+ PD0 = Proj(D0)\n+ ys = [rnd.getrandbits(m) for _ in range(20)]\n+ for name, L in cases.items():\n+ E = [tens(tA, l, tB) for l in L]\n+ V = D0 + E\n+ PV = Proj(V); PE = Proj(E) if E else (lambda x: 0)\n+ G = span_basis(D0 + perp(V)); PG = Proj(G)\n+ nonalt = any(dot(g, g) for g in G)\n+ ent = all((q(PV, y) - q(PD0, y) - (q(PE, y) if E else 0)) % 4 == 0 for y in ys)\n+ ex = all((bin(y).count('1') + q(PD0, y) - q(PV, y) - q(PG, y)) % 4 == 0 for y in ys)\n+ print(h, trial, name, 'dimV', len(V), 'entrance rank', len(E), 'entrance phase ok', ent,\n+ '| exit rank dim G', len(G), '= m-dimL', len(G) == m - len(L), 'nondeg+nonalt', nonalt,\n+ 'exit phase ok', ex, flush=True)\n+ ok &= ent and ex and nonalt and len(G) == m - len(L)\n+print('ALL OK', ok)" + }, + { + "sha": "ca684ec9badd9f4305d584f4786f6042d35b87e3", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_sim.py", + "status": "added", + "additions": 157, + "deletions": 0, + "changes": 157, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_sim.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_sim.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_sim.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,157 @@\n+\"\"\"Three-stage scalar simulation of the complex exchange with auxiliary source frames (PR #7 network).\n+\n+Network: side.Side(h) with roles.compile_roles, plus h+1 centre wires, under the PR #7 schedule\n+(fullbatch_hist.invocation): forward L,-J,L^-1,-R,V,G,R,L,J,L^-1,G^-1,V^-1 gives y <- y+x, the inverse\n+V,G,L,-J,L^-1,-R,G^-1,V^-1,R,L,J,L^-1 gives x <- x-y; stages forward/inverse/forward give the exchange.\n+\n+All phase frames D_phi = H^(x)m diag(i^phi) H^(x)m are diagonal in the Hadamard basis and every gate is a\n+scalar combination of wires, so the network is checked pointwise at a random y in F_2^m (m = h^3), exactly\n+mod p = 2^64-59 with i = sqrt(-1). Each gate gets an independent random common phase, data endpoints get\n+random phases and scratch is arbitrary. Scratch endpoints:\n+ stage-1/3 banks (shared between the stages), centre wires, input-pivot and retained slots: source 0, sink wt\n+ other stage-two side roles: source q_D0, sink wt + q_D0, with D0 = t_A^perp (x) F (x) \n+Pass: every scratch wire leaves as i^wt times its physical input, X -> -Y and Y -> X with the endpoint phases.\n+Usage: python3 sourceframe_sim.py h [seeds] (run beside side.py and roles.py).\"\"\"\n+import os, sys, random\n+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\n+from side import Side\n+from roles import compile_roles\n+\n+p = (1 << 64) - 59\n+g = next(a for a in range(2, 100) if pow(a, (p - 1) // 2, p) == p - 1)\n+IU = pow(g, (p - 1) // 4, p); assert IU * IU % p == p - 1\n+IP = [pow(IU, k, p) for k in range(4)]\n+HALF = pow(2, p - 2, p)\n+\n+\n+def par(x): return bin(x).count('1') & 1\n+\n+\n+def qD0(h, y, tA, tB):\n+ \"\"\"wt(P_D0 y) mod 4 for D0 = t_A^perp (x) F (x) ; y[i][j] is an h-bit int over the third index.\"\"\"\n+ tot = 0\n+ for j in range(h):\n+ z = sum(par(y[i][j] & tB) << i for i in range(h))\n+ if par(z & tA): z ^= tA # project along the first index onto t_A^perp\n+ tot += 3 * bin(z).count('1') # each surviving (i,j) carries t_B, of weight 3\n+ return tot % 4\n+\n+\n+class Invocation:\n+ \"\"\"Framed scalar operations on one bank: side slots 0..R-1, centre wires R..R+h (index R+h is '*').\"\"\"\n+\n+ def __init__(s, c, k, rnd):\n+ s.c, s.k, s.rnd, s.h, s.R = c, k, rnd, c.h, k['size']\n+ s.pieces = {t: [] for t in c.triples}\n+ for i, sl in k['pout'].items():\n+ S, _, cf = c.pieces[i]; s.pieces[S].append((sl, cf * HALF % p)) # side map weights are +-1/2\n+ s.cent = {i: [t for t in c.triples if i in t] for i in range(s.h)}\n+\n+ def gate(s, cells):\n+ \"\"\"Bring every (values, key, frames) cell to one fresh random common phase.\"\"\"\n+ ph = s.rnd.randrange(4)\n+ for val, key, fr in cells:\n+ d = (ph - fr[key]) % 4\n+ if d: val[key] = val[key] * IP[d] % p\n+ fr[key] = ph\n+\n+ def L(s, b, sign):\n+ r, rf = b\n+ for n, ins, outs in (s.k['gates'] if sign > 0 else reversed(s.k['gates'])):\n+ s.gate([(r, q, rf) for q in set(ins + outs)])\n+ if sign > 0:\n+ if len(ins) == 2: r[ins[0]] = (r[ins[0]] + r[ins[1]]) % p\n+ for o in outs[1:]: r[o] = (r[o] + r[outs[0]]) % p\n+ else:\n+ for o in outs[1:]: r[o] = (r[o] - r[outs[0]]) % p\n+ if len(ins) == 2: r[ins[0]] = (r[ins[0]] - r[ins[1]]) % p\n+\n+ def J(s, b, tgt, sg): # one injection gate per target\n+ r, rf = b; tv, tf = tgt\n+ for S, terms in s.pieces.items():\n+ if not terms: continue\n+ s.gate([(r, sl, rf) for sl, _ in terms] + [(tv, S, tf)])\n+ tv[S] = (tv[S] + sg * sum(cf * r[sl] for sl, cf in terms)) % p\n+\n+ def V(s, b, src, sg): # copy gates\n+ r, rf = b; xv, xf = src\n+ for t, sl in s.k['src'].items():\n+ s.gate([(r, sl, rf), (xv, t, xf)]); r[sl] = (r[sl] + sg * xv[t]) % p\n+\n+ def central(s, b, d): # one central gate: all of one data bank and every centre wire\n+ r, rf = b; dv, df = d\n+ s.gate([(dv, t, df) for t in s.c.triples] + [(r, s.R + i, rf) for i in range(s.h + 1)])\n+\n+ def G(s, b, src, sg):\n+ r = b[0]; xv = src[0]; s.central(b, src)\n+ for i in range(s.h): r[s.R + i] = (r[s.R + i] + sg * sum(xv[t] for t in s.cent[i])) % p\n+ r[s.R + s.h] = (r[s.R + s.h] + sg * sum(xv.values())) % p\n+\n+ def Rc(s, b, tgt, sg):\n+ r = b[0]; tv = tgt[0]; s.central(b, tgt)\n+ for t in s.c.triples:\n+ tv[t] = (tv[t] + sg * (sum(r[s.R + i] for i in t) - r[s.R + s.h]) * HALF) % p\n+\n+ def forward(s, b, x, y):\n+ s.L(b, 1); s.J(b, y, -1); s.L(b, -1); s.Rc(b, y, -1); s.V(b, x, 1); s.G(b, x, 1)\n+ s.Rc(b, y, 1); s.L(b, 1); s.J(b, y, 1); s.L(b, -1); s.G(b, x, -1); s.V(b, x, -1)\n+\n+ def inverse(s, b, y, x):\n+ s.V(b, y, 1); s.G(b, y, 1); s.L(b, 1); s.J(b, x, -1); s.L(b, -1); s.Rc(b, x, -1)\n+ s.G(b, y, -1); s.V(b, y, -1); s.Rc(b, x, 1); s.L(b, 1); s.J(b, x, 1); s.L(b, -1)\n+\n+\n+def run(c, k, seed, src_frame=True, sink_ok=True):\n+ \"\"\"Returns (data ok, scratch ok, invocations with nonzero q_D0, stage-two invocations).\"\"\"\n+ rnd = random.Random(seed); h = c.h; T = c.triples; tm = {t: sum(1 << q for q in t) for t in T}\n+ y = [[rnd.getrandbits(h) for _ in range(h)] for _ in range(h)]\n+ wt = sum(bin(y[i][j]).count('1') for i in range(h) for j in range(h)) % 4\n+ I = Invocation(c, k, rnd); W = k['size'] + h + 1\n+ keep = set(k['src'].values()) | set(k['rout'].values()) | set(range(k['size'], W))\n+ keys = [(a, b, d) for a in T for b in T for d in T]\n+ X = {a: rnd.randrange(p) for a in keys}; Y = {a: rnd.randrange(p) for a in keys}\n+ Xf = {a: rnd.randrange(4) for a in keys}; Yf = {a: rnd.randrange(4) for a in keys}\n+ X0, Y0, Xf0, Yf0 = dict(X), dict(Y), dict(Xf), dict(Yf)\n+ psiX = {a: rnd.randrange(4) for a in keys}; psiY = {a: rnd.randrange(4) for a in keys}\n+\n+ def bank(ph):\n+ v = [rnd.randrange(p) for _ in range(W)]; return [v, list(ph), list(v)]\n+ b1 = {(A, B): bank([0] * W) for A in T for B in T}\n+ q0 = {(A, B): qD0(h, y, tm[A], tm[B]) for A in T for B in T}\n+ b2 = {AB: bank([0 if (sl in keep or not src_frame) else q for sl in range(W)]) for AB, q in q0.items()}\n+\n+ def stage(st, fixed, bk, inv):\n+ key = [lambda t: (t,) + fixed, lambda t: (fixed[0], t, fixed[1]), lambda t: fixed + (t,)][st]\n+ xv = {t: X[key(t)] for t in T}; xf = {t: Xf[key(t)] for t in T}\n+ yv = {t: Y[key(t)] for t in T}; yf = {t: Yf[key(t)] for t in T}\n+ if inv: I.inverse(bk[:2], (yv, yf), (xv, xf))\n+ else: I.forward(bk[:2], (xv, xf), (yv, yf))\n+ for t in T: X[key(t)], Xf[key(t)], Y[key(t)], Yf[key(t)] = xv[t], xf[t], yv[t], yf[t]\n+\n+ partner = lambda t: tuple(sorted((q + 1) % h for q in t)) # stage-three reuse of the stage-one banks\n+ for A in T:\n+ for B in T: stage(0, (A, B), b1[A, B], False)\n+ for A in T:\n+ for B in T: stage(1, (A, B), b2[A, B], True)\n+ for A in T:\n+ for B in T: stage(2, (B, partner(A)), b1[A, B], False)\n+\n+ def sink(val, fr, i, target): return val[i] * IP[(target - fr[i]) % 4] % p\n+ ok_s = all(sink(v, f, i, wt) == v0[i] * IP[wt] % p for v, f, v0 in b1.values() for i in range(W))\n+ for AB, (v, f, v0) in b2.items():\n+ framed = lambda i: src_frame and sink_ok and i not in keep\n+ ok_s &= all(sink(v, f, i, (wt + q0[AB]) % 4 if framed(i) else wt) == v0[i] * IP[wt] % p for i in range(W))\n+ ok_d = all(sink(X, Xf, a, psiX[a]) == (-Y0[a] * IP[(psiX[a] - Yf0[a]) % 4]) % p and\n+ sink(Y, Yf, a, psiY[a]) == X0[a] * IP[(psiY[a] - Xf0[a]) % 4] % p for a in keys)\n+ return ok_d, ok_s, sum(1 for q in q0.values() if q), len(q0)\n+\n+\n+if __name__ == '__main__':\n+ h = int(sys.argv[1]); seeds = int(sys.argv[2]) if len(sys.argv) > 2 else 3\n+ c = Side(h); k = compile_roles(c)\n+ print('h', h, 'side roles', k['size'], 'centre wires', h + 1, 'source-framed per invocation',\n+ k['size'] - len(set(k['src'].values()) | set(k['rout'].values())), flush=True)\n+ for seed in range(seeds):\n+ print('seed', seed, 'source frames: (data ok, scratch ok, nonzero q_D0, invocations)', run(c, k, seed), flush=True)\n+ print('negative control, sink wt only (scratch must fail):', run(c, k, 100, sink_ok=False), flush=True)\n+ print('baseline, no source frames (must pass):', run(c, k, 101, src_frame=False), flush=True)" + }, + { + "sha": "965b9101c68167a245b17bbdf49f884b2f62d5db", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_trace.py", + "status": "added", + "additions": 159, + "deletions": 0, + "changes": 159, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_trace.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_trace.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-network%2Fsourceframe_trace.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,159 @@\n+\"\"\"Stage-two label check of the source-frame lemma on the PR #7 complex network (Side(h), h+1 centre wires).\n+\n+Traces every side role and centre wire through the stage-two (inverse) PR #7 schedule, assigning each gate its\n+binary frame (PR #7 construction, frames section), with a1 = A, a3 = B fixed:\n+ D(U) = (t_A^perp (x) F (x) ) perp ( (x) U (x) ), D0 = D(0);\n+ copy y a-1 uses the physical Y frame t_A^perp (x) (x) .\n+Every frame's dimension is checked against fullbatch_hist's. For each distinct (first, last) label pair of a\n+source-framed role it checks in F_2^m: D0 subset of both, entrance phase q_U - q_D0 = q_{L1} (rank dim L1),\n+exit phase wt + q_D0 - q_V = q_G with G = D0 + V^perp of dim m - dim L2, nondegenerate and nonalternating.\n+Input-pivot slots must fail D0 subset first label (the reason they are excluded). Usage: labcheck_pr7.py h.\"\"\"\n+import os, sys, random\n+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\n+from side import Side\n+from labels import Checker\n+from roles import compile_roles\n+\n+h = int(sys.argv[1]); m = h ** 3; rnd = random.Random(h)\n+def idx(i, j, k): return (i * h + j) * h + k\n+def tens(a, b, c):\n+ x = 0\n+ for i in range(h):\n+ if a >> i & 1:\n+ for j in range(h):\n+ if b >> j & 1:\n+ for k in range(h):\n+ if c >> k & 1: x |= 1 << idx(i, j, k)\n+ return x\n+def dot(x, y): return bin(x & y).count('1') & 1\n+def span_basis(vs):\n+ b = {}\n+ for x in vs:\n+ for piv, y in b.items():\n+ if x >> piv & 1: x ^= y\n+ if x:\n+ piv = x.bit_length() - 1\n+ for q in list(b):\n+ if b[q] >> piv & 1: b[q] ^= x\n+ b[piv] = x\n+ return b\n+def contains(big, small):\n+ b = span_basis(big)\n+ for x in small:\n+ for piv, y in b.items():\n+ if x >> piv & 1: x ^= y\n+ if x: return False\n+ return True\n+class Proj:\n+ def __init__(s, B):\n+ s.B = B; n = len(B)\n+ G = [sum(dot(a, b) << j for j, b in enumerate(B)) | (1 << (n + i)) for i, a in enumerate(B)]\n+ for col in range(n):\n+ r = next((r for r in range(col, n) if G[r] >> col & 1), None)\n+ assert r is not None, 'degenerate'\n+ G[col], G[r] = G[r], G[col]\n+ for rr in range(n):\n+ if rr != col and G[rr] >> col & 1: G[rr] ^= G[col]\n+ s.Gi = [g >> n for g in G]\n+ def __call__(s, x):\n+ c = sum(dot(b, x) << j for j, b in enumerate(s.B)); out = 0\n+ for i, b in enumerate(s.B):\n+ if bin(s.Gi[i] & c).count('1') & 1: out ^= b\n+ return out\n+def q(P, x): return bin(P(x)).count('1') % 4\n+def perp(B):\n+ R = list(span_basis(B).items()); out = []\n+ pivs = {pv for pv, _ in R}\n+ for f in range(m):\n+ if f in pivs: continue\n+ x = 1 << f\n+ for pv, r in R:\n+ if dot(r, x): x ^= 1 << pv\n+ out.append(x)\n+ return out\n+def _perp_small(U):\n+ rows = list(span_basis(U).items()); out = []\n+ pivs = {pv for pv, _ in rows}\n+ for f in range(h):\n+ if f in pivs: continue\n+ x = 1 << f\n+ for pv, r in rows:\n+ if dot(r, x): x ^= 1 << pv\n+ out.append(x)\n+ return out\n+\n+c = Side(h); k = compile_roles(c); ch = Checker(c); assert ch.run()['bad'] == 0\n+R = k['size']; F = [1 << i for i in range(h)]; a = h; low, high = (a - 1) * h, a * h\n+lab = {n: ch.label(n) for n in c.active}\n+# trace: frame descriptors ('U', basis tuple) or ('Ydata', T); dims checked against fullbatch_hist\n+first = {}; last = {}\n+def touch(slot, desc, dim):\n+ got = (low + len(span_basis(list(desc[1])))) if desc[0] == 'U' else a - 1\n+ assert got == dim, (desc, got, dim)\n+ first.setdefault(slot, desc); last[slot] = desc\n+U = lambda B: ('U', tuple(sorted(span_basis(list(B)).values())))\n+cent = range(R, R + h + 1)\n+pieces = {t: [] for t in c.triples}\n+for i, sl in k['pout'].items(): pieces[c.pieces[i][0]].append(sl)\n+def mix(md, rev=False):\n+ for n, ins, outs in (reversed(k['gates']) if rev else k['gates']):\n+ L = {'low': [], 'high': F, 'complement': _perp_small(lab[n])}[md]\n+ dim = {'low': low, 'high': high, 'complement': high - len(lab[n])}[md]\n+ for sl in set(ins + outs): touch(sl, U(L), dim)\n+def inject(f, line):\n+ for t in c.triples:\n+ tm = sum(1 << q for q in t)\n+ for sl in pieces[t]: touch(sl, U([tm] if line else F), f)\n+def copy_y(f, data):\n+ for t, sl in k['src'].items():\n+ tm = sum(1 << q for q in t)\n+ touch(sl, ('Ydata', t) if data else U(_perp_small([tm])), f)\n+def central(L, f):\n+ for sl in cent: touch(sl, U(L), f)\n+# stage-two inverse schedule, exactly as fullbatch_hist.invocation(inverse=True)\n+copy_y(a - 1, True); central([], low); mix('low'); inject(low + 1, True)\n+mix('complement', True); central(F, high); central([], low)\n+copy_y(high - 1, False); central(F, high); mix('high'); inject(high, False)\n+mix('high', True)\n+\n+keep = set(k['src'].values()) | set(k['rout'].values()) | set(cent)\n+framed = [sl for sl in range(R) if sl not in keep]\n+pairs = {}\n+for sl in framed: pairs.setdefault((first[sl], last[sl]), []).append(sl)\n+src_firsts = {first[sl][0] for sl in k['src'].values()}\n+print('h', h, 'roles', R, 'source-framed', len(framed), 'distinct (first,last) label pairs', len(pairs),\n+ 'input-pivot first frames', src_firsts, flush=True)\n+\n+T3 = [sum(1 << i for i in t) for t in c.triples]\n+ok = True\n+for trial in range(3):\n+ tA, tB = rnd.choice(T3), rnd.choice(T3)\n+ Aperp = list(span_basis([u ^ (tA if dot(u, tA) else 0) for u in F]).values())\n+ D0 = list(span_basis([tens(x, u, tB) for x in Aperp for u in F]).values()); assert len(D0) == low\n+ PD0 = Proj(D0)\n+ def space(desc):\n+ if desc[0] == 'Ydata':\n+ tm = sum(1 << q for q in desc[1]); return [tens(x, tm, tB) for x in Aperp], None\n+ E = [tens(tA, l, tB) for l in desc[1]]; return D0 + E, E\n+ ys = [rnd.getrandbits(m) for _ in range(20)]\n+ for (f, l), sls in pairs.items():\n+ Uf, E1 = space(f); Vl, E2 = space(l)\n+ inc = contains(Uf, D0) and contains(Vl, D0)\n+ PU, PV = Proj(list(span_basis(Uf).values())), Proj(list(span_basis(Vl).values()))\n+ PE = Proj(E1) if E1 else (lambda x: 0)\n+ Gs = list(span_basis(D0 + perp(Vl)).values()); PG = Proj(Gs)\n+ ent = all((q(PU, y) - q(PD0, y) - q(PE, y)) % 4 == 0 for y in ys)\n+ ex = all((bin(y).count('1') + q(PD0, y) - q(PV, y) - q(PG, y)) % 4 == 0 for y in ys)\n+ nonalt = any(dot(x, x) for x in Gs); rk = len(Gs) == m - len(E2)\n+ print(' trial', trial, 'first dim L1', len(E1), 'last dim L2', len(E2), 'roles', len(sls),\n+ '| D0 in both', inc, 'entrance ok', ent, 'exit ok', ex, 'exit rank', len(Gs), 'm-dimL2', rk,\n+ 'nonalt', nonalt, flush=True)\n+ ok &= inc and ent and ex and nonalt and rk\n+ # excluded roles: an input pivot's first stage-two label must not contain D0\n+ sp, _ = space(first[k['src'][c.triples[0]]])\n+ neg = not contains(sp, D0); print(' trial', trial, 'input-pivot first label excludes D0 (expected):', neg)\n+ ok &= neg\n+ # centre wires: first D0, last D1 as well (they keep source 0 regardless)\n+ cf = {(first[s], last[s]) for s in cent}; print(' centre (first,last) dims',\n+ [(len(x[1]), len(y[1])) for x, y in cf])\n+print('ALL OK', ok)" + }, + { + "sha": "bb6879adcd3b2a0c78afba69ea05ed154e4b786b", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-twostage/cert.py", + "status": "added", + "additions": 44, + "deletions": 0, + "changes": 44, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fcert.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fcert.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fcert.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,44 @@\n+\"\"\"Certified complex saving a_c from a residual histogram {rank r: count n_r}, exact rationals only.\n+\n+Moment condition (PR #10 batched recursion, sigma = 1 - a): sum_r n_r r^sigma / (W m^sigma) < 1.\n+Write it as M(a) = sum_r w_r (m/r)^a, w_r = r n_r / (W m) (so sum_r w_r = s/(W m) < 1).\n+We bound (m/r)^a <= exp(a U_r) with a rational U_r >= ln(m/r), and exp(x) <= 1 + x + x^2/2 + x^3/(6(1 - x/4))\n+for 0 <= x < 4 (the Taylor tail sum_{j>=3} x^j/j! is dominated by the geometric series x^3/6 sum (x/4)^i).\n+ln upper bounds: ln y = k ln 2 + ln(y/2^k), y/2^k in [1, 2); ln z = 2 atanh((z-1)/(z+1)), atanh truncated after\n+K odd terms with the tail bounded by u^(2K+1) / ((2K+1)(1-u^2)); every term is exact, rounded up to 10^-40.\n+a_c = largest grid point a with M(a) < 1 (binary search; M is increasing in a).\n+Usage: imported by run.py (cert(hist, W, m) -> (a_c, 1 - M(a_c))).\"\"\"\n+from fractions import Fraction as Q\n+\n+PREC = 10 ** 40\n+\n+def up(x): return Q(-((-x.numerator * PREC) // x.denominator), PREC) # round up to the 10^-40 grid\n+\n+def atanh_up(u, K=40):\n+ s = Q(0); p = u\n+ for k in range(K): s += p / (2 * k + 1); p *= u * u\n+ return s + p / ((2 * K + 1) * (1 - u * u)) # p = u^(2K+1)\n+\n+LN2 = up(2 * atanh_up(Q(1, 3)))\n+\n+def ln_up(y):\n+ y = Q(y); assert y >= 1\n+ k = 0\n+ while y >= 2: y /= 2; k += 1\n+ return up(k * LN2 + 2 * atanh_up((y - 1) / (y + 1)))\n+\n+def exp_up(x):\n+ assert 0 <= x < 4\n+ return 1 + x + x * x / 2 + x ** 3 / (6 * (1 - x / 4))\n+\n+def moment(ws, a): return sum(w * exp_up(a * U) for w, U in ws)\n+\n+def cert(hist, W, m, grid=10 ** 12):\n+ ws = [(Q(r * n, W * m), ln_up(Q(m, r))) for r, n in hist.items()]\n+ lo, hi = 0, grid // 1000 # a < 10^-3 (far above any saving here)\n+ assert moment(ws, Q(hi, grid)) > 1\n+ while hi - lo > 1:\n+ mid = (lo + hi) // 2\n+ if moment(ws, Q(mid, grid)) < 1: lo = mid\n+ else: hi = mid\n+ a = Q(lo, grid); return a, 1 - moment(ws, a)" + }, + { + "sha": "45126062136d58f2d4fedcf549f40cd95d456c7f", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-twostage/frames.py", + "status": "added", + "additions": 92, + "deletions": 0, + "changes": 92, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fframes.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fframes.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fframes.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,92 @@\n+\"\"\"Binary frame labels of the complex producer over F2^h with the dot product, and the residual checks.\n+\n+Label of a node (a subspace of F2^h, h = points): an input triple t -> ; a node whose >= 2 triples share a common\n+pair -> span of their indicator vectors; otherwise the coordinate space of the covered points.\n+A frame change U -> V is a valid whole-residual child iff U, V are nested and the residual (larger \u2229 smaller^perp)\n+is nondegenerate and nonalternating (has an orthonormal basis). The checker verifies, for every active node,\n+ - the label itself as the entry residual from the low frame 0 (also: the copied-centre COPY transform L -> 0),\n+ - its complement in F = F2^h as the exit residual to the high frame (also: the copied-centre DIRECT move L -> F),\n+ - every producer edge (argument label -> node label) and piece edge (node label -> t_S^perp).\n+Two-stage lifts preserve this: stage-one frames are L (x) t, stage-two frames D0 + t (x) L, D0 = t^perp (x) F; for a\n+weight-3 triple t (t.t = 1, odd weight) the lifted residual R (x) t, resp. t (x) R, is nondegenerate and\n+nonalternating iff R is (Gram matrix is unchanged; wt(r (x) t) = 3 wt(r) is odd iff wt(r) is).\n+Usage: python3 frames.py 24 (prints edges checked and bad count)\"\"\"\n+import sys\n+\n+\n+def echelon(vs):\n+ b = {}\n+ for x in vs:\n+ for p, y in b.items():\n+ if x & p: x ^= y\n+ if not x: continue\n+ p = x & -x\n+ for q in list(b):\n+ if b[q] & p: b[q] ^= x\n+ b[p] = x\n+ return b\n+def red(b, x):\n+ for p, y in b.items():\n+ if x & p: x ^= y\n+ return x\n+def dot(a, b): return bin(a & b).count('1') & 1\n+def perp_in(V, U):\n+ \"\"\"basis of span(V) \u2229 U^perp.\"\"\"\n+ rows = [(sum(dot(v, u) << j for j, u in enumerate(U)), 1 << i) for i, v in enumerate(V)]\n+ for col in range(len(U)):\n+ bit = 1 << col\n+ idx = next((i for i, (a, _) in enumerate(rows) if a & bit), None)\n+ if idx is None: continue\n+ pa, pb = rows.pop(idx)\n+ rows = [(a ^ pa, b ^ pb) if a & bit else (a, b) for a, b in rows]\n+ out = []\n+ for a, b in rows:\n+ x = 0\n+ for i, v in enumerate(V):\n+ if b >> i & 1: x ^= v\n+ out.append(x)\n+ return out\n+def nondeg(B):\n+ return len(echelon([sum(dot(a, b) << j for j, b in enumerate(B)) for a in B])) == len(B)\n+def ok_res(R):\n+ \"\"\"nondegenerate and nonalternating (some odd-weight vector), i.e. an orthonormal basis exists.\"\"\"\n+ return (not R) or (nondeg(R) and any(bin(x).count('1') & 1 for x in R))\n+\n+\n+class Checker:\n+ def __init__(s, c): s.c = c; s.h = c.h; s.cache = {}; s.lab = {}\n+ def tvec(s, i): return sum(1 << p for p in s.c.triples[i])\n+ def label(s, n):\n+ if n in s.lab: return s.lab[n]\n+ c = s.c; sp = c.sup[n]; idx = []\n+ while sp:\n+ lo = sp & -sp; idx.append(lo.bit_length() - 1); sp ^= lo\n+ if len(idx) == 1: B = [s.tvec(idx[0])]\n+ else:\n+ common = set(c.triples[idx[0]])\n+ for i in idx[1:]: common &= set(c.triples[i])\n+ if len(common) >= 2: B = list(echelon([s.tvec(i) for i in idx]).values()); assert len(B) == len(idx)\n+ else: X = c.cover(n); B = [1 << p for p in range(s.h) if X >> p & 1]\n+ B = sorted(echelon(B).values()); s.lab[n] = B; return B\n+ def edge(s, U, V):\n+ key = (tuple(U), tuple(V))\n+ if key not in s.cache:\n+ bV = echelon(V)\n+ s.cache[key] = all(red(bV, u) == 0 for u in U) and ok_res(perp_in(V, U))\n+ return s.cache[key]\n+ def run(s):\n+ c = s.c; bad = 0; n_e = 0; F = [1 << p for p in range(s.h)]\n+ for n in c.active:\n+ L = s.label(n)\n+ n_e += 2; bad += (not (nondeg(L) and ok_res(L))) + (not ok_res(perp_in(F, L))) # entry / exit residuals\n+ if c.args[n]:\n+ for a in c.args[n]:\n+ n_e += 1; bad += not s.edge(s.label(a), L)\n+ for S, n, _ in c.pieces:\n+ n_e += 1; bad += not s.edge(s.label(n), perp_in(F, [sum(1 << p for p in S)]))\n+ return dict(edges=n_e, bad=bad, labels=len(s.lab))\n+\n+\n+if __name__ == '__main__':\n+ from producer import NStar3\n+ for h in map(int, sys.argv[1:]): print(h, Checker(NStar3(h)).run(), flush=True)" + }, + { + "sha": "30fc761818781e881962cbab3efcb0547e1173a1", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-twostage/hist.py", + "status": "added", + "additions": 109, + "deletions": 0, + "changes": 109, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fhist.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fhist.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fhist.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,109 @@\n+\"\"\"Residual-rank histogram of the two-stage complex network (m = h^2) on the NStar3 producer with retained totals,\n+optionally with copied retained centres; every nonzero residual is one whole-residual child (full batching).\n+\n+Network. Each stage runs v = C(h,3) invocations of the producer's role network on a bank of R auxiliary roles.\n+Forward invocation (y <- y + x), single-factor frame dims (low 0, high h, label = dim of the node label):\n+ mix(low) sret(low) inject(low) mix(low,rev) copy(line=1) mix(label) sret(low) inject(t^perp=h-1) mix(high,rev) copy(F=h)\n+ mix = every addition gate on its role slots; inject = pieces into y[t]; copy = x[t] into its source slot;\n+ sret = the retained-total scatter into y[S] (reads the h retained roles).\n+Stage 1: forward per fixed a2, frames L (x) t_a2, dim = d. Stage 2: the inverse (op list and gates reversed, labels\n+complemented in F) per fixed a1, frames D0 + t_a1 (x) L^perp, dim = m - d; source = Y, target = X.\n+Endpoints: every auxiliary role 0 -> ... -> m per invocation (arbitrary scratch restored); X: U (dim 1) -> m,\n+Y: 0 -> m-1; plus one rank-one endpoint-correction child per data pair. Frames are nested along every role\n+(frames.py, and the explicit simulation), so each edge's rank is the dimension difference.\n+Copied centres (PR #36 lemma): in the second sret (forward op 6, stage-two op 3) each retained role is read from a\n+transformed copy; the original moves directly from its previous frame p to its next frame q. The copy is charged\n+|p - lo| in stage 1 (copy made before the original moves) and |q - lo| in stage 2 (original moves first).\n+Total rank s = W m - N + 2L, or W m - N + L with copies, W = 2N + 2vR, L = 2v((h-1)^2 + h), N = v^2.\n+Usage: python3 hist.py 24 copy (prints the histogram and the sum check)\"\"\"\n+import sys\n+from collections import Counter\n+from producer import NStar3, compile_roles\n+\n+DESIG = 6 # index of the copied scatter op in the forward op list\n+\n+\n+def label_dims(c):\n+ \"\"\"dim of the frame label of every active node, from supports: 1 for an input; the number of triples when\n+ they share a common pair; else the number of covered points (see frames.Checker.label).\"\"\"\n+ out = {}\n+ for n in c.active:\n+ sp = c.sup[n]; k = bin(sp).count('1')\n+ if k == 1: out[n] = 1; continue\n+ common = (1 << c.h) - 1; i = 0\n+ while sp:\n+ if sp & 1: common &= sum(1 << p for p in c.triples[i])\n+ sp >>= 1; i += 1\n+ out[n] = k if bin(common).count('1') >= 2 else bin(c.cover(n)).count('1')\n+ return out\n+\n+\n+def forward_ops(c, kk, dl):\n+ \"\"\"list of ops; op = list of (roles, single-factor dim). Roles: ('s', slot), ('x', t), ('y', t).\"\"\"\n+ h = c.h; T = c.triples\n+ pieces = {t: [] for t in T}\n+ for i, sl in kk['pout'].items(): pieces[c.pieces[i][0]].append(sl)\n+ rout = kk['rout']\n+ def mix(mode, rev=False):\n+ g = list(reversed(kk['gates'])) if rev else kk['gates']\n+ return [(tuple(('s', q) for q in set(ins + outs)), {'low': 0, 'high': h}.get(mode, dl.get(n))) for n, ins, outs in g]\n+ def sret():\n+ out = []\n+ for S in T: # the retained totals that the scatter identity uses for y[S]\n+ names = [('*',)] + ([('E', i) for i in S] if h - 1 not in S else [('E', i) for i in range(h - 1) if i not in S])\n+ out.append((tuple([('y', S)] + [('s', rout[nm]) for nm in names]), 0))\n+ return out\n+ inject = lambda d: [(tuple([('y', t)] + [('s', q) for q in pieces[t]]), d) for t in T if pieces[t]]\n+ copy = lambda d: [((('x', t), ('s', sl)), d) for t, sl in kk['src'].items()]\n+ return [mix('low'), sret(), inject(0), mix('low', True), copy(1), mix('label'), sret(), inject(h - 1),\n+ mix('high', True), copy(h)]\n+\n+\n+def build(h, copied):\n+ c = NStar3(h); kk = compile_roles(c); dl = label_dims(c)\n+ T = c.triples; v = len(T); m = h * h; N = v * v; R = kk['size']\n+ f = forward_ops(c, kk, dl)\n+ r = [[(roles, h - d) for roles, d in reversed(op)] for op in reversed(f)]\n+ ret = {('s', q) for q in kk['rout'].values()}\n+ H = Counter(); data = {}\n+ for stage, ops, lift, desig in ((1, f, lambda d: d, DESIG), (2, r, lambda d: m - h + d, len(f) - 1 - DESIG)):\n+ cur = {}; dd = {}; pend = set(); done = set(); Hs = Counter()\n+ for oi, op in enumerate(ops):\n+ for roles, d in op:\n+ D = lift(d)\n+ for ro in roles:\n+ if ro[0] in ('x', 'y'): dd.setdefault(ro, []).append(D); continue\n+ p = cur.get(ro, 0)\n+ if copied and ro in ret and oi == desig:\n+ # one copy per retained role serves all of this op's scatter reads\n+ if ro not in done:\n+ done.add(ro)\n+ if stage == 1: Hs[abs(p - D)] += p != D # copy made at p, original stays at p\n+ else: pend.add(ro); lo2 = D # copy charged once q is known\n+ continue\n+ if ro in pend: # stage 2: q = this frame\n+ pend.discard(ro); Hs[abs(lo2 - D)] += lo2 != D\n+ if p != D: Hs[abs(p - D)] += 1\n+ cur[ro] = D\n+ assert len(cur) == R and not pend\n+ for ro, p in cur.items(): Hs[m - p] += p != m # auxiliary endpoint: full frame\n+ for k_, n_ in Hs.items(): H[k_] += v * n_ # dims do not depend on the fixed index\n+ data[stage] = dd\n+ # data pairs (a1, a2): X = stage-1 'x' of a1 then stage-2 target ('y') of a2; Y = stage-1 'y' then stage-2 'x'\n+ p1 = Counter((tuple(data[1].get(('x', t), [])), tuple(data[1].get(('y', t), []))) for t in T)\n+ p2 = Counter((tuple(data[2].get(('y', t), [])), tuple(data[2].get(('x', t), []))) for t in T)\n+ for (x1, y1), n1 in p1.items():\n+ for (x2, y2), n2 in p2.items():\n+ for sq in ([1, *x1, *x2, m], [0, *y1, *y2, m - 1]):\n+ for a, b in zip(sq, sq[1:]):\n+ if a != b: H[abs(b - a)] += n1 * n2\n+ H[1] += N # endpoint correction children\n+ W = 2 * N + 2 * v * R; L = 2 * v * ((h - 1) ** 2 + h); s = W * m - N + (L if copied else 2 * L)\n+ tot = sum(k_ * n_ for k_, n_ in H.items())\n+ return dict(h=h, v=v, m=m, N=N, R=R, W=W, L=L, s=s, hist={k_: n_ for k_, n_ in sorted(H.items()) if n_}, sum=tot, sum_ok=tot == s,\n+ maxrank=max(H), c=c)\n+\n+\n+if __name__ == '__main__':\n+ h = int(sys.argv[1]); copied = len(sys.argv) > 2 and sys.argv[2] == 'copy'\n+ d = build(h, copied); d.pop('c'); print(d)" + }, + { + "sha": "10d2110f9bf25a857f5b7fef76bb95fa367d3eac", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-twostage/producer.py", + "status": "added", + "additions": 233, + "deletions": 0, + "changes": 233, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fproducer.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fproducer.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Fproducer.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,233 @@\n+\"\"\"NStar3: the pair-exclusion complex side producer with retained totals (h even).\n+\n+An addition circuit over the binomial(h,3) triple inputs x_t. It emits signed pieces (S, node, coef) whose\n+half-weighted sum, plus the retained-total scatter, is x_S, and retains the h totals\n+E_i = sum_{t not containing i} x_t (i < h-1) and T = sum_t x_t. Nodes are interned by their support (set of\n+triples), so an equal sum is never built twice. Structure:\n+ triple() recursive triple exclusion over point pairs (groups), giving every 'exclusion' sum\n+ sum_{t disjoint from S} x_t for |S| <= 3;\n+ block() pair-exclusion block (one point excluded, one pair excluded), with an 8-addition 3-point base;\n+ stars minus pieces from group-level leave-one-out vectors shared across pairs (two_vec).\n+Usage: python3 producer.py 24 (prints the circuit size R)\"\"\"\n+import sys\n+from itertools import combinations\n+from collections import defaultdict\n+sys.setrecursionlimit(10000)\n+\n+\n+class NStar3:\n+ def __init__(s, h, base=4):\n+ assert h % 2 == 0 and h >= 8, 'groups are point pairs: h even, h >= 8'\n+ s.h = h; s.base = base\n+ s.triples = list(combinations(range(h), 3)); s.tid = {t: i for i, t in enumerate(s.triples)}\n+ s.sup = [0]; s.args = [None]; s.look = {} # node 0 is the empty sum; node i+1 is input triple i\n+ for i, t in enumerate(s.triples): s.sup.append(1 << i); s.args.append(None)\n+ s.cov = {}; s.pieces = []; s.retained = []; s.twos = {}\n+ s.top = True\n+ w = {t: s.tid[t] + 1 for t in s.triples}\n+ s.results = s.triple(list(range(h)), w)\n+ for S in s.triples: s.emit(S, s.results[S], 1)\n+ for i in range(h - 1): s.retained.append((('E', i), s.results[(i,)]))\n+ s.retained.append((('*',), s.results[()]))\n+ s.star_pieces()\n+ s.prune()\n+\n+ # node store: interned by support; a sum of two nodes must not share triples (no cancellation)\n+ def add(s, a, b):\n+ if not a: return b\n+ if not b: return a\n+ assert not s.sup[a] & s.sup[b], 'cancellation'\n+ key = s.sup[a] | s.sup[b]; n = s.look.get(key)\n+ if n is None:\n+ n = len(s.sup); s.look[key] = n; s.sup.append(key); s.args.append((a, b))\n+ return n\n+ def total(s, vals):\n+ if not vals: return 0\n+ if len(vals) == 1: return vals[0]\n+ k = len(vals) // 2\n+ return s.add(s.total(vals[:k]), s.total(vals[k:]))\n+ def vector(s, vals):\n+ \"\"\"total and all leave-one-out sums, by prefix/suffix chains.\"\"\"\n+ n = len(vals); pre = [0]\n+ for x in vals: pre.append(s.add(pre[-1], x))\n+ suf = [0] * (n + 1)\n+ for i in range(n - 1, -1, -1): suf[i] = s.add(vals[i], suf[i + 1])\n+ return pre[-1], [s.add(pre[i], suf[i + 1]) for i in range(n)]\n+ def grouping(s, pts): return [pts[i:i + 2] for i in range(0, len(pts), 2)]\n+ def x(s, *p): return s.tid[tuple(sorted(p))] + 1\n+\n+ # pair-exclusion block: total, one point excluded, one pair excluded ---------------------------\n+ def block(s, points, edges, weights):\n+ T = s.total; A = s.add\n+ if len(points) == 3: # 8-addition base: the three pair sums share q1, q2, q3\n+ p1, p2, p3 = points; e = lambda a, b: edges[tuple(sorted((a, b)))]; wt = weights\n+ q1 = A(e(p2, p3), wt[p2]); q2 = A(e(p1, p3), wt[p3]); q3 = A(e(p1, p2), wt[p1])\n+ O = {p1: A(q1, wt[p3]), p2: A(q2, wt[p1]), p3: A(q3, wt[p2])}\n+ tot = A(O[p1], A(q3, e(p1, p3)))\n+ return tot, O, {(p1, p2): wt[p3], (p1, p3): wt[p2], (p2, p3): wt[p1]}\n+ if len(points) <= 4:\n+ tot = lambda om: T([x for p, x in edges.items() if not set(p) & set(om)] + [x for p, x in weights.items() if p not in om])\n+ return tot(()), {a: tot((a,)) for a in points}, {(a, b): tot((a, b)) for a, b in combinations(points, 2)}\n+ groups = s.grouping(points); ng = len(groups); e = lambda a, b: edges[tuple(sorted((a, b)))]\n+ coarse = {(i, j): T([e(a, b) for a in groups[i] for b in groups[j]]) for i, j in combinations(range(ng), 2)}\n+ wt = {i: T([weights[a] for a in g] + [e(a, b) for a, b in combinations(g, 2)]) for i, g in enumerate(groups)}\n+ total, outside, far = s.block(list(range(ng)), coarse, wt)\n+ strips = {}; sums = {}\n+ for i, g in enumerate(groups):\n+ other = [j for j in range(ng) if j != i]\n+ for a in g:\n+ carry = T([weights[u] for u in g if u != a])\n+ vals = [T([e(u, v) for u in g if u != a for v in groups[j]]) for j in other]\n+ st, one = s.vector([carry] + vals)\n+ strips[a] = {j: z for j, z in zip(other, one[1:])}; sums[a] = st\n+ out = {}; single = {a: s.add(outside[i], sums[a]) for i, g in enumerate(groups) for a in g}\n+ for i, g in enumerate(groups):\n+ for a, b in combinations(g, 2): out[a, b] = outside[i]\n+ for i, j in combinations(range(ng), 2):\n+ for a in groups[i]:\n+ left = s.add(far[i, j], strips[a][j])\n+ for b in groups[j]:\n+ cross = T([e(u, v) for u in groups[i] if u != a for v in groups[j] if v != b])\n+ out[a, b] = s.add(left, s.add(strips[b][i], cross))\n+ return total, single, out\n+\n+ # recursive triple exclusion ---------------------------------------------------------------------\n+ def triple(s, pts, w):\n+ top = s.top; s.top = False\n+ T = s.total\n+ subsets = [c for k in range(4) for c in combinations(pts, k)]\n+ if len(pts) <= s.base:\n+ return {c: T([v for t, v in w.items() if not set(c) & set(t)]) for c in subsets}\n+ groups = s.grouping(pts); ng = len(groups)\n+ gof = {u: i for i, g in enumerate(groups) for u in g}\n+ cp = defaultdict(list)\n+ for t, v in w.items(): cp[tuple(sorted({gof[u] for u in t}))].append(v)\n+ coarse = {c: T(xs) for c, xs in cp.items() if not (top and len(c) == 2)}\n+ if top:\n+ # a two-group coarse item is the union of two free star prefixes {u,v,pu},{u,v,pv}\n+ for (i, j) in [c for c in cp if len(c) == 2]:\n+ (i0, i1), (j0, j1) = groups[i], groups[j]\n+ coarse[i, j] = s.add(s.add(s.x(i0, j0, i1), s.x(i0, j0, j1)), s.add(s.x(i1, j1, i0), s.x(i1, j1, j0)))\n+ oc = s.triple(list(range(ng)), coarse)\n+ one = {}\n+ for u in pts:\n+ g = gof[u]; others = [j for j in range(ng) if j != g]\n+ pieces = defaultdict(list)\n+ for t, v in w.items():\n+ if u not in t: continue\n+ rest = [a for a in t if a != u]\n+ if any(gof[a] == g for a in rest): continue\n+ pieces[tuple(sorted({gof[a] for a in rest}))].append(v)\n+ coeff = {c: T(xs) for c, xs in pieces.items()}\n+ edges = {c: coeff.get(c, 0) for c in combinations(others, 2)}\n+ weights = {j: coeff.get((j,), 0) for j in others}\n+ tot, single, pair = s.block(others, edges, weights)\n+ const = coeff.get((), 0)\n+ one[u] = {(): s.add(const, tot)}\n+ one[u].update({(j,): s.add(const, x) for j, x in single.items()})\n+ one[u].update({c: s.add(const, x) for c, x in pair.items()})\n+ two = {}\n+ for u, v in combinations(pts, 2):\n+ i, j = gof[u], gof[v]\n+ if i == j: continue\n+ others = [k for k in range(ng) if k not in (i, j)]\n+ vals = [T([w.get(tuple(sorted((u, v, a))), 0) for a in groups[k]]) for k in others]\n+ tot, leave = s.vector([w.get((u, v), 0)] + vals)\n+ two[u, v] = {(): tot} | {(k,): x for k, x in zip(others, leave[1:])}\n+ res = {}\n+ for ex in subsets:\n+ E = set(ex); G = tuple(sorted({gof[a] for a in E}))\n+ surv = [u for i in G for u in groups[i] if u not in E]\n+ pc = {(): oc[G]}\n+ for u in surv: pc[u,] = one[u][tuple(i for i in G if i != gof[u])]\n+ for u, v in combinations(surv, 2): pc[u, v] = two[u, v][tuple(i for i in G if i not in (gof[u], gof[v]))]\n+ if len(surv) == 3:\n+ pc[tuple(surv)] = w.get(tuple(surv), 0)\n+ a, b, c = surv; order = [(), (a,), (b,), (a, b), (c,), (a, c), (b, c), (a, b, c)]\n+ else: order = [c for k in range(len(surv) + 1) for c in combinations(surv, k)]\n+ res[ex] = T([pc[c] for c in order])\n+ return res\n+\n+ # minus pieces (pair stars) from shared group-level leave-one-out vectors -----------------------\n+ def two_vec(s, u, v):\n+ \"\"\"leave-one-group-out vector of star(u,v) over groups other than g(u), g(v).\"\"\"\n+ key = (min(u, v), max(u, v))\n+ if key in s.twos: return s.twos[key]\n+ h = s.h; ng = (h + 1) // 2\n+ others = [k for k in range(ng) if k not in (u // 2, v // 2)]\n+ vals = [s.total([s.x(u, v, a) for a in range(2 * k, min(2 * k + 2, h))]) for k in others]\n+ tot, leave = s.vector(vals)\n+ r = {(): tot} | {(k,): x for k, x in zip(others, leave)}\n+ s.twos[key] = r; return r\n+ def star_pieces(s):\n+ # star(u,v) minus {c} = {u,v,c'} + B_k with B_k = two[u,v](k) + PP_uv, shared by {u,v,c} and {u,v,c'}\n+ h = s.h\n+ for a, b in combinations(range(h), 2):\n+ tw = s.two_vec(a, b)\n+ if a // 2 == b // 2:\n+ for c in range(h):\n+ if c // 2 == a // 2: continue\n+ S = tuple(sorted((a, b, c)))\n+ s.emit(S, s.x(a, b, c ^ 1), -1); s.emit(S, tw[(c // 2,)], -1)\n+ continue\n+ pa, pb = a ^ 1, b ^ 1\n+ PP = s.add(s.x(a, b, pa), s.x(a, b, pb))\n+ for c in range(h):\n+ if c in (a, b): continue\n+ S = tuple(sorted((a, b, c)))\n+ if c == pa: s.emit(S, s.x(a, b, pb), -1); s.emit(S, tw[()], -1)\n+ elif c == pb: s.emit(S, s.x(a, b, pa), -1); s.emit(S, tw[()], -1)\n+ else: s.emit(S, s.x(a, b, c ^ 1), -1); s.emit(S, s.add(tw[(c // 2,)], PP), -1)\n+\n+ def cover(s, n):\n+ \"\"\"bitmask of the points covered by the triples of node n.\"\"\"\n+ if n not in s.cov:\n+ sp = s.sup[n]; m = 0\n+ while sp:\n+ lo = sp & -sp; m |= sum(1 << p for p in s.triples[lo.bit_length() - 1]); sp ^= lo\n+ s.cov[n] = m\n+ return s.cov[n]\n+ def emit(s, S, n, coef):\n+ # a piece whose cover together with S is every point would need a full label: split it into its arguments\n+ if not n: return\n+ Sm = sum(1 << p for p in S)\n+ if s.cover(n) | Sm == (1 << s.h) - 1:\n+ a, b = s.args[n]; s.emit(S, a, coef); s.emit(S, b, coef)\n+ else: s.pieces.append((S, n, coef))\n+ def prune(s):\n+ s.active = set(); st = [n for _, n, _ in s.pieces] + [n for _, n in s.retained]\n+ while st:\n+ n = st.pop()\n+ if n in s.active: continue\n+ s.active.add(n)\n+ if s.args[n]: st.extend(s.args[n])\n+ s.additions = sum(1 for n in s.active if s.args[n])\n+ s.roles = s.additions + len(s.pieces) + len(s.retained) # R: one role slot per use of a node\n+\n+\n+def compile_roles(c):\n+ \"\"\"Role slots: every node gets one output slot per user (gate argument, piece, retained total).\"\"\"\n+ users = {x: [] for x in c.active}\n+ for n in sorted(c.active):\n+ if c.args[n]:\n+ for pos, x in enumerate(c.args[n]): users[x].append(('g', n, pos))\n+ for i, (_, n, _) in enumerate(c.pieces): users[n].append(('p', i))\n+ for name, n in c.retained: users[n].append(('r', name))\n+ edge = {}; src = {}; pout = {}; rout = {}; gates = []; size = 0\n+ for n in sorted(c.active):\n+ if c.args[n]: ins = (edge[n, 0], edge[n, 1]); piv = ins[0]\n+ else: piv = size; size += 1; ins = (piv,); src[c.triples[n - 1]] = piv\n+ outs = (piv,) + tuple(range(size, size + len(users[n]) - 1)); size += len(users[n]) - 1\n+ assert len(set(ins)) == len(ins) and set(ins) & set(outs) == {piv}\n+ gates.append((n, ins, outs))\n+ for u, sl in zip(users[n], outs):\n+ if u[0] == 'g': edge[u[1], u[2]] = sl\n+ elif u[0] == 'p': pout[u[1]] = sl\n+ else: rout[u[1]] = sl\n+ assert size == c.roles\n+ return dict(size=size, gates=gates, src=src, pout=pout, rout=rout)\n+\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ c = NStar3(h); print(dict(h=h, v=len(c.triples), additions=c.additions, pieces=len(c.pieces), R=c.roles), flush=True)" + }, + { + "sha": "fe438f91656df7dc6b236d7b2000261282776228", + "filename": "research/deferred-signed/swapnil-round7/independent/complex-twostage/run.py", + "status": "added", + "additions": 23, + "deletions": 0, + "changes": 23, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Frun.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Frun.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fcomplex-twostage%2Frun.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,23 @@\n+\"\"\"Round-six complex saving: two-stage complex network, NStar3 producer with retained totals, copied retained\n+centres, full batching. Prints the circuit size, the frame/label check (0 bad), the histogram sum check (== s),\n+the largest child (crude guard needs <= m - 1) and the certified a_c; writes the histogram to hist_.json.\n+Usage: python3 run.py 24\"\"\"\n+import sys, json, time\n+from hist import build\n+from frames import Checker\n+from cert import cert\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ t0 = time.time()\n+ d = build(h, copied=True); c = d.pop('c')\n+ print(dict(h=h, v=d['v'], m=d['m'], R=d['R'], W=d['W'], s=d['s'], hist_sum=d['sum'], sum_ok=d['sum_ok'],\n+ maxrank=d['maxrank'], guard_ok=d['maxrank'] <= d['m'] - 1), flush=True)\n+ ch = Checker(c); dims = {n: len(ch.label(n)) for n in c.active}\n+ from hist import label_dims\n+ assert dims == label_dims(c), 'histogram label dims differ from the explicit labels'\n+ print('labels', ch.run(), flush=True)\n+ a, gap = cert(d['hist'], d['W'], d['m'])\n+ print(dict(a_c=str(a), a_c_float=float(a), moment_gap=float(gap), secs=round(time.time() - t0)), flush=True)\n+ json.dump(dict(h=h, m=d['m'], W=d['W'], s=d['s'], hist={str(k): n for k, n in d['hist'].items()}),\n+ open(f'hist_{h}.json', 'w'))" + }, + { + "sha": "f22b6998f9415dd0b081a146f00e5c30065d6689", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_frames.py", + "status": "added", + "additions": 262, + "deletions": 0, + "changes": 262, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_frames.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_frames.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_frames.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,262 @@\n+\"\"\"Round-seven check, part 2 (stdlib only): every frame of the reordered word, exactly over Q.\n+\n+The base frames (lifted node frames M_n, late-copy intersections, root frames t_T^perp and U_c) are rebuilt from the\n+witness with check_lifted.py's exact machinery. The design-B frames (deferred readout frames sigma_u, V-leaf starts\n+s_i) are the primitive integer bases of the data file. Checked:\n+ X. the frame dimensions recorded in the data file (node frames, late-copy intersections) equal the exact ones; every\n+ slot's node list moves along slot successors of the witness (gate uses and links, for which check_lifted.py proves\n+ nesting), its first node is where its start says, its last node reaches its root frame directly;\n+ Q. sigma_u <= F0(u) (the slot's start frame); sigma_u <= t_T^perp for every target of u (Z supports, a superset of\n+ the F2 supports); on every y_T the deferred levels are nested in time order (readout order); t_S <= s_i <= N_i\n+ (the first frame of the use); every X_S chain , early V frames, deferred V frames, F is nested in time order;\n+ G = I - J/9 nondegenerate on every new frame (Gram determinant nonzero mod a prime, so nonzero over Z);\n+ S. side lemma at check_lifted's integer point (U, V of point(h, 1), the point of check_stair.py too): every distinct\n+ high-rank step (2r > h) of the reordered word that check_lifted.py does not already cover (slot starts, gauged\n+ corners sigma_u -> F, y_T and X_S chain steps, base steps that only the new schedule uses) has the generic\n+ north-east pivots under both conjugations, mod 2^31-1;\n+ F. the child-width histogram rebuilt from the exact dimensions (Z and F2 y supports), rank sum s = W m - N + L,\n+ moment certificate and kappa, with the round-six and the staircase entrance corners;\n+ N. negative controls: reversed readout order, readouts at F0(u) instead of sigma_u, perturbed sigma frames, X_S\n+ chains with the deferred V gates first, side lemma with U = V = I.\n+Usage: python3 check_frames.py [h]\"\"\"\n+import sys, os, time, random\n+from fractions import Fraction as Fr\n+from math import gcd\n+from collections import Counter, defaultdict\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path[:0] = [HERE, os.path.join(HERE, '..', '..', 'scripts'), os.path.join(HERE, '..', 'two-stage-bit')]\n+import check_lifted as cl\n+import deferred as dr\n+from linalg import null_exact, rank_mod, inv_mod_matrix, rightmost_pivots, predicted, Q31, Echelon\n+\n+T0 = time.time()\n+def log(*a): print('[%5.0fs]' % (time.time() - T0), *a, flush=True)\n+OK = {}\n+def report(name, ok):\n+ OK[name] = bool(ok); log('%-100s %s' % (name, 'PASS' if ok else 'FAIL'))\n+\n+\n+def prim(r):\n+ r = [Fr(x) for x in r]; den = 1\n+ for x in r: den = den * x.denominator // gcd(den, x.denominator)\n+ z = [int(x * den) for x in r]; g = 0\n+ for x in z: g = gcd(g, x)\n+ return [x // g for x in z] if g else z\n+\n+\n+class ModQ7(cl.ModQ):\n+ \"\"\"check_lifted's mod-q frames, extended by the design-B frames ('sigma', s) and ('v', s) (integer bases).\"\"\"\n+ def __init__(self, fr, ld, extra, control=False):\n+ super().__init__(fr, ld, control); self.extra = extra\n+\n+ def basis(self, key):\n+ if key[0] in ('sigma', 'v') and key not in self.bcache:\n+ E = Echelon(self.q)\n+ for r in self.extra[key]: E.insert([x % self.q for x in r])\n+ if len(E.rows) != len(self.extra[key]): self.dimfail += 1\n+ self.bcache[key] = E.rows\n+ return super().basis(key)\n+\n+\n+def main(h=23):\n+ W, D = dr.load(h); S = dr.Schedule(W, D); trip = S.trip; tv = lambda T: [int(q in T) for q in range(h)]\n+ FULL = [[int(i == j) for j in range(h)] for i in range(h)]\n+ pr = cl.Prog(W); bas, dn = cl.spans(pr); users = cl.users_of(pr, dn)\n+ fr = cl.Frames(pr, dn, bas, users); fr.cobases(); d, _ = fr.dims(); ld, _ = cl.late_frames(fr, pr, users)\n+ log('exact base frames: %d node frames (%d lifted), %d late-copy intersections' % (len(d), len(pr.j), len(ld)))\n+\n+ # ------------------------------------------------------------------ X. recorded dims, slot paths\n+ okd = all(S.node_dims[n] == d[n] for n in pr.act) and len(S.node_dims) == len(pr.act)\n+ okd &= all(S.late_dims[n, lt] == ld[('c', n, lt)] for (n, lt) in S.late_dims) and len(S.late_dims) == len(ld)\n+ report('X. recorded frame dims == exact dims (%d node frames, %d late-copy intersections)' % (len(d), len(ld)), okd)\n+ def ukey(n, k):\n+ u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else cl.root_key(u)\n+ badp = 0\n+ for s in range(S.R):\n+ hl = S.hold[s]\n+ for a, b in zip(hl, hl[1:]): badp += b not in fr.succ[a]\n+ root = [k for k in S.chain_keys(s) if k[0] in ('out', 'ret')]\n+ if root: badp += fr.rid[root[0]] not in fr.droots[hl[-1]]\n+ st = S.start[s]\n+ if st[0] == 'fresh': # a copy starts at the use it serves\n+ nxt = ('n', hl[1]) if len(hl) > 1 else root[0]\n+ badp += ukey(hl[0], st[2]) != nxt\n+ report('X. every slot moves along slot successors of the witness, starts at its use, ends at its root (%d slots)' % S.R,\n+ badp == 0)\n+\n+ # ------------------------------------------------------------------ exact frames\n+ _eb = {}\n+ def exact(key):\n+ if key not in _eb:\n+ k = key[0]\n+ if k == 'sigma': B = S.sigma[key[1]]\n+ elif k == 'v': B = S.vstart[key[1]]\n+ elif k == '0': B = []\n+ elif k == 'F': B = FULL\n+ elif k == 'c':\n+ n, lt = key[1], key[2]\n+ B = exact(ukey(n, lt[-1]))\n+ for kk in reversed(lt[:-1]): B = fr.intersect_exact(exact(ukey(n, kk)), B)\n+ B = [prim(r) for r in B]; assert len(B) == ld[key]\n+ else: B = [prim(r) for r in fr.exact_basis(key)]\n+ _eb[key] = B\n+ return _eb[key]\n+ _nz = {}\n+ def nullZ(B):\n+ kb = tuple(map(tuple, B))\n+ if kb not in _nz: _nz[kb] = [prim(z) for z in null_exact(B, h)] if B else FULL\n+ return _nz[kb]\n+ def inside(A, B):\n+ if not A or len(B) == h: return True\n+ return all(sum(a * z for a, z in zip(ra, rz)) == 0 for ra in A for rz in nullZ(B))\n+ def nondeg(B, p=Q31): # det(9 B G B^T) != 0 mod p => != 0 over Z\n+ if not B or len(B) == h: return True\n+ sm = [sum(b) for b in B]\n+ Gr = [[9 * sum(x * y for x, y in zip(a, b)) - sa * sb for b, sb in zip(B, sm)] for a, sa in zip(B, sm)]\n+ return rank_mod(Gr, p) == len(B)\n+ gout = {T: [9 * x - 3 for x in tv(T)] for T in trip}\n+ tperp = lambda T: ('out', T[0], T) # t_T^perp is the root frame of every output (c, T)\n+\n+ # ------------------------------------------------------------------ Q. exact facts\n+ indep = all(rank_mod(B, Q31) == len(B) for B in list(S.sigma.values()) + list(S.vstart.values()))\n+ report('Q. sigma_u and s_i bases independent (rank mod 2^31-1 == row count; %d + %d frames, max |entry| %d)' % (\n+ len(S.sigma), len(S.vstart), max(abs(x) for B in list(S.sigma.values()) + list(S.vstart.values()) for r in B for x in r)), indep)\n+ sel = S.readout; F0 = {s: S.start_key(s) for s in range(S.R)}\n+ report('Q. sigma_u <= F0(u) exactly (%d deferred slots)' % len(sel), all(inside(S.sigma[s], exact(F0[s])) for s in sel))\n+ CZ = S.adjoint(); CF = [{t: 1 for t, x in dd.items() if x % 2} for dd in CZ]\n+ capbad = sum(1 for s in sel for t in CZ[s] if any(sum(a * g for a, g in zip(r, gout[trip[t]])) for r in S.sigma[s]))\n+ report('Q. sigma_u <= t_T^perp exactly for every Z-support target (a superset of the F2 targets)', capbad == 0)\n+ def ychains(co, order, frame=lambda s: S.sigma[s], limit=None):\n+ byT = defaultdict(list)\n+ for s in order:\n+ for t in co[s]: byT[t].append(s)\n+ bad = 0; levels = {}\n+ for t, ss in list(byT.items())[:limit]:\n+ seq = [frame(s) for s in ss]\n+ for A, B in zip(seq, seq[1:]):\n+ if A is B: continue\n+ if len(A) > len(B) or not inside(A, B): bad += 1\n+ lv = []\n+ for s in ss:\n+ if not lv or S.f[lv[-1]] != S.f[s]: lv.append(s)\n+ levels[t] = lv\n+ return bad, levels\n+ bZ, levZ = ychains(CZ, sel); bF, levF = ychains(CF, sel)\n+ report('Q. deferred levels on every y_T nested in time order, exactly (Z targets %d bad, F2 targets %d bad)' % (bZ, bF),\n+ bZ == 0 and bF == 0)\n+ nd = sum(1 for B in list(S.sigma.values()) + list(S.vstart.values()) if not nondeg(B))\n+ report('Q. G nondegenerate on every sigma_u and s_i (Gram det != 0 mod 2^31-1 => over Z)', nd == 0)\n+ bad_t = bad_n = 0\n+ for s, n in S.srcop.items():\n+ bad_t += not inside([tv(trip[n - 1])], S.vstart[s])\n+ N1 = S.chain_keys(s)[2] # first frame of the use after its start\n+ bad_n += not inside(S.vstart[s], exact(N1))\n+ report('Q. V leaves exactly: t_S <= s_i (%d bad), s_i <= N_i, the first frame of the use (%d bad), %d slots' % (\n+ bad_t, bad_n, len(S.srcop)), bad_t == bad_n == 0)\n+ def xchains(order_fn):\n+ bad = 0; steps = []\n+ for n, us in S.xs:\n+ seq = [[tv(trip[n - 1])]] + [S.vstart[s] for s in order_fn(us)] + [FULL]\n+ keys = [('n', n)] + [('v', s) for s in order_fn(us)] + [('F',)]\n+ for (A, ka), (B, kb) in zip(zip(seq, keys), zip(seq[1:], keys[1:])):\n+ if len(A) > len(B) or not inside(A, B): bad += 1\n+ steps.append(keys)\n+ return bad, steps\n+ bx, xkeys = xchains(lambda us: us)\n+ report('Q. X_S chains nested exactly in time order (, early V gates, deferred V gates, F; %d leaves)' % len(S.xs), bx == 0)\n+\n+ # ------------------------------------------------------------------ S. side lemma on the new high-rank steps\n+ ops0, chains0, _, R0 = cl.compile_(pr, dn, users)\n+ def dimof0(k):\n+ if k == ('0',): return 0\n+ if k == ('F',): return h\n+ if k[0] in ('out', 'ret'): return h - 1\n+ if k[0] == 'c': return ld[k]\n+ return d[k[1]]\n+ _, base_steps = cl.chain_steps(chains0, dimof0, h)\n+ base_frames = {k for e in base_steps for k in e}\n+ def dimx(k): return len(exact(k)) if k[0] in ('sigma', 'v') else dimof0(k)\n+ new = {}\n+ def add_chain(keys, kind):\n+ prev = keys[0]; pd = dimx(prev)\n+ for k in keys[1:]:\n+ dk = dimx(k)\n+ if dk > pd:\n+ if (prev, k) not in base_steps and 2 * (dk - pd) > h: new.setdefault((prev, k), (dk - pd, kind))\n+ prev, pd = k, dk\n+ else: prev = k\n+ for s in range(S.R):\n+ add_chain(S.chain_keys(s), 'slot')\n+ if S.f[s]: add_chain([('sigma', s), ('F',)], 'corner')\n+ for t, lv in levZ.items():\n+ add_chain([('0',)] + [('sigma', s) for s in lv] + [tperp(trip[t])], 'ydata')\n+ for t, lv in levF.items():\n+ add_chain([('0',)] + [('sigma', s) for s in lv] + [tperp(trip[t])], 'ydata')\n+ for keys in xkeys: add_chain(keys, 'xdata')\n+ extra = {('sigma', s): B for s, B in S.sigma.items()}; extra.update({('v', s): B for s, B in S.vstart.items()})\n+ mq = ModQ7(fr, ld, extra)\n+ used = {k for e in new for k in e} - base_frames\n+ ndq = sum(1 for k in used if not mq.nondeg(k))\n+ report('S. frames used only by the new steps: %d, G-degenerate mod 2^31-1 %d, reduction dimension mismatches %d' % (\n+ len(used), ndq, mq.dimfail), ndq == 0 and mq.dimfail == 0)\n+ pr_ = predicted(h); q = mq.q\n+ def lemma(items, m):\n+ bad = 0\n+ for (A, B), (r, _) in items:\n+ QA, QB = m.conjugated(A), m.conjugated(B)\n+ for t in range(2):\n+ a, b = QA[t], QB[t]\n+ M = [[(b[i * h + c] - a[i * h + c]) % q for c in range(h)] for i in range(h)]\n+ if rightmost_pivots(M, q) != pr_[r]: bad += 1\n+ return bad\n+ items = sorted(new.items(), key=lambda e: (str(e[0][1]), str(e[0][0])))\n+ badL = lemma(items, mq)\n+ report('S. side lemma (generic NE pivots, both conjugations, mod 2^31-1) on all %d new high-rank steps %s' % (\n+ len(items), dict(Counter(k for _, k in new.values()))), badL == 0)\n+\n+ # ------------------------------------------------------------------ F. histogram from exact dims\n+ import moment\n+ from certificate_round3 import evaluate\n+ def dim_exact(k): return dimx(k)\n+ rk = dr.chain_ranks(S, dim_exact)\n+ xd = S.xdata(lambda s: len(exact(('v', s))))\n+ okx = all(sum(x) == h - 1 for x in xd)\n+ ylZ = S.ylevels(CZ); ylF = {t: sorted({S.f[s] for s in sel if t in CF[s]}) for t in range(S.v)}\n+ res = {}\n+ for corner_name, corner in (('round-six corner', dr.ROUND6_CORNER(h)), ('staircase corner', dr.STAIRCASE_CORNER(h))):\n+ for yname, yl in (('Z', ylZ), ('F2', ylF)):\n+ c = dr.histogram(S, rk, yl, xd, corner)\n+ rs = sum(w * n for w, n in c['hist'].items())\n+ a, _ = moment.certify(c)\n+ k = evaluate(a, Fr(36926111, 5 * 10**11), Fr(1, 1000), 'crude', m_c=576, s_c=119453132304)\n+ res[corner_name, yname] = (a, k['kappa'], k['ok'], rs == c['s'] and max(c['hist']) < c['m'])\n+ for corner_name in ('round-six corner', 'staircase corner'):\n+ (aZ, kZ, oZ, sZ), (aF, kF, oF, sF) = res[corner_name, 'Z'], res[corner_name, 'F2']\n+ report('F. %s: rank sum == s (Z and F2 y supports), a_b = %s (%.6e), kappa = %s (%.7e) ok=%s, F2 a_b = %s' % (\n+ corner_name, aZ, float(aZ), kZ, float(kZ), oZ, aF), sZ and sF and oZ and oF and okx)\n+ report('F. claims: a_b 12599/200000000, kappa 6299103187973/10^17; staircase a_b 31987/500000000, kappa 1599247689723/(2.5*10^16)',\n+ res['round-six corner', 'Z'][:2] == (Fr(12599, 200000000), Fr(6299103187973, 10**17)) and\n+ res['staircase corner', 'Z'][:2] == (Fr(31987, 500000000), Fr(1599247689723, 25 * 10**15)))\n+\n+ # ------------------------------------------------------------------ N. negative controls\n+ bZr, _ = ychains(CZ, list(reversed(sel)))\n+ report('N. NEG reversed readout order breaks the y_T chains (%d bad)' % bZr, bZr > 0)\n+ bF0, _ = ychains(CF, sorted(sel, key=lambda s: (dimx(F0[s]), s)), frame=lambda s: exact(F0[s]), limit=300)\n+ report('N. NEG readouts at F0(u) instead of sigma_u break the y_T chains (%d breaks on 300 targets)' % bF0, bF0 > 0)\n+ rng = random.Random(5); pert = tot = 0\n+ for s in [s for s in sel if dimx(F0[s]) < h][:200]:\n+ B = [r[:] for r in S.sigma[s]]; B[0] = [x + rng.randint(1, 3) for x in B[0]]; tot += 1\n+ pert += not inside(B, exact(F0[s]))\n+ report('N. NEG perturbed sigma frames fail sigma <= F0 (%d / %d)' % (pert, tot), tot and pert >= 0.9 * tot)\n+ early = set(S.srcop) - S.sel\n+ bxr, _ = xchains(lambda us: [s for s in us if s not in early] + [s for s in us if s in early])\n+ report('N. NEG deferred V gates before the early ones break the X_S chains (%d bad)' % bxr, bxr > 0)\n+ mq0 = ModQ7(fr, ld, extra, control=True)\n+ badc = lemma(items[:300], mq0)\n+ report('N. NEG side lemma with U = V = I fails (%d / %d)' % (badc, 2 * min(300, len(items))), badc > 0)\n+ log('ALL %s' % ('PASS' if all(OK.values()) else 'FAIL: ' + str([k for k, x in OK.items() if not x])))\n+ return all(OK.values())\n+\n+\n+if __name__ == '__main__':\n+ sys.exit(0 if main(int(sys.argv[1]) if len(sys.argv) > 1 else 23) else 1)" + }, + { + "sha": "4a19240e2fe5f55891d842fd451bd0cb24e4ae76", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_lifted.py", + "status": "added", + "additions": 677, + "deletions": 0, + "changes": 677, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_lifted.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_lifted.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_lifted.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,677 @@\n+\"\"\"Release check (stdlib only) of the lifted-frame + late-copy bit side program, stacked with the staircase corner.\n+\n+Input: certificates/round7/witness_.json.gz: the side DAG (leaves = triples of [h], additions), outputs (c, T),\n+retained totals, links (donor x -> use (y, k)), the flag matrix F (integer h x h), the lift index j(n) of every\n+lifted addition and the late-copy decisions (early users, ordered late users) per node.\n+\n+What is checked, from the witness alone:\n+ A. DAG semantics: disjoint supports; output (c,T) support = {S : c in S, S cap T = {c}}; retained = star(c).\n+ B. Compile: one slot per role, schedule order (dim span, id), links hand the donor's non-pivot slot to the linked\n+ use; late copies: the pivot of n climbs C_1 <= ... <= C_k (C_i = frames of users late[i:] intersected) and the\n+ copy for late user i is a gate (pivot, fresh slot) at C_i, placed in time as LATE as possible (just before the\n+ first of: its user's gate, the pivot's consumer gate, the next copy's slot). R = adds + outputs + retained - links.\n+ C. Dirty-scratch replay of the compiled program: word L J L^-1 V L J L^-1 V^-1 and its mirror, arbitrary scratch,\n+ over F2 and over Z, reads at the slot's last touch and at the end; targets must receive J L V x exactly\n+ (DAG values) and every slot is restored; over F2 every target also receives exactly x_T.\n+ D. Frames (exact over Q). Frame of addition n: M_n = span(n) + (U_n cap F_j(n)), U_n = common kernel of the root\n+ covectors reachable from n ((9I-J) t_T for an output to Y_T, 1 - 3 e_c for a retained use of c), F_j = first j\n+ rows of F. Nesting is a THEOREM given the combinatorial facts checked here:\n+ j(n) <= j(t) on every slot successor pair n -> t; span(x) <= span(t) on every link pair (exact);\n+ span(n) <= every root frame n reaches directly (exact integer dot products); F invertible.\n+ Then U_n <= U_t, so M_n <= M_t, M_n <= U_n <= every reachable root frame, and every late-copy frame C_i\n+ (an intersection of frames that all contain M_n) is nested. Dimensions (exact, see linalg.py):\n+ dim M_n = rank[span(n); F_j] - rank(K_n F_j^T) (modular law; span(n) <= U_n; K_n spans the root covectors),\n+ with ranks by mod-p + Hadamard certificates, Bareiss when the mod-p rank is not full; late-copy intersections by\n+ exact Fraction bases. Rank of every chain step = difference of dimensions (nested), histogram vs claim.\n+ E. Frame reductions mod q = 2^31-1 (dimension-matched, so they are the reductions of the rational frames),\n+ G = I - J/9 nondegenerate on every frame of every step (Gram matrix invertible mod q => over Q), and the side\n+ lemma at ONE integer point (U, V of point_UV(h, 1), the random stream of independent/two-stage-bit/flag_existence.py): for every distinct step A -> B of\n+ rank r with 2r > h (retained copy edges 0 -> U_c included), U^T (P_B - P_A) U^-T and V^T (..) V^-T have the\n+ generic north-east pivots of f_r. (NE ranks mod q <= over Q <= f_r, so equality mod q proves it over Q.)\n+ F. Certificate: rt_histogram with the round-6 entrance corner and with the staircase corner (m-4h+2, h-2, h-5, 1^6),\n+ rank sum == s, moment.certify (exact), kappa = certificate_round3.evaluate(a_b, round-6 complex values).\n+Negative controls (CONTROL=1): see controls().\n+Usage: python3 check_lifted.py h [--no-generic]\"\"\"\n+import sys, os, json, random, time\n+from itertools import combinations\n+from collections import Counter, OrderedDict\n+from fractions import Fraction as Fr\n+from array import array\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, HERE)\n+from linalg import *\n+\n+T0 = time.time()\n+def load_witness(h):\n+ import gzip\n+ with gzip.open(os.path.join(HERE, '..', '..', 'certificates', 'round7', 'witness_%d.json.gz' % h), 'rt') as fh:\n+ return json.load(fh)\n+\n+\n+def log(*a):\n+ print('[%5.0fs]' % (time.time() - T0), *a, flush=True)\n+\n+\n+# ----------------------------------------------------------------------------------------------- A. DAG\n+class Prog:\n+ def __init__(self, W):\n+ self.W = W; h = self.h = W['h']\n+ self.trip = list(combinations(range(h), 3)); v = self.v = len(self.trip)\n+ self.args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}\n+ self.act = sorted(self.args)\n+ for n in self.act:\n+ if self.args[n] is None: assert 1 <= n <= v and tuple(W['leaf'][str(n)]) == self.trip[n - 1]\n+ else: assert all(a < n and a in self.args for a in self.args[n]), n\n+ self.sup = {}\n+ for n in self.act:\n+ if self.args[n] is None: self.sup[n] = 1 << (n - 1)\n+ else:\n+ a, b = self.args[n]; assert not self.sup[a] & self.sup[b], 'overlapping supports'\n+ self.sup[n] = self.sup[a] | self.sup[b]\n+ self.outputs = {(c, tuple(T)): n for c, T, n in W['outputs']}\n+ self.retained = {c: n for c, n in W['retained']}\n+ star = [sum(1 << i for i, t in enumerate(self.trip) if q in t) for q in range(h)]\n+ assert len(self.outputs) == 3 * v and len(self.retained) == h\n+ for (c, T), n in self.outputs.items():\n+ A, B = [q for q in T if q != c]; assert c in T and self.sup[n] == star[c] & ~star[A] & ~star[B]\n+ for c, n in self.retained.items(): assert self.sup[n] == star[c]\n+ roots = set(self.outputs.values()) | set(self.retained.values()); reach = set(); st = list(roots)\n+ while st:\n+ n = st.pop()\n+ if n in reach: continue\n+ reach.add(n)\n+ if self.args[n]: st.extend(self.args[n])\n+ assert reach == set(self.act), 'inactive nodes in witness'\n+ self.mL = {x: (y, k) for x, y, k in W['links']}\n+ self.j = {int(n): j for n, j in W['j'].items()}\n+ self.late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}\n+ self.F = W['flag']\n+\n+\n+def trow(h, S): return [int(q in S) for q in range(h)]\n+\n+\n+def spans(pr):\n+ \"\"\"independent triple subsets (exact: 0/1 rows with three ones, every minor < 3^(h/2) < Q31) and dims.\"\"\"\n+ h = pr.h; assert 3 ** h < Q31 ** 2\n+ bas = {}; dn = {}\n+ for n in pr.act:\n+ if pr.args[n] is None: bas[n] = (n - 1,); dn[n] = 1; continue\n+ a, b = pr.args[n]; E = Echelon(Q31); keep = []\n+ for i in bas[a] + bas[b]:\n+ if len(E) == h: break\n+ if E.insert(trow(h, pr.trip[i])): keep.append(i)\n+ bas[n] = tuple(keep); dn[n] = len(keep)\n+ return bas, dn\n+\n+\n+def users_of(pr, dn):\n+ key = lambda n: (dn[n], n); users = {n: [] for n in pr.act}\n+ for n in sorted(pr.act, key=key):\n+ if pr.args[n]:\n+ for pos, x in enumerate(pr.args[n]): users[x].append(('gate', n, pos))\n+ for (c, T), n in sorted(pr.outputs.items()): users[n].append(('out', (c, T)))\n+ for c, n in sorted(pr.retained.items()): users[n].append(('ret', c))\n+ return users\n+\n+\n+# ----------------------------------------------------------------------------------------------- B. compile\n+def root_key(u): return ('out',) + u[1] if u[0] == 'out' else ('ret', u[1])\n+\n+\n+def compile_(pr, dn, users, late=True, defer=True, tamper=None):\n+ \"\"\"returns ops (scalar program), chains (frame keys per slot), reads, R. tamper: negative-control hooks.\"\"\"\n+ key = lambda n: (dn[n], n); order = sorted(pr.act, key=key); gpos = {n: i for i, n in enumerate(order)}\n+ linked = {r: x for x, r in pr.mL.items()}\n+ chains = []; edge = {}; reads = []; ops = []; deferred = []\n+ def new(first): chains.append(list(first)); return len(chains) - 1\n+ def assign(s, n, k):\n+ u = users[n][k]\n+ if u[0] == 'gate': edge[u[1], u[2]] = s\n+ else:\n+ chains[s] += [root_key(u), ('F',)]\n+ reads.append((s, [u[1][1]] if u[0] == 'out' else [T for T in pr.trip if u[1] in T]))\n+ def ufr(n, k):\n+ u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u)\n+ for n in order:\n+ if pr.args[n] is None:\n+ piv = new([('0',), ('n', n)]); ops.append(('src', piv, n, n))\n+ else:\n+ a, b = pr.args[n]; sa, sb = edge.pop((n, 0)), edge.pop((n, 1))\n+ if n in pr.mL and pr.mL[n][0] == a: sa, sb = sb, sa # the linked operand stays on the non-pivot\n+ piv, oth = sa, sb\n+ chains[piv].append(('n', n)); chains[oth].append(('n', n)); ops.append(('add', piv, oth, n))\n+ if n in pr.mL: y, k = pr.mL[n]; assign(oth, y, k)\n+ else: chains[oth].append(('F',))\n+ ks = [k for k in range(len(users[n])) if (n, k) not in linked]\n+ if late and n in pr.late:\n+ early, lt = pr.late[n]; assert sorted(early + lt) == ks, ('bad late decision', n)\n+ else: early, lt = ks[1:], [ks[0]]\n+ for k in early:\n+ f = new([('0',), ('n', n)]); ops.append(('copy', piv, f, n)); assign(f, n, k)\n+ for i, k in enumerate(lt):\n+ Ck = ufr(n, k) if i == len(lt) - 1 else ('c', n, tuple(lt[i:]))\n+ if tamper == 'nointersect' and i < len(lt) - 1: Ck = ufr(n, k)\n+ chains[piv].append(Ck)\n+ if i < len(lt) - 1:\n+ f = new([('0',), Ck]); deferred.append((n, i, f, k, lt[-1])); assign(f, n, k)\n+ k = lt[-1]\n+ if users[n][k][0] == 'gate': edge[users[n][k][1], users[n][k][2]] = piv\n+ else: assign(piv, n, k)\n+ assert not edge\n+ # place deferred copies: as late as possible, in order, before the user's gate and the pivot consumer's gate\n+ INF = len(order); byn = {}\n+ for (n, i, f, k, kl) in deferred: byn.setdefault(n, []).append((i, f, k, kl))\n+ ins = {}\n+ for n, lst in byn.items():\n+ lst.sort(); D = []\n+ for i, f, k, kl in lst:\n+ u, ul = users[n][k], users[n][kl]\n+ d = min(gpos[u[1]] if u[0] == 'gate' else INF, gpos[ul[1]] if ul[0] == 'gate' else INF)\n+ D.append(d)\n+ for t in range(len(D) - 2, -1, -1): D[t] = min(D[t], D[t + 1])\n+ for (i, f, k, kl), d in zip(lst, D):\n+ if not defer: d = gpos[n] + 1 # immediate copy (still a valid program)\n+ if tamper == 'aftercons' and n == tamper_node[0] and i == 0:\n+ ul = users[n][kl]; d = gpos[ul[1]] + 1 # copy AFTER the pivot was consumed\n+ ins.setdefault(d, []).append((n, i, f))\n+ pivslot = {}\n+ for o in ops:\n+ if o[0] in ('src', 'add'): pivslot[o[3]] = o[1]\n+ out = []\n+ for o in ops:\n+ if o[0] in ('src', 'add'):\n+ for (n, i, f) in sorted(ins.get(gpos[o[3]], []), key=lambda z: (gpos[z[0]], z[1])):\n+ out.append(('copy', pivslot[n], f, n))\n+ out.append(o)\n+ for (n, i, f) in sorted(ins.get(INF, []) + [z for d, zs in ins.items() if d > INF for z in zs], key=lambda z: (gpos[z[0]], z[1])):\n+ out.append(('copy', pivslot[n], f, n))\n+ if tamper == 'dropcopy':\n+ idx = next(i for i, o in enumerate(out) if o[0] == 'copy' and o[3] in pr.late); out.pop(idx)\n+ R = len(chains); adds = sum(1 for n in pr.act if pr.args[n])\n+ assert R == adds + len(pr.outputs) + len(pr.retained) - len(pr.mL), 'role count'\n+ return out, chains, reads, R\n+\n+tamper_node = [None]\n+\n+\n+# ----------------------------------------------------------------------------------------------- C. replay\n+def replay(pr, ops, reads, R, ring, rng, mirror=False, midread=True):\n+ trip, v = pr.trip, pr.v; tid = {T: i for i, T in enumerate(trip)}\n+ mod = (lambda z: z & 1) if ring == 2 else (lambda z: z)\n+ last = {}\n+ for i, o in enumerate(ops):\n+ last[o[1]] = i\n+ if o[0] != 'src': last[o[2]] = i\n+ readers = {}\n+ for s, Ts in reads: readers.setdefault(last[s] if midread else len(ops) - 1, []).append((s, Ts))\n+ x = [rng.randrange(-10**6, 10**6) for _ in range(v)]\n+ a0 = [rng.randrange(-10**6, 10**6) for _ in range(R)]; y0 = [rng.randrange(-10**6, 10**6) for _ in range(v)]\n+ a = list(a0); y = list(y0); src = [(o[1], o[2]) for o in ops if o[0] == 'src']\n+ def L(sg=None):\n+ for i, o in enumerate(ops):\n+ if o[0] == 'add': a[o[1]] += a[o[2]]\n+ elif o[0] == 'copy': a[o[2]] += a[o[1]]\n+ if sg is not None:\n+ for s, Ts in readers.get(i, ()):\n+ for T in Ts: y[tid[T]] += sg * a[s]\n+ def Li():\n+ for o in reversed(ops):\n+ if o[0] == 'add': a[o[1]] -= a[o[2]]\n+ elif o[0] == 'copy': a[o[2]] -= a[o[1]]\n+ def V(sg):\n+ for s, n in src: a[s] += sg * x[n - 1]\n+ if not mirror: L(-1); Li(); V(+1); L(+1); Li(); V(-1)\n+ else: V(+1); L(+1); Li(); V(-1); L(-1); Li()\n+ if any(mod(p - q) for p, q in zip(a, a0)): return False\n+ val = {}\n+ for n in pr.act: val[n] = x[n - 1] if pr.args[n] is None else val[pr.args[n][0]] + val[pr.args[n][1]]\n+ want = list(y0)\n+ for (c, T), n in pr.outputs.items(): want[tid[T]] += val[n]\n+ for c, n in pr.retained.items():\n+ for T in trip:\n+ if c in T: want[tid[T]] += val[n]\n+ if any(mod(p - q) for p, q in zip(y, want)): return False\n+ if ring == 2 and any(mod(y[i] - y0[i] - x[i]) for i in range(v)): return False\n+ return True\n+\n+\n+# ----------------------------------------------------------------------------------------------- D. frames\n+class Frames:\n+ def __init__(self, pr, dn, bas, users):\n+ self.pr = pr; self.dn = dn; self.bas = bas; self.users = users; h = self.h = pr.h\n+ self.rootcov = {}\n+ for (c, T) in pr.outputs: self.rootcov[('out', c, T)] = [9 * int(q in T) - 3 for q in range(h)]\n+ for c in pr.retained: self.rootcov[('ret', c)] = [1 - 3 * int(q == c) for q in range(h)]\n+ rid = {k: i for i, k in enumerate(sorted(self.rootcov))}; self.rkeys = sorted(self.rootcov)\n+ self.rid = rid\n+ # slot successors (same for base and late compile: every free use of n is reached by one slot from n,\n+ # a donor's non-pivot slot goes on to its linked use) and direct roots\n+ linked = {r: x for x, r in pr.mL.items()}\n+ self.succ = {n: set() for n in pr.act}; self.droots = {n: set() for n in pr.act}\n+ def to(n, use):\n+ if use[0] == 'gate': self.succ[n].add(use[1])\n+ else: self.droots[n].add(rid[root_key(use)])\n+ for n in pr.act:\n+ for k, u in enumerate(users[n]):\n+ if (n, k) not in linked: to(n, u)\n+ if n in pr.mL: y, k = pr.mL[n]; to(n, users[y][k])\n+\n+ def check_structure(self):\n+ \"\"\"combinatorial / exact facts behind the nesting theorem.\"\"\"\n+ pr, h = self.pr, self.h; bad_j = bad_link = bad_root = 0\n+ J = lambda n: self.pr.j.get(n, 0)\n+ for n in pr.act:\n+ if pr.args[n] is None: assert J(n) == 0\n+ for t in self.succ[n]:\n+ if J(n) > J(t): bad_j += 1\n+ for x, (y, k) in pr.mL.items(): # span(x) <= span(linked use target)\n+ u = self.users[y][k]\n+ if u[0] == 'gate':\n+ t = u[1]; E = Echelon(Q31)\n+ for i in self.bas[t]: E.insert(trow(h, pr.trip[i]))\n+ if not all(E.contains(trow(h, pr.trip[i])) for i in self.bas[x]): bad_link += 1\n+ for n in pr.act: # span(n) <= direct root frames\n+ for r in self.droots[n]:\n+ g = self.rootcov[self.rkeys[r]]\n+ if any(sum(gq * tq for gq, tq in zip(g, trow(h, pr.trip[i]))) for i in self.bas[n]): bad_root += 1\n+ # F invertible over Q (a nonzero determinant mod a prime)\n+ F_ok = rank_mod(self.pr.F, Q31) == h\n+ return bad_j, bad_link, bad_root, F_ok\n+\n+ def cobases(self):\n+ \"\"\"K_n: independent subset of the root covectors reachable from n, spanning all of them over Q\n+ (selection mod M127, valid by the Hadamard certificate on root covectors).\"\"\"\n+ pr, h = self.pr, self.h\n+ rows = [self.rootcov[k] for k in self.rkeys]\n+ mx = max(sum(x * x for x in r) for r in rows); assert mx ** h < M127 ** 2, 'Hadamard bound for K'\n+ key = lambda n: (self.dn[n], n); K = {}\n+ for n in sorted(pr.act, key=key, reverse=True):\n+ cand = sorted(self.droots[n]); srcs = sorted((K[t] for t in self.succ[n]), key=len, reverse=True)\n+ cap = h - self.dn[n] # span(n) <= U_n\n+ if not cand and len(srcs) == 1: K[n] = srcs[0]; continue\n+ E = Echelon(M127); keep = []\n+ seq = list(srcs[0]) if srcs else []\n+ for r in seq: E.insert(rows[r]); keep.append(r) # srcs[0] is already independent\n+ for lst in [cand] + srcs[1:]:\n+ for r in lst:\n+ if len(keep) >= cap: break\n+ if E.insert(rows[r]): keep.append(r)\n+ K[n] = tuple(keep)\n+ self.K = K\n+ return K\n+\n+ def dims(self):\n+ \"\"\"exact dim of every addition frame M_n.\"\"\"\n+ pr, h = self.pr, self.h; F = pr.F; d = dict(self.dn); stats = Counter()\n+ rows = [self.rootcov[k] for k in self.rkeys]\n+ self.KF = {}\n+ for n, j in pr.j.items():\n+ Fj = F[:j]; K = [rows[r] for r in self.K[n]]\n+ KF = [[sum(a * b for a, b in zip(kr, fr)) for fr in Fj] for kr in K]\n+ SF = [trow(h, pr.trip[i]) for i in self.bas[n]] + Fj\n+ r1 = self._rank(SF, min(len(SF), h), stats, 'SF'); r2 = self._rank(KF, min(len(K), j), stats, 'KF')\n+ d[n] = r1 - r2; self.KF[n] = (r2, KF)\n+ assert self.dn[n] <= d[n] <= h - len(K)\n+ self.d = d\n+ return d, stats\n+\n+ @staticmethod\n+ def _rank(M, full, stats, tag):\n+ if not M or full == 0: return 0\n+ r = rank_mod(M, Q31)\n+ if r == full: stats[tag + ' full mod q'] += 1; return r # rank mod q <= rank over Q <= full\n+ if hadamard_ok(M, M521): stats[tag + ' M521'] += 1; return rank_mod(M, M521)\n+ stats[tag + ' Bareiss'] += 1; return rank_exact(M)\n+\n+ # exact rational bases, used for the late-copy intersections\n+ def exact_basis(self, key):\n+ pr, h = self.pr, self.h\n+ if key[0] in ('out', 'ret'):\n+ return null_exact([self.rootcov[key]], h)\n+ n = key[1]\n+ S = [trow(h, pr.trip[i]) for i in self.bas[n]]\n+ j = pr.j.get(n, 0)\n+ if not j: return S\n+ _, KF = self.KF[n]; F = pr.F[:j]\n+ X = null_exact(KF, j) if KF else [[int(i == t) for t in range(j)] for i in range(j)]\n+ vecs = S + [[sum(c * F[i][q] for i, c in enumerate(x)) for q in range(h)] for x in X]\n+ # independent subset: rows independent mod q are independent over Q; d of them span M_n (dim M_n = d exactly)\n+ E = Echelon(Q31); out = []\n+ for vv in vecs:\n+ if E.insert(vv): out.append(vv)\n+ assert len(out) == self.d[n], ('exact basis dim', n, len(out), self.d[n])\n+ return out\n+\n+ def intersect_exact(self, A, B):\n+ h = self.h\n+ if not A or not B: return []\n+ # z = (x, y): x A = y B <=> [A; -B]^T z = 0\n+ M = [[A[i][q] for i in range(len(A))] + [-B[i][q] for i in range(len(B))] for q in range(h)]\n+ Z = null_exact(M, len(A) + len(B))\n+ # A and B are bases, so z -> x A is injective on the null space: the images are a basis of A cap B\n+ return [[sum(z[i] * A[i][q] for i in range(len(A))) for q in range(h)] for z in Z]\n+\n+\n+def late_frames(fr, pr, users):\n+ \"\"\"exact dims of every late-copy intersection frame ('c', n, late users).\"\"\"\n+ cache = {}; dims = {}\n+ def eb(k):\n+ if k not in cache: cache[k] = fr.exact_basis(k)\n+ return cache[k]\n+ def ufr(n, k):\n+ u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u)\n+ for n, (early, lt) in pr.late.items():\n+ for i in range(len(lt) - 1):\n+ B = eb(ufr(n, lt[-1]))\n+ for k in reversed(lt[i:-1]): B = fr.intersect_exact(eb(ufr(n, k)), B)\n+ dims[('c', n, tuple(lt[i:]))] = len(B)\n+ return dims, cache\n+\n+\n+def chain_steps(chains, dimof, h):\n+ rk = Counter(); steps = {}\n+ for ch in chains:\n+ prev = ch[0]; pd = dimof(prev)\n+ for k in ch[1:]:\n+ dk = dimof(k)\n+ assert dk >= pd, ('decreasing chain', prev, k, pd, dk)\n+ if dk > pd: rk[dk - pd] += 1; steps[prev, k] = dk - pd; prev, pd = k, dk\n+ else: prev = k # equal dims, nested => equal frames\n+ assert pd == h\n+ return rk, steps\n+\n+\n+# ----------------------------------------------------------------------------------------------- E. mod-q frames, side lemma\n+def point_UV(h, seed):\n+ \"\"\"the U, V drawn by independent/two-stage-bit/flag_existence.py with this seed (same random stream).\"\"\"\n+ CR = 10**6; rng = random.Random(seed)\n+ nz = lambda: rng.choice([-1, 1]) * rng.randint(1, CR)\n+ for b in range(h):\n+ for i in range(h):\n+ for jj in range(h):\n+ if i <= b and jj <= b: nz()\n+ for b in range(h):\n+ for i in range(h):\n+ for jj in range(h):\n+ if i >= b and jj >= b: nz()\n+ U = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)]\n+ V = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)]\n+ return U, V\n+\n+\n+class ModQ:\n+ def __init__(self, fr, latedims, control=False):\n+ self.fr = fr; self.h = h = fr.h; self.q = q = Q31; self.latedims = latedims\n+ U, V = point_UV(h, 1)\n+ if control: U = [[int(i == k) for k in range(h)] for i in range(h)]; V = [r[:] for r in U]\n+ self.conj = []\n+ for A in (U, V):\n+ Ai = inv_mod_matrix(A, q); assert Ai is not None\n+ self.conj.append(([list(c) for c in zip(*A)], Ai)) # columns of A, rows of A^-1\n+ self.inv9 = pow(9, q - 2, q); self.bcache = {}; self.qcache = OrderedDict(); self.cap = 6000\n+ self.degenerate = 0; self.dimfail = 0\n+\n+ def basis(self, key):\n+ if key in self.bcache: return self.bcache[key]\n+ fr, h, q = self.fr, self.h, self.q; pr = fr.pr\n+ if key == ('0',): B = []\n+ elif key == ('F',): B = [[int(i == t) for t in range(h)] for i in range(h)]\n+ elif key[0] in ('out', 'ret'): B = null_mod([fr.rootcov[key]], h, q)\n+ elif key[0] == 'c':\n+ n, lt = key[1], key[2]\n+ B = None\n+ for k in lt:\n+ u = fr.users[n][k]; kk = ('n', u[1]) if u[0] == 'gate' else root_key(u)\n+ Bk = self.basis(kk)\n+ B = Bk if B is None else self._cap(B, Bk)\n+ if len(B) != self.latedims[key]: self.dimfail += 1\n+ else:\n+ n = key[1]; S = [trow(h, pr.trip[i]) for i in fr.bas[n]]; j = pr.j.get(n, 0)\n+ E = Echelon(q)\n+ for r in S: E.insert(r)\n+ if j:\n+ r2, KF = fr.KF[n]\n+ if KF and rank_mod(KF, q) != r2: self.dimfail += 1\n+ X = null_mod(KF, j, q) if KF else [[int(i == t) for t in range(j)] for i in range(j)]\n+ Fj = pr.F[:j]\n+ for x in X: E.insert([sum(c * Fj[i][t] for i, c in enumerate(x)) % q for t in range(h)])\n+ B = E.rows\n+ if len(B) != fr.d[n]: self.dimfail += 1\n+ self.bcache[key] = B\n+ return B\n+\n+ def _cap(self, A, B):\n+ q, h = self.q, self.h\n+ if not A or not B: return []\n+ M = [[A[i][t] for i in range(len(A))] + [(-B[i][t]) % q for i in range(len(B))] for t in range(h)]\n+ Z = null_mod(M, len(A) + len(B), q); E = Echelon(q)\n+ for z in Z: E.insert([sum(z[i] * A[i][t] for i in range(len(A))) % q for t in range(h)])\n+ return E.rows\n+\n+ def gram_inv(self, B):\n+ q = self.q; BG = [[(x - sum(b) * self.inv9) % q for x in b] for b in B]\n+ Gr = [[sum(x * y for x, y in zip(bg, c)) % q for c in B] for bg in BG]\n+ return BG, inv_mod_matrix(Gr, q)\n+\n+ def nondeg(self, key):\n+ B = self.basis(key)\n+ if not B or len(B) == self.h: return True\n+ return self.gram_inv(B)[1] is not None\n+\n+ def conjugated(self, key):\n+ \"\"\"(U^T P U^-T, V^T P V^-T) for the G-orthogonal projector P onto the frame, flattened.\"\"\"\n+ if key in self.qcache: self.qcache.move_to_end(key); return self.qcache[key]\n+ h, q = self.h, self.q; B = self.basis(key)\n+ if not B: out = (array('q', [0] * h * h),) * 2\n+ elif len(B) == h: I = array('q', [int(i == t) for i in range(h) for t in range(h)]); out = (I, I)\n+ else:\n+ BG, Gi = self.gram_inv(B)\n+ if Gi is None: raise ZeroDivisionError(key)\n+ res = []\n+ for Acols, Ai in self.conj:\n+ LU = [[sum(x * y for x, y in zip(ac, b)) % q for b in B] for ac in Acols] # A^T B^T (h x d)\n+ RU = [[sum(x * y for x, y in zip(bg, ai)) % q for ai in Ai] for bg in BG] # B G A^-T (d x h)\n+ Mi = matmul(Gi, RU, q)\n+ Mt = list(zip(*Mi))\n+ res.append(array('q', [sum(x * y for x, y in zip(l, c)) % q for l in LU for c in Mt]))\n+ out = tuple(res)\n+ self.qcache[key] = out\n+ if len(self.qcache) > self.cap: self.qcache.popitem(last=False)\n+ return out\n+\n+\n+def side_lemma(mq, steps, h, retained):\n+ q = mq.q; pr_ = predicted(h); E = dict((k, r) for k, r in steps.items() if 2 * r > h)\n+ for c in retained: E[('0',), ('ret', c)] = h - 1 # retained copy edges 0 -> U_c\n+ keys = sorted(E, key=lambda e: (str(e[1]), str(e[0]))) # group by target frame (cache reuse)\n+ bad = 0; n = 0\n+ for (A, B) in keys:\n+ r = E[A, B]; QA, QB = mq.conjugated(A), mq.conjugated(B)\n+ for t in range(2):\n+ a, b = QA[t], QB[t]\n+ M = [[(b[i * h + c] - a[i * h + c]) % q for c in range(h)] for i in range(h)]\n+ if rightmost_pivots(M, q) != pr_[r]: bad += 1\n+ n += 1\n+ if n % 5000 == 0: log(' side lemma %d/%d, failures %d' % (n, len(keys), bad))\n+ return bad, len(keys)\n+\n+\n+# ----------------------------------------------------------------------------------------------- F. certificate\n+K_REPO = os.path.normpath(os.path.join(HERE, '..', '..'))\n+sys.path[:0] = [K_REPO + '/scripts', K_REPO + '/independent/two-stage-bit']\n+\n+\n+def inner_children(r, h): return [1] * (h - r) + [2 * r - h] if 2 * r > h else [1] * r\n+\n+\n+def rt_histogram(h, R, rk, corner):\n+ \"\"\"cert_rt.rt_histogram with the data-entrance corner profile 'corner' (round six: [h-2] + [1]*(h+1)).\"\"\"\n+ from math import comb\n+ v, m = comb(h, 3), h * h; N = v * v; A = v * R; H = Counter()\n+ assert sum(r * n for r, n in rk.items()) == h * R and sum(corner) == 2 * h - 1\n+ for _ in range(2):\n+ H[m - 2 * h] += A; H[h] += A\n+ for r, n in rk.items():\n+ for w in inner_children(r, h): H[w] += v * n\n+ for w in inner_children(h - 1, h): H[w] += v * h\n+ H[m - 4 * h + 2] += 2 * N\n+ for w in corner: H[w] += 2 * N\n+ for _ in range(2): H[h - 2] += 2 * N; H[1] += 2 * N\n+ H[1] += N\n+ W = 2 * N + 2 * A; L = 2 * v * h * (h - 1); s = W * m - N + L\n+ H = {w: c for w, c in H.items() if c}\n+ assert sum(w * c for w, c in H.items()) == s and max(H) <= m - 1\n+ return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=H)\n+\n+\n+def certificate(h, R, rk):\n+ import moment\n+ from certificate_round3 import evaluate\n+ out = {}\n+ for name, corner in (('round6 corner', [h - 2] + [1] * (h + 1)), ('staircase', [h - 2, h - 5] + [1] * 6)):\n+ c = rt_histogram(h, R, rk, corner)\n+ if c['W'] * c['m'] <= c['s']: out[name] = ('no deficit', c['s']); continue\n+ a, root = moment.certify(c)\n+ k = evaluate(a, Fr(36926111, 5 * 10**11), Fr(1, 1000), 'crude', m_c=576, s_c=119453132304)\n+ out[name] = (a, root, c['s'], c['W'], k['kappa'], k['ok'])\n+ return out\n+\n+\n+# ----------------------------------------------------------------------------------------------- main\n+def main(h, generic=True, control=False):\n+ W = load_witness(h)\n+ pr = Prog(W); log('h=%d: A. DAG semantics OK (%d nodes, %d additions, %d links, %d lifted, %d late)' % (\n+ h, len(pr.act), sum(1 for n in pr.act if pr.args[n]), len(pr.mL), len(pr.j), len(pr.late)))\n+ bas, dn = spans(pr); users = users_of(pr, dn)\n+ ops, chains, reads, R = compile_(pr, dn, users)\n+ log('B. compiled: R=%d (claimed %d), ops %d, late copies %d' % (R, W['claimed']['R'], len(ops),\n+ sum(len(l) - 1 for _, l in pr.late.values())))\n+ assert R == W['claimed']['R']\n+ rng = random.Random(h)\n+ res = {(ring, mir, mid): all(replay(pr, ops, reads, R, ring, rng, mir, mid) for _ in range(2))\n+ for ring in (2, 0) for mir in (False, True) for mid in (True, False)}\n+ log('C. dirty-scratch replay (F2/Z x word/mirror x midread/endread): %s' % ('ALL OK' if all(res.values()) else res))\n+ fr = Frames(pr, dn, bas, users)\n+ bj, bl, br, Fok = fr.check_structure()\n+ log('D. nesting facts: j-monotone failures %d, link span failures %d, root containment failures %d, F invertible %s'\n+ % (bj, bl, br, Fok))\n+ fr.cobases(); log(' co-bases K_n done')\n+ d, st = fr.dims(); log(' lifted frame dims exact: %s' % dict(st))\n+ nU = sum(1 for n in pr.j if d[n] == h - len(fr.K[n]))\n+ log(' every lifted frame is the largest admissible frame U_n: %s (%d / %d; the flag only switches span -> U_n)'\n+ % (nU == len(pr.j), nU, len(pr.j)))\n+ ld, ecache = late_frames(fr, pr, users); log(' late-copy intersections exact: %d frames' % len(ld))\n+ def dimof(k):\n+ if k == ('0',): return 0\n+ if k == ('F',): return h\n+ if k[0] in ('out', 'ret'): return h - 1\n+ if k[0] == 'c': return ld[k]\n+ return d[k[1]]\n+ rk, steps = chain_steps(chains, dimof, h)\n+ claimed = Counter({int(r): c for r, c in W['claimed']['rk'].items()})\n+ log(' chain steps: sum of ranks %d = h R %d: %s; histogram equals claim: %s; distinct steps %d (2r>h: %d)' % (\n+ sum(r * c for r, c in rk.items()), h * R, sum(r * c for r, c in rk.items()) == h * R, rk == claimed,\n+ len(steps), sum(1 for r in steps.values() if 2 * r > h)))\n+ out = dict(h=h, R=R, replay=all(res.values()), struct=(bj, bl, br, Fok), hist_ok=rk == claimed, rk=rk)\n+ if generic:\n+ mq = ModQ(fr, ld, control)\n+ frames_used = {k for e in steps for k in e} | {('ret', c) for c in pr.retained}\n+ nd = sum(1 for k in frames_used if not mq.nondeg(k))\n+ log('E. frames used %d: G-degenerate %d, reduction dimension mismatches %d' % (len(frames_used), nd, mq.dimfail))\n+ bad, ne = side_lemma(mq, steps, h, pr.retained)\n+ log(' side lemma at one integer point%s: failures %d over %d distinct high-rank steps x 2 conjugations' % (\n+ ' (CONTROL U=V=I)' if control else '', bad, ne))\n+ out.update(degenerate=nd, dimfail=mq.dimfail, side_bad=bad, side_n=ne)\n+ for name, val in certificate(h, R, rk).items():\n+ if val[0] == 'no deficit': log('F. %s: no deficit at this h (s=%d), certificate n/a' % (name, val[1])); continue\n+ a, root, s, Wr, kap, ok = val\n+ log('F. %s: s=%d W=%d a_b=%s (%.6e, root %.6e) kappa=%s (%.7e) ok=%s' % (name, s, Wr, a, float(a), root, kap,\n+ float(kap), ok))\n+ out[name] = (a, kap, ok)\n+ return out, pr, dn, users\n+\n+\n+\n+\n+# ----------------------------------------------------------------------------------------------- negative controls\n+def controls(h, nsample=40):\n+ \"\"\"Each must FAIL (or differ) for the check to have teeth:\n+ (a) one late copy moved to just after its pivot's consumer gate: replay must fail;\n+ (b) one late copy dropped: replay must fail;\n+ (c) pivot chain without intersections (C_i := frame of user i alone): exhibit non-nested consecutive pivot frames;\n+ (d) M_n rebuilt from an independent flag F' on targets strictly between span and U (vacuous for this\n+ witness: every lifted frame equals U_n, so the flag is only a switch and nesting needs no common flag);\n+ (e) side lemma at U = V = I on the first high-rank steps: generic pivots must fail;\n+ (f) no late copies (lifted frames only): histogram must change.\"\"\"\n+ W = load_witness(h)\n+ pr = Prog(W); bas, dn = spans(pr); users = users_of(pr, dn); rng = random.Random(7)\n+ key = lambda n: (dn[n], n); linked = {r: x for x, r in pr.mL.items()}\n+ cand = [n for n, (e, lt) in pr.late.items() if users[n][lt[-1]][0] == 'gate']\n+ fails = 0; tried = 0\n+ for n in cand[:nsample]:\n+ tamper_node[0] = n; ops, ch, rd, R = compile_(pr, dn, users, tamper='aftercons')\n+ ok = all(replay(pr, ops, rd, R, ring, rng) for ring in (2, 0)); tried += 1; fails += not ok\n+ log('(a) late copy moved after the pivot consumer: replay failed %d / %d (must be all)' % (fails, tried))\n+ ops, ch, rd, R = compile_(pr, dn, users, tamper='dropcopy')\n+ log('(b) one late copy dropped: replay correct %s (must be False)' % all(replay(pr, ops, rd, R, ring, rng) for ring in (2, 0)))\n+ fr = Frames(pr, dn, bas, users); fr.cobases(); d, _ = fr.dims(); d = dict(d); ld, _ = late_frames(fr, pr, users)\n+ mq = ModQ(fr, ld)\n+ def inside(A, B):\n+ E = Echelon(mq.q)\n+ for r in mq.basis(B): E.insert(r)\n+ return all(E.contains(r) for r in mq.basis(A))\n+ def ufr(n, k):\n+ u = users[n][k]; return ('n', u[1]) if u[0] == 'gate' else root_key(u)\n+ bad = tot = 0\n+ for n, (e, lt) in pr.late.items():\n+ for i in range(len(lt) - 1):\n+ tot += 1; bad += not inside(ufr(n, lt[i]), ufr(n, lt[i + 1]))\n+ log('(c) pivot chain through user frames without intersections: non-nested consecutive frames %d / %d '\n+ '(the intersections are needed)' % (bad, tot))\n+ # (d) the common flag is essential: rebuild M_n with an independent flag F' (same j(n)) and test M_n <= M_t\n+ pairs = [(n, t) for n in pr.j for t in fr.succ[n] if pr.j.get(t, 0) > 0 and dn[t] < d[t] < h - len(fr.K[t])]\n+ rng.shuffle(pairs); bad = tot = 0; r2 = random.Random(99)\n+ Fp = [[r2.randint(-50, 50) for _ in range(h)] for _ in range(h)]\n+ for n, t in pairs[:nsample]:\n+ j = pr.j[n]; K = [fr.rootcov[fr.rkeys[r]] for r in fr.K[n]]\n+ KF = [[sum(a * b for a, b in zip(kr, fl)) for fl in Fp[:j]] for kr in K]\n+ if KF and rank_mod(KF, mq.q) != fr._rank(KF, min(len(K), j), Counter(), 'KF'): continue\n+ X = null_mod(KF, j, mq.q) if KF else [[int(i == c) for c in range(j)] for i in range(j)]\n+ E = Echelon(mq.q)\n+ for r in mq.basis(('n', t)): E.insert(r)\n+ vecs = [[sum(c * Fp[i][q] for i, c in enumerate(x)) % mq.q for q in range(h)] for x in X]\n+ tot += 1; bad += not all(E.contains(v) for v in vecs)\n+ log(\"(d) M_n rebuilt with an independent flag F': M_n not inside M_t on %d / %d lifted successor pairs (targets strictly between span and U)\" % (bad, tot))\n+ ops, chains, reads, R = compile_(pr, dn, users)\n+ fr2 = Frames(pr, dn, bas, users); fr2.cobases(); d2, _ = fr2.dims(); ld2, _ = late_frames(fr2, pr, users)\n+ dimof = lambda k: 0 if k == ('0',) else h if k == ('F',) else h - 1 if k[0] in ('out', 'ret') else ld2[k] if k[0] == 'c' else d2[k[1]]\n+ rk, steps = chain_steps(chains, dimof, h)\n+ mqs = ModQ(fr2, ld2); smp = list(steps); random.Random(5).shuffle(smp); nb = 0\n+ for A, B in smp[:3000]:\n+ E = Echelon(mqs.q)\n+ for r in mqs.basis(B): E.insert(r)\n+ nb += not all(E.contains(r) for r in mqs.basis(A))\n+ log('(g) sanity (positive): 3000 sampled chain steps A -> B with A inside B mod q: failures %d' % nb)\n+ mq0 = ModQ(fr2, ld2, control=True); pr_ = predicted(h); hi = [(e, r) for e, r in steps.items() if 2 * r > h][:300]\n+ nb = 0\n+ for (A, B), r in hi:\n+ QA, QB = mq0.conjugated(A), mq0.conjugated(B)\n+ M = [[(QB[0][i * h + c] - QA[0][i * h + c]) % mq0.q for c in range(h)] for i in range(h)]\n+ nb += rightmost_pivots(M, mq0.q) != pr_[r]\n+ log('(e) side lemma with U = V = I: failures %d / %d (must be most)' % (nb, len(hi)))\n+ ops, chains0, reads, R = compile_(pr, dn, users, late=False)\n+ rk0, _ = chain_steps(chains0, dimof, h)\n+ log('(f) without late copies: histogram differs %s; certificate %s' % (rk0 != rk, {k: v[0] for k, v in certificate(h, R, rk0).items()}))\n+\n+\n+if __name__ == '__main__':\n+ h = int(sys.argv[1])\n+ if '--controls' in sys.argv: controls(h)\n+ else:\n+ out = main(h, generic='--no-generic' not in sys.argv)[0]\n+ ok = out['replay'] and out['struct'][:3] == (0, 0, 0) and out['struct'][3] and out['hist_ok']\n+ ok &= out.get('degenerate', 0) == 0 and out.get('dimfail', 0) == 0 and out.get('side_bad', 0) == 0\n+ ok &= all(v[2] for k, v in out.items() if k in ('round6 corner', 'staircase'))\n+ log('ALL %s' % ('PASS' if ok else 'FAIL'))\n+ sys.exit(0 if ok else 1)" + }, + { + "sha": "d3d1dea1a9a42601410fb5cd3edc5888d63d217b", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_stair.py", + "status": "added", + "additions": 194, + "deletions": 0, + "changes": 194, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_stair.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_stair.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_stair.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,194 @@\n+\"\"\"Staircase data-entrance corner certificate (stdlib only).\n+\n+Sparse flag family + staircase cells:\n+ rows lambda_b = E(b,b) (b < h-1), lambda_{h-1} = al E(h-1,0) + be E(0,h-1); E(RC[t]) (staircase rows)\n+ cols E(CC[t]) (staircase columns); mu_j = a_j E(j,j+1) + b_j E(j+1,j) (j < h-1), mu_{h-1} = E(h-1,h-1)\n+Checks:\n+ 1. the sparse R_b, C_b are flag-family members (supports, zero diagonal entries) with all trace conditions;\n+ the flag diagonal factors f1..f4 are nonzero on every line at the point (U, V of point(h, 1)) and the inner corners\n+ of the rank-(h-1) data classes are nonzero, so the flag-basis lemmas (lower-triangular corners, side lemma) apply\n+ to this family at the SAME U, V where check_lifted.py verifies the side lemma;\n+ 2. upper bound, identically in all parameters: for every north-east block of the (2h-1)x(2h-1) entrance corner,\n+ rank <= min vertex cut of the rows-terms-cols graph (max flow, cut re-verified);\n+ 3. lower bound at one point: the corner at sampled line pairs has rightmost pivots whose NE rank function equals the\n+ upper bound on every nontrivial block, and is invertible; its runs are (h-2, h-5, 1^6).\n+So the entrance compiles to m-4h+2 and runs (h-2, h-5, 1^6) on a Zariski-open set (partial-swap lemma).\n+Negative control (--control): random elementary cells instead of the staircase must NOT certify.\n+--ij: fixed explicit axis bases U = V = I + J instead of point(h, 1).\n+Usage: python3 check_stair.py h [npairs] [--control] [--ij]\"\"\"\n+import sys, random\n+from itertools import combinations\n+from collections import deque\n+sys.path.insert(0, __import__('os').path.dirname(__import__('os').path.abspath(__file__)))\n+from linalg import inv_mod_matrix, rightmost_pivots\n+from check_lifted import point_UV\n+\n+P = 67108859 # the prime of round six's draws (sparse parameters depend on it)\n+def iv(x): return pow(x % P, P - 2, P)\n+\n+\n+def design(h, kind='stair'):\n+ if kind == 'stair':\n+ RC = [(0, 3)] + [(r + 1, r - 1) for r in range(1, h - 1)]\n+ CC = [(c + 1, c + 3) for c in range(h - 3)] + [(0, h - 3), (0, h - 2)]\n+ return RC, CC\n+ reserved = {(b, b) for b in range(h)} | {(h - 1, 0), (0, h - 1)}\n+ for j in range(h - 1): reserved |= {(j, j + 1), (j + 1, j)}\n+ free = sorted(set((i, j) for i in range(h) for j in range(h)) - reserved)\n+ rng = random.Random(kind); cells = rng.sample(free, 2 * h - 2)\n+ return cells[:h - 1], cells[h - 1:]\n+\n+\n+def structure(h, RC, CC):\n+ rows = [{(b, b)} for b in range(h - 1)] + [{(h - 1, 0), (0, h - 1)}] + [{c} for c in RC]\n+ cols = [{c} for c in CC] + [{(j, j + 1), (j + 1, j)} for j in range(h - 1)] + [{(h - 1, h - 1)}]\n+ for f in rows:\n+ for g in cols: assert not (f & g), 'identity term would not vanish'\n+ assert len(set().union(*rows) | set().union(*cols)) == sum(map(len, rows)) + sum(map(len, cols)), 'cells reused'\n+ terms = []\n+ for l in range(h): terms.append(({i for i, f in enumerate(rows) if any(c[1] == l for c in f)},\n+ {j for j, g in enumerate(cols) if any(c[1] == l for c in g)}))\n+ for k in range(h): terms.append(({i for i, f in enumerate(rows) if any(c[0] == k for c in f)},\n+ {j for j, g in enumerate(cols) if any(c[0] == k for c in g)}))\n+ terms.append((set(range(len(rows))), set(range(len(cols)))))\n+ return rows, cols, terms\n+\n+\n+def cut_bound(rows_, cols_, terms):\n+ T = [(sr & rows_, sc & cols_) for sr, sc in terms]\n+ nodes = [('r', r) for r in rows_] + [('t', t) for t in range(len(T))] + [('c', c) for c in cols_]\n+ idx = {nd: i for i, nd in enumerate(nodes)}\n+ BIG = 10**6; N = 2 * len(nodes) + 2; S_, K_ = N - 2, N - 1; cap = {}; adj = [[] for _ in range(N)]\n+ def add(a, b, c):\n+ if (a, b) not in cap: adj[a].append(b); adj[b].append(a); cap[a, b] = 0; cap.setdefault((b, a), 0)\n+ cap[a, b] += c\n+ for nd, k in idx.items(): add(2 * k, 2 * k + 1, 1)\n+ for r in rows_: add(S_, 2 * idx['r', r], BIG)\n+ for c in cols_: add(2 * idx['c', c] + 1, K_, BIG)\n+ for t, (sr, sc) in enumerate(T):\n+ if not sr or not sc: continue\n+ for r in sr: add(2 * idx['r', r] + 1, 2 * idx['t', t], BIG)\n+ for c in sc: add(2 * idx['t', t] + 1, 2 * idx['c', c], BIG)\n+ flow = 0\n+ while True:\n+ par = {S_: None}; dq = deque([S_])\n+ while dq and K_ not in par:\n+ a = dq.popleft()\n+ for b in adj[a]:\n+ if b not in par and cap[a, b] > 0: par[b] = a; dq.append(b)\n+ if K_ not in par: break\n+ b = K_\n+ while par[b] is not None: a = par[b]; cap[a, b] -= 1; cap[b, a] += 1; b = a\n+ flow += 1\n+ reach = set(par)\n+ cut = [nd for nd, k in idx.items() if 2 * k in reach and 2 * k + 1 not in reach]\n+ R0 = {x for t_, x in cut if t_ == 'r'}; T0 = {x for t_, x in cut if t_ == 't'}; C0 = {x for t_, x in cut if t_ == 'c'}\n+ assert len(cut) == flow\n+ for t, (sr, sc) in enumerate(T): # the cut is a certificate: every other term is covered\n+ if t in T0: continue\n+ assert not (sr - R0) or not (sc - C0), 'cut misses a term'\n+ return flow\n+\n+\n+def sparse_params(h, rng):\n+ nz = lambda: rng.randrange(1, P)\n+ return dict(al=nz(), be=nz(), a=[nz() for _ in range(h - 1)], b=[nz() for _ in range(h - 1)])\n+\n+\n+def runs(pc):\n+ pts = sorted((i, c) for i, c in enumerate(pc) if c >= 0); out = []; prev = None\n+ for i, c in pts:\n+ if prev and i == prev[0] + 1 and c == prev[1] + 1: out[-1] += 1\n+ else: out.append(1)\n+ prev = (i, c)\n+ return out\n+\n+\n+def mv(A, x): return [sum(a * b for a, b in zip(r, x)) % P for r in A]\n+\n+\n+def flag_factors(h, sp, U, V, Ui, Vi):\n+ \"\"\"check 1: family membership, trace conditions, f1..f4 and inner corners nonzero on every line.\"\"\"\n+ R = [[[0] * h for _ in range(h)] for _ in range(h)]; C = [[[0] * h for _ in range(h)] for _ in range(h)]\n+ for b in range(h - 1): R[b][b][b] = 1\n+ R[h - 1][h - 1][0] = sp['al']; R[h - 1][0][h - 1] = sp['be']\n+ for j in range(h - 1): C[j][j][j + 1] = sp['a'][j]; C[j][j + 1][j] = sp['b'][j]\n+ C[h - 1][h - 1][h - 1] = 1\n+ for b in range(h):\n+ assert all(R[b][i][k] == 0 for i in range(h) for k in range(h) if i > b or k > b)\n+ assert all(C[b][i][k] == 0 for i in range(h) for k in range(h) if i < b or k < b)\n+ if b < h - 1: assert C[b][b][b] == 0\n+ assert R[h - 1][h - 1][h - 1] == 0\n+ for i in range(h):\n+ for j in range(h):\n+ assert sum(R[i][a][b] * C[j][a][b] for a in range(h) for b in range(h)) % P == 0, 'trace condition'\n+ UT = [list(c) for c in zip(*U)]; VT = [list(c) for c in zip(*V)]\n+ Rrow = [R[k][k] for k in range(h)]; Crow = [C[k][k] for k in range(h)]\n+ Rcol = [[R[k][i][k] for i in range(h)] for k in range(h)]; Ccol = [[C[k][i][k] for i in range(h)] for k in range(h)]\n+ zeros = inner = 0; i9 = iv(9); i2 = iv(2); lines = 0\n+ for t in combinations(range(h), 3):\n+ tv = [int(q in t) for q in range(h)]; g = [(x - 3 * i9) * i2 % P for x in tv]\n+ a, b, c, d = mv(VT, tv), mv(Vi, g), mv(UT, tv), mv(Ui, g)\n+ for M, x in ((Rrow, a), (Crow, b), (Rcol, c), (Ccol, d)):\n+ zeros += sum(1 for v in mv(M, x) if v == 0)\n+ inner += (c[0] * d[h - 1] % P == 0) + (a[0] * b[h - 1] % P == 0); lines += 1\n+ return lines, zeros, inner\n+\n+\n+def corner_at(h, rows, cols, p, xi, v, nu):\n+ \"\"\"rows . (q1 (x) q2) . cols, (q1 (x) q2) vec G = vec(q1 G q2^T), q1 = I - p xi^T, q2 = I - v nu^T.\"\"\"\n+ q1 = [[(int(i == k) - p[i] * xi[k]) % P for k in range(h)] for i in range(h)]\n+ q2 = [[(int(i == k) - v[i] * nu[k]) % P for k in range(h)] for i in range(h)]\n+ out = [[0] * len(cols) for _ in rows]\n+ for j, col in enumerate(cols):\n+ G = [[0] * h for _ in range(h)]\n+ for (a, b), val in col.items(): G[a][b] = val % P\n+ qG = [[sum(q1[i][k] * G[k][l] for k in range(h)) % P for l in range(h)] for i in range(h)]\n+ Y = [[sum(qG[i][l] * q2[k][l] for l in range(h)) % P for k in range(h)] for i in range(h)]\n+ for i, row in enumerate(rows):\n+ out[i][j] = sum(val * Y[a][b] for (a, b), val in row.items()) % P\n+ return out\n+\n+\n+def main(h, npairs=20, kind='stair', seed=1, ij=False):\n+ RC, CC = design(h, kind); n = 2 * h - 1\n+ _, _, terms = structure(h, RC, CC)\n+ U, V = point_UV(h, seed)\n+ if ij: U = [[1 + int(i == k) for k in range(h)] for i in range(h)]; V = [r[:] for r in U] # fixed U = V = I + J\n+ U = [[x % P for x in r] for r in U]; V = [[x % P for x in r] for r in V]\n+ Ui, Vi = inv_mod_matrix(U, P), inv_mod_matrix(V, P)\n+ sp = sparse_params(h, random.Random(1000 + seed))\n+ lines, zeros, inner = flag_factors(h, sp, U, V, Ui, Vi)\n+ print('1. sparse flag family: trace conditions OK; f1..f4 zeros %d over %d lines x %d rows; inner-corner zeros %d'\n+ % (zeros, lines, h, inner), flush=True)\n+ rows = [{(b, b): 1} for b in range(h - 1)] + [{(h - 1, 0): sp['al'], (0, h - 1): sp['be']}] + [{c: 1} for c in RC]\n+ cols = [{c: 1} for c in CC] + [{(j, j + 1): sp['a'][j], (j + 1, j): sp['b'][j]} for j in range(h - 1)] + [{(h - 1, h - 1): 1}]\n+ trip = list(combinations(range(h), 3)); prng = random.Random(seed + 7); UT = [list(c) for c in zip(*U)]; VT = [list(c) for c in zip(*V)]\n+ i9 = iv(9); i2 = iv(2); pats = {}\n+ def line(t, AT, Ai):\n+ tv = [int(i in t) for i in range(h)]; g = [(x - 3 * i9) * i2 % P for x in tv]\n+ return mv(AT, tv), mv(Ai, g)\n+ for _ in range(npairs):\n+ t1, t2 = prng.choice(trip), prng.choice(trip)\n+ p, xi = line(t1, UT, Ui); v, nu = line(t2, VT, Vi)\n+ pc = tuple(rightmost_pivots(corner_at(h, rows, cols, p, xi, v, nu), P)); pats[pc] = pats.get(pc, 0) + 1\n+ pc = list(max(pats, key=pats.get))\n+ rho = [[sum(1 for r in range(i + 1) if pc[r] >= j) for j in range(n)] for i in range(n)]\n+ certs = above = 0\n+ for i in range(n):\n+ for j in range(n):\n+ if rho[i][j] == min(i + 1, n - j): continue\n+ ub = cut_bound(set(range(i + 1)), set(range(j, n)), terms); certs += 1\n+ assert ub >= rho[i][j]\n+ above += ub > rho[i][j]\n+ ok = above == 0 and -1 not in pc and len(pats) == 1 and zeros == 0 and inner == 0\n+ print('2-3. %d pairs, distinct pivot patterns %d; runs %s invertible %s; nontrivial NE blocks %d, symbolic bound '\n+ 'above evaluated rank on %d' % (npairs, len(pats), runs(pc), -1 not in pc, certs, above), flush=True)\n+ print('RESULT h=%d kind=%s runs=%s certified=%s' % (h, kind, sorted(runs(pc), reverse=True), ok), flush=True)\n+ return ok, sorted(runs(pc), reverse=True)\n+\n+\n+if __name__ == '__main__':\n+ h = int(sys.argv[1]); npairs = int(sys.argv[2]) if len(sys.argv) > 2 and sys.argv[2].isdigit() else 20\n+ ok, _ = main(h, npairs, 'rand1' if '--control' in sys.argv else 'stair', ij='--ij' in sys.argv)\n+ sys.exit(0 if ok or '--control' in sys.argv else 1)" + }, + { + "sha": "7db40994e4d74afe191c3fd8ac5c9acc9b438eeb", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_word.py", + "status": "added", + "additions": 193, + "deletions": 0, + "changes": 193, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_word.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_word.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fcheck_word.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,193 @@\n+\"\"\"Round-seven check, part 1 (stdlib only): the reordered stage-1 word, as scalars. No frames are used here.\n+\n+From certificates/round7/{witness,deferred}_23.json.gz:\n+ A. side DAG from the definitions (disjoint additions, out(c,T) = {S : S cap T = {c}}, retained(c) = star(c));\n+ the schedule computes it: replaying the ops symbolically, every addition reads its two operands from the two slots\n+ it names, a linked operand stays on the non-pivot slot, every addition runs once, the node lists of every slot\n+ follow the replay, copies start where their source is, and every output / retained slot ends holding its node;\n+ B. garbage coefficients of every slot (the transpose sweep of L applied to the root reads), over Z and over F2;\n+ C. phase 1 = the ops that must precede the retained-total completions under per-slot sequence precedence; no\n+ deferred slot is read or written in phase 1, the retained slots complete in phase 1 and are not touched again,\n+ every V gate precedes its slot's first touch by L; the release rule: deferred readouts in increasing dim sigma_u,\n+ deferred V gates in increasing dim s_i, each X_S ordered as its early V gates then its deferred V gates;\n+ D. the stage-1 word of B-defer with V leaves, every event placed in time:\n+ readouts of the non-deferred slots (at 0), the early V gates, phase 1 of L, the centre copies read every target\n+ containing their centre, the deferred readouts in order, the deferred V gates, the rest of L, the output reads,\n+ L^-1, V^-1;\n+ replayed with arbitrary scratch and data over F2 and over Z (exact integer readout coefficients): every slot is\n+ restored and every target receives its definition sum (over F2 exactly x_T); negative controls must break it.\n+Usage: python3 check_word.py [h]\"\"\"\n+import sys, os, random, time\n+from collections import defaultdict\n+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\n+import deferred as dr\n+\n+T0 = time.time()\n+def log(*a): print('[%5.0fs]' % (time.time() - T0), *a, flush=True)\n+OK = {}\n+def report(name, ok):\n+ OK[name] = bool(ok); log('%-100s %s' % (name, 'PASS' if ok else 'FAIL'))\n+\n+\n+def main(h=23):\n+ W, D = dr.load(h); S = dr.Schedule(W, D)\n+ trip, v, R, tid, ops, args = S.trip, S.v, S.R, S.tid, S.ops, S.args\n+ act = sorted(args)\n+ # ------------------------------------------------------------------ A. DAG and schedule semantics\n+ star = [sum(1 << i for i, T in enumerate(trip) if q in T) for q in range(h)]\n+ sup = {}; okA = True\n+ for n in act:\n+ if args[n] is None: okA &= 1 <= n <= v and tuple(W['leaf'][str(n)]) == trip[n - 1]; sup[n] = 1 << (n - 1)\n+ else:\n+ a, b = args[n]; okA &= a < n and b < n and not (sup[a] & sup[b]); sup[n] = sup[a] | sup[b]\n+ outputs = {(c, tuple(T)): n for c, T, n in W['outputs']}; retained = {c: n for c, n in W['retained']}\n+ for (c, T), n in outputs.items():\n+ A_, B_ = [q for q in T if q != c]\n+ okA &= c in T and sup[n] == star[c] & ~star[A_] & ~star[B_]\n+ okA &= len(outputs) == 3 * v and sorted(retained) == list(range(h)) and all(sup[n] == star[c] for c, n in retained.items())\n+ report('A. disjoint additions; out(c,T) = {S: S cap T = {c}}; retained(c) = star(c) (%d outputs, %d totals)' % (\n+ len(outputs), len(retained)), okA)\n+ mL = {x: (y, k) for x, y, k in W['links']}\n+ val = {}; pos = [0] * R; seen = set(); okS = True; started = set()\n+ for op in ops:\n+ if op[0] == 'src':\n+ s, n = op[1], op[2]; okS &= s not in started and args[n] is None and S.hold[s][0] == n\n+ val[s] = n; started.add(s)\n+ elif op[0] == 'fan':\n+ p = op[1]; okS &= p in started\n+ for g in op[2]:\n+ okS &= g not in started and S.hold[g][0] == val[p] and S.start[g][0] == 'fresh' and S.start[g][1] == val[p]\n+ val[g] = val[p]; started.add(g)\n+ else:\n+ _, p, o, n = op; okS &= n not in seen and args[n] is not None and p in started and o in started; seen.add(n)\n+ okS &= (val[p], val[o]) in (args[n], args[n][::-1])\n+ if n in mL: okS &= mL[n][0] == val[o] # the linked operand stays on the non-pivot\n+ for s_ in (p, o): # both wires pass the gate of n\n+ okS &= pos[s_] + 1 < len(S.hold[s_]) and S.hold[s_][pos[s_] + 1] == n; pos[s_] += 1\n+ val[p] = n\n+ okS &= seen == {n for n in act if args[n] is not None} and len(started) == R\n+ okS &= all(pos[s] == len(S.hold[s]) - 1 for s in range(R))\n+ okS &= all(val[s] == outputs[cT] for s, cT in S.out.items()) and all(val[s] == retained[c] for s, c in S.ret.items())\n+ okS &= sorted(S.out.values()) == sorted(outputs) and sorted(S.ret.values()) == list(range(h))\n+ okS &= R == len(seen) + len(outputs) + len(retained) - len(mL)\n+ report('A. schedule computes the DAG: %d ops, R = adds + outputs + totals - links = %d, node lists follow the replay' % (\n+ len(ops), R), okS)\n+\n+ # ------------------------------------------------------------------ B. coefficients\n+ CZ = S.adjoint(); CF = [{t: 1 for t, x in d.items() if x % 2} for d in CZ]\n+ report('B. garbage coefficients by the transpose sweep: %d nonzero over Z, %d odd' % (\n+ sum(len(d) for d in CZ), sum(len(d) for d in CF)), all(x > 0 for d in CZ for x in d.values()))\n+\n+ # ------------------------------------------------------------------ C. phase 1 and the release rule\n+ prev = {}; pred = defaultdict(list); first = {}; last = {}\n+ for i, op in enumerate(ops):\n+ for s in S.touch(op):\n+ if s in prev: pred[i].append(prev[s])\n+ prev[s] = i; first.setdefault(s, i); last[s] = i\n+ Anc = set(); st = [last[s] for s in S.ret]\n+ while st:\n+ i = st.pop()\n+ if i in Anc: continue\n+ Anc.add(i); st.extend(pred[i])\n+ sel = S.sel; srcop = S.srcop\n+ srcidx = {o[1]: i for i, o in enumerate(ops) if o[0] == 'src'}\n+ okC = not any(set(S.touch(ops[i])) & sel for i in Anc)\n+ okC &= all(last[s] in Anc for s in S.ret)\n+ okC &= all(s not in first or srcidx[s] < first[s] for s in srcop)\n+ report('C. deferred slots (%d, %d of them V leaves) untouched by phase 1 (%d of %d ops); totals complete in phase 1' % (\n+ len(sel), len(sel & set(srcop)), len(Anc), len(ops)), okC)\n+ dimv = {s: len(B) for s, B in S.vstart.items()}\n+ late_V = [s for s in S.late_v]; early = set(srcop) - sel\n+ okR = S.readout == sorted(sel, key=lambda s: (S.f[s], s)) and all(S.f[s] > 0 for s in sel)\n+ okR &= set(late_V) == sel & set(srcop) and late_V == sorted(late_V, key=lambda s: (dimv[s], s))\n+ posl = {s: i for i, s in enumerate(late_V)}; okX = True; leaves = defaultdict(list)\n+ for s, n in srcop.items(): leaves[n].append(s)\n+ okX &= sorted(n for n, _ in S.xs) == sorted(leaves)\n+ for n, us in S.xs:\n+ e = sorted((s for s in leaves[n] if s in early), key=lambda s: (dimv[s], s))\n+ l = sorted((s for s in leaves[n] if s in sel), key=lambda s: posl[s])\n+ okX &= us == e + l\n+ report('C. release rule: readouts by dim sigma_u, deferred V gates by dim s_i, X_S = early then deferred V gates', okR and okX)\n+\n+ # ------------------------------------------------------------------ D. the word\n+ ph1 = [i for i in range(len(ops)) if i in Anc and ops[i][0] != 'src']\n+ rest = [i for i in range(len(ops)) if i not in Anc and ops[i][0] != 'src']\n+ early_V = sorted(early, key=lambda s: (srcop[s], dimv[s], s))\n+ def expected(x):\n+ want = [0] * v\n+ for (c, T), n in outputs.items():\n+ A_, B_ = [q for q in T if q != c]\n+ want[tid[T]] += sum(x[i] for i, Sx in enumerate(trip) if c in Sx and A_ not in Sx and B_ not in Sx)\n+ for c in range(h):\n+ tot = sum(x[i] for i, Sx in enumerate(trip) if c in Sx)\n+ for t, T in enumerate(trip):\n+ if c in T: want[t] += tot\n+ return want\n+ selist = S.readout\n+ def word(ring, rng, ctl=None):\n+ mod = (lambda z: z & 1) if ring == 2 else (lambda z: z)\n+ co = CF if ring == 2 or ctl == 'f2coef_in_Z' else CZ\n+ x = [rng.randrange(-10**6, 10**6) for _ in range(v)]\n+ a0 = [rng.randrange(-10**6, 10**6) for _ in range(R)]; y0 = [rng.randrange(-10**6, 10**6) for _ in range(v)]\n+ a = list(a0); y = list(y0)\n+ drop = selist[len(selist) // 2] if ctl == 'drop' else None\n+ def readout(s):\n+ for t, c in co[s].items():\n+ if s == drop and t == min(co[s]): continue\n+ y[t] -= c * a[s]\n+ def runop(i):\n+ op = ops[i]\n+ if op[0] == 'add': a[op[1]] += a[op[2]]\n+ elif op[0] == 'fan':\n+ for g in op[2]: a[g] += a[op[1]]\n+ late_slot = early_slot = None\n+ if ctl == 'late_readout': # one deferred slot reads out right after its first modifying touch\n+ late_slot = next(s for s in selist if ops[first[s]][0] == 'fan' and s in ops[first[s]][2] or\n+ ops[first[s]][0] == 'add' and ops[first[s]][1] == s)\n+ if ctl == 'phase1_slot': # a slot modified in phase 1 treated as deferred\n+ early_slot = next(s for s in range(R) if s not in sel and s not in srcop and any(\n+ (ops[i][0] == 'add' and ops[i][1] == s) or (ops[i][0] == 'fan' and s in ops[i][2]) for i in ph1))\n+ for s in range(R):\n+ if s not in sel and s != early_slot: readout(s)\n+ for s in early_V: a[s] += x[srcop[s] - 1]\n+ if ctl == 'V_before_readout': a[late_V[0]] += x[srcop[late_V[0]] - 1]\n+ done = []\n+ for i in ph1: runop(i); done.append(i)\n+ for s, c in S.ret.items(): # centre copies: the totals are complete; read every T with c in T\n+ for t, T in enumerate(trip):\n+ if c in T: y[t] += a[s]\n+ if early_slot is not None: readout(early_slot)\n+ for s in selist:\n+ if s != late_slot: readout(s)\n+ for s in late_V:\n+ if not (ctl == 'V_before_readout' and s == late_V[0]): a[s] += x[srcop[s] - 1]\n+ for i in rest:\n+ runop(i); done.append(i)\n+ if late_slot is not None and i == first[late_slot]: readout(late_slot)\n+ for s, (c, T) in S.out.items(): y[tid[T]] += a[s]\n+ for i in reversed(done):\n+ op = ops[i]\n+ if op[0] == 'add': a[op[1]] -= a[op[2]]\n+ elif op[0] == 'fan':\n+ for g in op[2]: a[g] -= a[op[1]]\n+ for s, n in srcop.items(): a[s] -= x[n - 1]\n+ if any(mod(p - q) for p, q in zip(a, a0)): return False\n+ want = expected(x)\n+ if any(mod(y[t] - y0[t] - want[t]) for t in range(v)): return False\n+ if ring == 2 and any(mod(y[t] - y0[t] - x[t]) for t in range(v)): return False\n+ return True\n+ rng = random.Random(20261009)\n+ report('D. scalar identity over F2 (3 random scratch/data): scratch restored, y_T += x_T and == definition sums',\n+ all(word(2, rng) for _ in range(3)))\n+ report('D. scalar identity over Z, exact integer readout coefficients', word(0, rng))\n+ for ctl in ('drop', 'late_readout', 'V_before_readout', 'phase1_slot'):\n+ # one F2 trial can miss a fault whose error term is even, so 8 trials (any failure = broken)\n+ report('D. NEG control %-18s breaks the identity (F2, 8 trials; and Z)' % ctl,\n+ not all(word(2, rng, ctl) for _ in range(8)) and not word(0, rng, ctl))\n+ report('D. NEG control F2 coefficients used over Z break the Z identity', not word(0, rng, 'f2coef_in_Z'))\n+ log('ALL %s' % ('PASS' if all(OK.values()) else 'FAIL: ' + str([k for k, x in OK.items() if not x])))\n+ return all(OK.values())\n+\n+\n+if __name__ == '__main__':\n+ sys.exit(0 if main(int(sys.argv[1]) if len(sys.argv) > 1 else 23) else 1)" + }, + { + "sha": "b77bb4861c38b731e5b41a17af8fc1b63b56ec42", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/deferred.py", + "status": "added", + "additions": 188, + "deletions": 0, + "changes": 188, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fdeferred.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fdeferred.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Fdeferred.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,188 @@\n+\"\"\"Shared reader and accounting for the round-seven bit side (stdlib only).\n+\n+Frozen inputs (certificates/round7/):\n+ witness_23.json.gz the base side program: DAG (leaves = triples of [h], additions), outputs (c, T), retained\n+ totals, links, the flag matrix, the lift index j(n) of every lifted addition and the late-copy\n+ decisions; checked by check_lifted.py;\n+ deferred_23.json.gz the reordered stage-1 word: the slot schedule (ops, the node held by every slot over time,\n+ slot starts, output and retained slots), the deferred readout frames sigma_u, the V-leaf start\n+ frames s_i (both as primitive integer bases), the readout order, the X_S order of every leaf,\n+ the order of the deferred V gates, and the dimension of every node frame and late-copy\n+ intersection (re-derived exactly by check_frames.py).\n+\n+Ops: ['add', piv, oth, n] a[piv] += a[oth], the addition of node n; ['fan', piv, [f...]] a[f] += a[piv] for fresh\n+slots f (copies); ['src', s, n] the V gate a[s] += x_S of leaf n (applied outside L, see check_word.py).\"\"\"\n+import gzip, json, os\n+from collections import Counter, defaultdict\n+from itertools import combinations\n+from math import comb\n+\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+ROOT = os.path.normpath(os.path.join(HERE, '..', '..'))\n+DATA = os.path.join(ROOT, 'certificates', 'round7')\n+\n+\n+def load_json(name):\n+ with gzip.open(os.path.join(DATA, name), 'rt') as fh:\n+ return json.load(fh)\n+\n+\n+def load(h=23, witness=None, data=None):\n+ \"\"\"the base witness and the design-B data of one round-seven witness (default: the files of h).\"\"\"\n+ W = load_json(witness or 'witness_%d.json.gz' % h); D = load_json(data or 'deferred_%d.json.gz' % h)\n+ assert W['h'] == D['h'] == h\n+ return W, D\n+\n+\n+class Schedule:\n+ \"\"\"The design-B schedule in convenient form.\"\"\"\n+ def __init__(self, W, D):\n+ self.h = h = D['h']; self.R = D['R']; self.trip = list(combinations(range(h), 3)); self.v = len(self.trip)\n+ self.tid = {T: i for i, T in enumerate(self.trip)}\n+ self.args = {int(n): (tuple(a) if a else None) for n, a in W['args'].items()}\n+ self.ops = [tuple(o[:2]) + (tuple(o[2]),) if o[0] == 'fan' else tuple(o) for o in D['ops']]\n+ self.hold = D['hold']; self.start = D['start']\n+ self.out = {s: (c, tuple(T)) for s, c, T in D['out']}\n+ self.ret = {s: c for s, c in D['ret']}\n+ self.srcop = {o[1]: o[2] for o in self.ops if o[0] == 'src'}\n+ self.readout = D['readout_order']; self.sel = set(self.readout)\n+ self.sigma = dict(zip(D['readout_order'], D['sigma']))\n+ self.f = [0] * self.R\n+ for s, B in self.sigma.items(): self.f[s] = len(B)\n+ self.vstart = dict(zip(D['vleaf_slots'], D['vleaf_start']))\n+ self.xs = [(n, us) for n, us in D['xs_order']]\n+ self.late_v = D['deferred_v_order']\n+ self.node_dims = {n: d for n, d in D['node_dims']}\n+ self.late_dims = {(n, tuple(lt)): d for n, lt, d in D['late_dims']}\n+ self.late = {int(n): (list(e), list(l)) for n, (e, l) in W['late'].items()}\n+ self.pivslot = {o[3]: o[1] for o in self.ops if o[0] == 'add'}\n+\n+ def touch(self, op):\n+ if op[0] == 'add': return [op[1], op[2]]\n+ if op[0] == 'fan': return [op[1]] + list(op[2])\n+ return []\n+\n+ def root_targets(self):\n+ rt = {}\n+ for s, (c, T) in self.out.items(): rt[s] = [self.tid[T]]\n+ for s, c in self.ret.items(): rt[s] = [t for t, T in enumerate(self.trip) if c in T]\n+ return rt\n+\n+ def adjoint(self):\n+ \"\"\"garbage coefficients over Z: cov[s][t] = coefficient of slot s's start value in target y_T at the end of L\n+ (the transpose sweep of L applied to the root reads); the F2 circuit uses their parities.\"\"\"\n+ cov = [dict() for _ in range(self.R)]\n+ for s, ts in self.root_targets().items():\n+ for t in ts: cov[s][t] = cov[s].get(t, 0) + 1\n+ def addto(d, e):\n+ for t, x in e.items(): d[t] = d.get(t, 0) + x\n+ for op in reversed(self.ops):\n+ if op[0] == 'add': addto(cov[op[2]], cov[op[1]])\n+ elif op[0] == 'fan':\n+ for g in op[2]: addto(cov[op[1]], cov[g])\n+ return cov\n+\n+ # ------------------------------------------------------------------ frame keys of every slot's chain\n+ def start_key(self, s):\n+ \"\"\"('v', s) for a V-leaf slot (start s_i), ('n', n0) for a base or early copy, ('c', n0, late suffix).\"\"\"\n+ n0 = self.hold[s][0]\n+ if self.args[n0] is None: return ('v', s)\n+ st = self.start[s]; k = st[2]; dec = self.late.get(n0)\n+ if dec is None or k in dec[0]: return ('n', n0)\n+ lt = dec[1]; return ('c', n0, tuple(lt[lt.index(k):]))\n+\n+ def chain_keys(self, s):\n+ \"\"\"frames of slot s in time order: [sigma_u | 0], start, then every later node it holds (with the pivot's\n+ late-copy intersections after a node it pivots), its root frame if any, F.\"\"\"\n+ ch = [('sigma', s) if s in self.sel else ('0',), self.start_key(s)]\n+ for idx, n in enumerate(self.hold[s]):\n+ if idx > 0: ch.append(('n', n))\n+ if self.args[n] is not None and self.pivslot.get(n) == s and n in self.late:\n+ lt = self.late[n][1]\n+ for i in range(len(lt) - 1): ch.append(('c', n, tuple(lt[i:])))\n+ if s in self.out: c, T = self.out[s]; ch.append(('out', c, T))\n+ if s in self.ret: ch.append(('ret', self.ret[s]))\n+ ch.append(('F',)); return ch\n+\n+ def dim(self, key):\n+ k = key[0]\n+ if k == '0': return 0\n+ if k == 'F': return self.h\n+ if k in ('out', 'ret'): return self.h - 1\n+ if k == 'n': return self.node_dims[key[1]]\n+ if k == 'c': return self.late_dims[key[1], key[2]]\n+ if k == 'sigma': return len(self.sigma[key[1]])\n+ if k == 'v': return len(self.vstart[key[1]])\n+ raise KeyError(key)\n+\n+ def ylevels(self, cov):\n+ \"\"\"deferred readout levels (dim sigma) on every target, from the garbage-coefficient supports.\"\"\"\n+ lev = defaultdict(set)\n+ for s in self.readout:\n+ for t in cov[s]: lev[t].add(self.f[s])\n+ return {t: sorted(lev[t]) for t in range(self.v)}\n+\n+ def xdata(self, dimof=None):\n+ dimof = dimof or (lambda s: len(self.vstart[s]))\n+ out = []\n+ for n, us in self.xs:\n+ ds = [1] + [dimof(s) for s in us] + [self.h]\n+ ds = [d for i, d in enumerate(ds) if i == 0 or d != ds[i - 1]]\n+ out.append([b - a for a, b in zip(ds, ds[1:])])\n+ return out\n+\n+\n+def inner(r, h):\n+ \"\"\"children of a rank-r chain step under the inner-corner lemma (one block of width 2r-h when 2r > h).\"\"\"\n+ return [1] * (h - r) + [2 * r - h] if 2 * r > h else [1] * r\n+\n+\n+def chain_ranks(S, dimof=None):\n+ \"\"\"multiset of chain-step ranks over all slots (dims must be monotone along every chain).\"\"\"\n+ dimof = dimof or S.dim; rk = Counter()\n+ for s in range(S.R):\n+ ds = [dimof(k) for k in S.chain_keys(s)]\n+ assert all(b >= a for a, b in zip(ds, ds[1:])), ('decreasing chain', s)\n+ assert ds[-1] == S.h\n+ for a, b in zip(ds, ds[1:]):\n+ if b > a: rk[b - a] += 1\n+ return rk\n+\n+\n+ROUND6_CORNER = lambda h: [h - 2] + [1] * (h + 1) # data-entrance corner runs, rounds six and seven\n+STAIRCASE_CORNER = lambda h: [h - 2, h - 5] + [1] * 6 # staircase corner (check_stair.py)\n+\n+\n+def histogram(S, rk, ylev, xdata, corner=None):\n+ \"\"\"child-width histogram of the batched two-stage bit interchange with deferred readouts and V leaves.\n+ Per stage (stage two is the complement time-reversal of stage one, same edge multiset), each of the v invocations:\n+ every slot u: its auxiliary edge of rank m - r_u (block m - 2 r_u) and its corner of rank r_u = h - dim sigma_u,\n+ both batched by the inner lemma, plus its chain steps;\n+ every centre: the copy's step U_c -> 0 of rank h-1;\n+ every target y_T: the chain 0 -> deferred levels -> t_T^perp (total rank h-1);\n+ every leaf X_S: its chain -> V-gate frames -> F (total rank h-1).\n+ Data: the entrance block m-4h+2 with its corner runs, one copy-correction singleton per pair.\"\"\"\n+ h, v, R = S.h, S.v, S.R; m = h * h; N = v * v; A = v * R; H = Counter()\n+ corner = corner or ROUND6_CORNER(h); assert sum(corner) == 2 * h - 1\n+ corners = Counter(h - S.f[s] for s in range(R))\n+ for _ in range(2):\n+ for r, c in corners.items():\n+ H[m - 2 * r] += v * c\n+ for w in inner(r, h): H[w] += v * c\n+ for r, c in rk.items():\n+ for w in inner(r, h): H[w] += v * c\n+ for _c in range(h):\n+ for w in inner(h - 1, h): H[w] += v\n+ for t in range(v):\n+ ds = sorted(set([0] + ylev[t] + [h - 1]))\n+ for a, b in zip(ds, ds[1:]):\n+ for w in inner(b - a, h): H[w] += v\n+ for xs in xdata:\n+ for x in xs:\n+ for w in inner(x, h): H[w] += v\n+ H[m - 4 * h + 2] += 2 * N\n+ for w in corner: H[w] += 2 * N\n+ H[1] += N\n+ H = {w: c for w, c in H.items() if c}\n+ Wd = 2 * N + 2 * A; L = 2 * v * h * (h - 1); s = Wd * m - N + L\n+ return dict(h=h, m=m, v=v, N=N, W=Wd, L=L, s=s, R=R, hist=H)" + }, + { + "sha": "a81cbaa61e2c09075f900546ec46833103b77ac1", + "filename": "research/deferred-signed/swapnil-round7/independent/deferred-readout/linalg.py", + "status": "added", + "additions": 176, + "deletions": 0, + "changes": 176, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Flinalg.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Flinalg.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fdeferred-readout%2Flinalg.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,176 @@\n+\"\"\"Stdlib exact linear algebra used by the release checks (no numpy).\n+\n+Ranks over Q are computed in one of two rigorous ways:\n+ * modulo a prime p with a Hadamard certificate: if every row of an integer matrix has squared norm n_i and\n+ prod_i max(1, n_i) < p^2, every minor has absolute value < p, so a minor is nonzero over Q iff it is nonzero\n+ mod p, and the rank mod p equals the rank over Q (hadamard_ok);\n+ * exactly, by fraction-free (Bareiss) elimination over Z (rank_exact) or Fraction elimination (null_exact).\n+Everything else is plain arithmetic modulo a prime.\"\"\"\n+from fractions import Fraction\n+from math import gcd\n+\n+Q31 = 2**31 - 1 # prime used for the point evaluation and frame reductions\n+M127 = 2**127 - 1 # Mersenne prime\n+M521 = 2**521 - 1 # Mersenne prime\n+\n+\n+def hadamard_ok(rows, p):\n+ \"\"\"True if prod of max(1, |row|^2) < p^2, i.e. every minor of the integer matrix is below p in absolute value.\"\"\"\n+ b = 1; p2 = p * p\n+ for r in rows:\n+ b *= max(1, sum(x * x for x in r))\n+ if b >= p2: return False\n+ return True\n+\n+\n+class Echelon:\n+ \"\"\"Row echelon basis mod p, built by insertion. Each stored row has a pivot (first nonzero, normalised to 1)\n+ and zeros in the pivot columns of all earlier rows, so reducing a new row against the rows in order is exact.\"\"\"\n+ __slots__ = ('p', 'rows', 'piv')\n+\n+ def __init__(self, p):\n+ self.p = p; self.rows = []; self.piv = []\n+\n+ def reduce(self, r):\n+ p = self.p; r = [x % p for x in r]\n+ for pc, b in zip(self.piv, self.rows):\n+ c = r[pc]\n+ if c: r = [(x - c * y) % p for x, y in zip(r, b)]\n+ return r\n+\n+ def insert(self, r):\n+ \"\"\"insert row; returns True if it was independent.\"\"\"\n+ r = self.reduce(r)\n+ for i, x in enumerate(r):\n+ if x:\n+ inv = pow(x, self.p - 2, self.p)\n+ self.rows.append([(y * inv) % self.p for y in r]); self.piv.append(i); return True\n+ return False\n+\n+ def contains(self, r):\n+ return not any(self.reduce(r))\n+\n+ def __len__(self): return len(self.rows)\n+\n+\n+def rank_mod(rows, p):\n+ E = Echelon(p)\n+ for r in rows: E.insert(r)\n+ return len(E)\n+\n+\n+def rank_exact(rows):\n+ \"\"\"exact rank over Q of an integer matrix (Bareiss fraction-free elimination).\"\"\"\n+ M = [list(r) for r in rows if any(r)]\n+ if not M: return 0\n+ n = len(M); k = len(M[0]); r = 0; prev = 1\n+ for c in range(k):\n+ i = next((i for i in range(r, n) if M[i][c]), None)\n+ if i is None: continue\n+ M[r], M[i] = M[i], M[r]\n+ pr = M[r]; a = pr[c]\n+ for t in range(r + 1, n):\n+ row = M[t]; b = row[c]\n+ M[t] = [(a * x - b * y) // prev for x, y in zip(row, pr)]\n+ prev = a; r += 1\n+ if r == n: break\n+ return r\n+\n+\n+def null_mod(A, k, p):\n+ \"\"\"basis of {x in F_p^k : A x = 0} (A: list of rows of length k).\"\"\"\n+ rows = [[x % p for x in r] for r in A]; piv = []; R = []\n+ for r in rows:\n+ for pc, b in zip(piv, R):\n+ c = r[pc]\n+ if c: r = [(x - c * y) % p for x, y in zip(r, b)]\n+ i = next((i for i, x in enumerate(r) if x), None)\n+ if i is None: continue\n+ inv = pow(r[i], p - 2, p); r = [(y * inv) % p for y in r]\n+ R = [[(x - b[i] * y) % p for x, y in zip(b, r)] if b[i] else b for b in R] # keep fully reduced\n+ R.append(r); piv.append(i)\n+ free = [c for c in range(k) if c not in piv]; out = []\n+ for f in free:\n+ x = [0] * k; x[f] = 1\n+ for pc, b in zip(piv, R): x[pc] = (-b[f]) % p\n+ out.append(x)\n+ return out\n+\n+\n+def null_exact(A, k):\n+ \"\"\"basis (integer vectors) of {x in Q^k : A x = 0}, by Fraction reduced row echelon form.\"\"\"\n+ R = []; piv = []\n+ for r0 in A:\n+ r = [Fraction(x) for x in r0]\n+ for pc, b in zip(piv, R):\n+ c = r[pc]\n+ if c: r = [x - c * y for x, y in zip(r, b)]\n+ i = next((i for i, x in enumerate(r) if x), None)\n+ if i is None: continue\n+ inv = 1 / r[i]; r = [y * inv for y in r]\n+ R = [[x - b[i] * y for x, y in zip(b, r)] if b[i] else b for b in R]\n+ R.append(r); piv.append(i)\n+ free = [c for c in range(k) if c not in piv]; out = []\n+ for f in free:\n+ x = [Fraction(0)] * k; x[f] = Fraction(1)\n+ for pc, b in zip(piv, R): x[pc] = -b[f]\n+ out.append(primitive(x))\n+ return out\n+\n+\n+def primitive(x):\n+ \"\"\"scale a rational vector to a primitive integer vector.\"\"\"\n+ den = 1\n+ for v in x: den = den * v.denominator // gcd(den, v.denominator)\n+ y = [int(v * den) for v in x]; g = 0\n+ for v in y: g = gcd(g, v)\n+ return [v // g for v in y] if g else y\n+\n+\n+def inv_mod_matrix(A, p):\n+ \"\"\"inverse of a square matrix mod p, or None if singular.\"\"\"\n+ n = len(A); M = [[x % p for x in A[i]] + [int(i == j) for j in range(n)] for i in range(n)]\n+ for c in range(n):\n+ i = next((i for i in range(c, n) if M[i][c]), None)\n+ if i is None: return None\n+ M[c], M[i] = M[i], M[c]\n+ inv = pow(M[c][c], p - 2, p); M[c] = [(x * inv) % p for x in M[c]]\n+ rc = M[c]\n+ for t in range(n):\n+ if t != c and M[t][c]:\n+ f = M[t][c]; M[t] = [(x - f * y) % p for x, y in zip(M[t], rc)]\n+ return [r[n:] for r in M]\n+\n+\n+def matmul(A, B, p):\n+ Bt = list(zip(*B))\n+ return [[sum(x * y for x, y in zip(r, c)) % p for c in Bt] for r in A]\n+\n+\n+def rightmost_pivots(Q, p):\n+ \"\"\"rows top to bottom: the rightmost nonzero column of the reduced row, then eliminate it below.\"\"\"\n+ M = [list(r) for r in Q]; n = len(M); out = [-1] * n\n+ for i in range(n):\n+ row = M[i]; c = next((j for j in range(len(row) - 1, -1, -1) if row[j]), -1)\n+ out[i] = c\n+ if c < 0: continue\n+ inv = pow(row[c], p - 2, p)\n+ for t in range(i + 1, n):\n+ f = M[t][c]\n+ if f:\n+ f = f * inv % p; M[t] = [(x - f * y) % p for x, y in zip(M[t], row)]\n+ return out\n+\n+\n+def predicted(h):\n+ \"\"\"pivot column per row of the generic north-east rank function f_r of a rank-r idempotent.\"\"\"\n+ pr = {}\n+ for r in range(1, h + 1):\n+ s = h - r\n+ f = lambda i, j: 0 if i < 0 or j >= h else min(i + 1, h - j, r, max(0, i - j + 1) + s)\n+ pc = [-1] * h\n+ for i in range(h):\n+ for j in range(h):\n+ if f(i, j) - f(i - 1, j) - f(i, j + 1) + f(i - 1, j + 1) == 1: pc[i] = j\n+ pr[r] = pc\n+ return pr" + }, + { + "sha": "536b9b40604d1391582b5e86ccc6aac64dc236d7", + "filename": "research/deferred-signed/swapnil-round7/independent/partial-swap/README.md", + "status": "added", + "additions": 10, + "deletions": 0, + "changes": 10, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,10 @@\n+# Partial-swap batching checks\n+\n+These check the partial-swap factorization lemma (`notes/partial-swap-batching.tex`) and the two-stage\n+frames at small h.\n+\n+```sh\n+python3 test_factor.py # exact Bruhat profiles of S_p on random, sparse and adversarial idempotents\n+python3 frames.py # two-stage frames at h = 6, 7, 8: monotonicity, rank sums, selected edges, profiles\n+python3 moment.py # certified batched saving at h = 32\n+```" + }, + { + "sha": "9908b695e021f9069123e2bf15095caf1ccae337", + "filename": "research/deferred-signed/swapnil-round7/independent/partial-swap/factor.py", + "status": "added", + "additions": 65, + "deletions": 0, + "changes": 65, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ffactor.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ffactor.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ffactor.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,65 @@\n+\"\"\"Exact lower-lower Bruhat factorization A = L1 * Mon * L2 (L1, L2 lower triangular, Mon monomial)\n+by elimination, plus helpers. Rows top-to-bottom; pivot = rightmost nonzero entry of the current row.\"\"\"\n+from fractions import Fraction as Q\n+\n+def ident(n): return [[Q(int(i == j)) for j in range(n)] for i in range(n)]\n+def mul(A, B):\n+ Bt = list(zip(*B))\n+ return [[sum((a*b for a, b in zip(r, c) if a and b), Q(0)) for c in Bt] for r in A]\n+def rank(M):\n+ M = [r[:] for r in M]; rk = 0; cols = len(M[0]) if M else 0\n+ for c in range(cols):\n+ piv = next((i for i in range(rk, len(M)) if M[i][c] != 0), None)\n+ if piv is None: continue\n+ M[rk], M[piv] = M[piv], M[rk]\n+ for i in range(rk+1, len(M)):\n+ if M[i][c] != 0:\n+ f = M[i][c]/M[rk][c]; M[i] = [a-f*b for a, b in zip(M[i], M[rk])]\n+ rk += 1\n+ return rk\n+def inv(M):\n+ n = len(M); A = [r[:]+[Q(int(i == j)) for j in range(n)] for i, r in enumerate(M)]\n+ for c in range(n):\n+ p = next(i for i in range(c, n) if A[i][c] != 0); A[c], A[p] = A[p], A[c]\n+ f = A[c][c]; A[c] = [x/f for x in A[c]]\n+ for i in range(n):\n+ if i != c and A[i][c] != 0:\n+ g = A[i][c]; A[i] = [a-g*b for a, b in zip(A[i], A[c])]\n+ return [r[n:] for r in A]\n+\n+def bruhat(A, track=True):\n+ \"\"\"Return (piv, L1, Mon, L2) with A = L1 Mon L2; piv[i] = column of row i's pivot.\"\"\"\n+ n = len(A); M = [r[:] for r in A]\n+ L1 = ident(n) if track else None; L2 = ident(n) if track else None\n+ piv = [None]*n\n+ for i in range(n):\n+ c = max((j for j in range(n) if M[i][j] != 0), default=None)\n+ if c is None: raise ValueError('singular')\n+ piv[i] = c; a = M[i][c]\n+ for k in range(i+1, n): # rows below: row_k -= f row_i (left lower op)\n+ if M[k][c] != 0:\n+ f = M[k][c]/a; M[k] = [x-f*y for x, y in zip(M[k], M[i])]\n+ if track: # L1 <- L1 (I + f e_k e_i^T): col_i += f col_k\n+ for r in range(n):\n+ if L1[r][k]: L1[r][i] += f*L1[r][k]\n+ for j in range(c): # cols left: col_j -= g col_c (right lower op)\n+ if M[i][j] != 0:\n+ g = M[i][j]/a\n+ for r in range(n):\n+ if M[r][c]: M[r][j] -= g*M[r][c]\n+ if track: # L2 <- (I + g e_c e_j^T) L2: row_c += g row_j\n+ L2[c] = [x+g*y for x, y in zip(L2[c], L2[j])]\n+ assert sorted(piv) == list(range(n))\n+ return piv, L1, M, L2\n+\n+def swapmat(p):\n+ m = len(p)\n+ return [[Q(int(i == j))-p[i][j] for j in range(m)]+[p[i][j] for j in range(m)] for i in range(m)] + \\\n+ [[p[i][j] for j in range(m)]+[Q(int(i == j))-p[i][j] for j in range(m)] for i in range(m)]\n+\n+def predicted(p_corner_perm, m, k):\n+ \"\"\"Predicted involution: H_l <-> D_sigma(l) (l in L), H_i <-> D_i (i in M), fixed elsewhere.\"\"\"\n+ w = list(range(2*m))\n+ for l, r in p_corner_perm.items(): w[l] = m+r; w[m+r] = l\n+ for i in range(k, m-k): w[i] = m+i; w[m+i] = i\n+ return w" + }, + { + "sha": "31c8130c5946574fd6996a56dac246ee688bffb1", + "filename": "research/deferred-signed/swapnil-round7/independent/partial-swap/frames.py", + "status": "added", + "additions": 174, + "deletions": 0, + "changes": 174, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fframes.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fframes.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fframes.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,174 @@\n+\"\"\"Task 2: explicit two-stage bit frames at small h (Gram I-J/9 on F=Q^h, G(x)G on F(x)F).\n+Builds every role class's label chain per invocation from the notes' schedules, checks monotonicity\n+(including X_a: U_a -> F), edge ranks, the ranks exceeding m/2, the per-role rank sums against\n+s_edge = Wm - 2N + 2L, and the batching hypothesis (simultaneous invertible corners after one\n+conjugation S0; full Bruhat profile of S_p on the selected projectors).\"\"\"\n+import random, sys\n+from itertools import combinations\n+from fractions import Fraction as Q\n+from factor import rank, inv, mul, bruhat, swapmat, predicted\n+\n+def kron(A, B):\n+ return [[a*b for a in ra for b in rb] for ra in A for rb in B]\n+def T(A): return [list(r) for r in zip(*A)]\n+\n+class Space:\n+ \"\"\"Subspace of Q^n given by a list of basis row vectors (reduced).\"\"\"\n+ def __init__(self, vecs, n):\n+ self.n = n; M = [list(v) for v in vecs]; B = []\n+ for v in M:\n+ w = v[:]\n+ for b, c in B:\n+ if w[c]: f = w[c]/b[c]; w = [x-f*y for x, y in zip(w, b)]\n+ c = next((i for i, x in enumerate(w) if x), None)\n+ if c is not None: B.append((w, c))\n+ self.B = [b for b, _ in B]\n+ @property\n+ def dim(self): return len(self.B)\n+ def __le__(self, o): return Space(o.B+self.B, self.n).dim == o.dim\n+ def __add__(self, o): return Space(self.B+o.B, self.n)\n+ def __eq__(self, o): return self <= o and o <= self\n+\n+def tens(U, V): return Space([[a*b for a in u for b in w] for u in U.B for w in V.B], U.n*V.n)\n+\n+def perp(U, G, n):\n+ \"\"\"G-orthogonal complement of U in Q^n.\"\"\"\n+ if not U.B: return Space([[Q(int(i == j)) for j in range(n)] for i in range(n)], n)\n+ A = mul(U.B, G) # rows: functionals u^T G\n+ # null space of A\n+ M = [r[:] for r in A]; piv = []; r0 = 0\n+ for c in range(n):\n+ p = next((i for i in range(r0, len(M)) if M[i][c]), None)\n+ if p is None: continue\n+ M[r0], M[p] = M[p], M[r0]; f = M[r0][c]; M[r0] = [x/f for x in M[r0]]\n+ for i in range(len(M)):\n+ if i != r0 and M[i][c]: g = M[i][c]; M[i] = [x-g*y for x, y in zip(M[i], M[r0])]\n+ piv.append(c); r0 += 1\n+ free = [c for c in range(n) if c not in piv]; out = []\n+ for fcol in free:\n+ v = [Q(0)]*n; v[fcol] = Q(1)\n+ for i, c in enumerate(piv): v[c] = -M[i][fcol]\n+ out.append(v)\n+ return Space(out, n)\n+\n+def proj(U, G):\n+ \"\"\"G-orthogonal projector onto nondegenerate U (column convention: p x).\"\"\"\n+ n = U.n\n+ if not U.B: return [[Q(0)]*n for _ in range(n)]\n+ Bc = T(U.B) # n x d\n+ Gr = mul(mul(U.B, G), Bc) # d x d Gram\n+ assert rank(Gr) == len(Gr), 'degenerate label'\n+ return mul(mul(Bc, inv(Gr)), mul(U.B, G))\n+\n+def run(h, data_sample, side_sample, seed=1, bruhat_count=None):\n+ rng = random.Random(seed)\n+ m = h*h; trip = list(combinations(range(h), 3)); v = len(trip)\n+ G = [[Q(int(i == j))-Q(1, 9) for j in range(h)] for i in range(h)]\n+ G2 = kron(G, G)\n+ tv = [[Q(int(i in t)) for i in range(h)] for t in trip]\n+ F = Space([[Q(int(i == j)) for j in range(h)] for i in range(h)], h)\n+ zeroF = Space([], h); FF = tens(F, F); zero = Space([], m)\n+ line = [Space([x], h) for x in tv]; lperp = [perp(L, G, h) for L in line]\n+ edges = [] # (role class, from, to) per traced role\n+ def chain(name, labels):\n+ for a, b in zip(labels, labels[1:]):\n+ if a <= b: edges.append((name, b.dim-a.dim, a, b, 'up'))\n+ else:\n+ assert b <= a, (name, 'incomparable labels')\n+ edges.append((name, a.dim-b.dim, a, b, 'down'))\n+ # source spans: common point i, target T containing i, sources S with S cap T = {i}\n+ def rect(T_):\n+ i = rng.choice(T_)\n+ src = [s for s, t in enumerate(trip) if i in t and set(t) & set(trip[T_]) == {i}] if False else \\\n+ [s for s, t in enumerate(trip) if i in t and set(t) & set(T_) == {i}]\n+ S = rng.sample(src, rng.randint(1, min(4, len(src))))\n+ U = Space([tv[s] for s in S], h)\n+ return S, U\n+ batched = {}\n+ for a2 in range(v): # stage 1, fixed a2 (Q = line a2); D0 = 0, D1 = F (x) t_a2\n+ Qs = line[a2]; D0 = zero; D1 = tens(F, Qs)\n+ X = {a1: tens(line[a1], Qs) for a1 in range(v)}\n+ Y = {a1: tens(lperp[a1], Qs) for a1 in range(v)}\n+ for _ in range(side_sample):\n+ T_ = trip[rng.randrange(v)]; S, U = rect(T_)\n+ DU = tens(U, Qs); tY = trip.index(T_)\n+ for s in S:\n+ assert line[s] <= U and U <= lperp[tY]\n+ chain('s1 input-only', [zero, D0, X[S[0]], DU, D1, FF])\n+ chain('s1 output-only', [zero, D0, DU, Y[tY], D1, FF])\n+ chain('s1 center', [zero, D0, D1, D0, D1, FF])\n+ batched[('s1 aux', a2)] = (D1, FF)\n+ for a1 in range(v): # stage 2 reverse, fixed a1; D0 = t_a1^perp (x) F, D1 = F (x) F\n+ D0 = tens(lperp[a1], F); D1 = FF; P = line[a1]\n+ X = {a2: D0 + tens(P, line[a2]) for a2 in range(v)}\n+ Y = {a2: D0 + tens(P, lperp[a2]) for a2 in range(v)}\n+ for _ in range(side_sample):\n+ T_ = trip[rng.randrange(v)]; S, U = rect(T_); tY = trip.index(T_)\n+ DU = D0 + tens(P, U)\n+ # reverse: physical X are the rectangle's logical targets; physical roles swap descriptions\n+ chain('s2 input-only', [zero, D0, X[S[0]], DU, D1])\n+ chain('s2 output-only', [zero, D0, DU, Y[tY], D1])\n+ chain('s2 center', [zero, D0, D1, D0, D1])\n+ batched[('s2 aux', a1)] = (zero, D0)\n+ # data roles (sampled pairs a=(a1,a2)): stage-1 forward then stage-2 reverse\n+ pairs = [(rng.randrange(v), rng.randrange(v)) for _ in range(data_sample)]\n+ Xmono = True\n+ for a1, a2 in pairs:\n+ Ua = tens(line[a1], line[a2]); Uap = perp(Ua, G2, m)\n+ s1X = [Ua, tens(line[a1], line[a2]), tens(F, line[a2])] # V at X_t, G/V at D1\n+ s1Y = [zero, zero, tens(lperp[a1], line[a2])] # J,R at D0=0, J at Y_t\n+ D0 = tens(lperp[a1], F)\n+ s2X = [tens(F, line[a2]), D0 + tens(line[a1], line[a2]), FF] # J at X_t, R/J at D1\n+ s2Y = [tens(lperp[a1], line[a2]), D0, D0 + tens(line[a1], lperp[a2])] # V,G at D0, V at Y_t\n+ assert s1X[-1] == s2X[0] and s1Y[-1] == s2Y[0], 'interstage boundary mismatch'\n+ assert s2Y[-1] == Uap, 'Y terminal is not U_a^perp'\n+ Xch = s1X+s2X[1:]\n+ Xmono &= all(a <= b for a, b in zip(Xch, Xch[1:])) and Xch[0] == Ua and Xch[-1] == FF\n+ chain('data X', Xch); chain('data Y', s1Y+s2Y[1:])\n+ batched[('data', a1, a2)] = (tens(F, line[a2]), D0 + tens(line[a1], line[a2]))\n+ # summarize edges\n+ summary = {}\n+ for name, r, a, b, d in edges:\n+ summary.setdefault(name, {}).setdefault((d, r), 0); summary[name][(d, r)] += 1\n+ per_role = {}\n+ for name, r, a, b, d in edges: per_role.setdefault(name, 0); per_role[name] += r\n+ print('h=%d m=%d v=%d: X_a monotone U_a->F on %d sampled pairs: %s' % (h, m, v, len(pairs), Xmono))\n+ for name, d in summary.items(): print(' %-16s (direction, rank): count %s' % (name, dict(sorted(d.items()))))\n+ big = sorted({(name, r) for name, r, a, b, dd in edges if r > m//2})\n+ print(' edges with rank > m/2:', big, ' predicted aux m-h=%d, data m-2h+1=%d' % (m-h, m-2*h+1))\n+ # batching hypothesis on the selected projectors after ONE conjugation S0\n+ projs = {}\n+ for key, (U, V) in batched.items():\n+ p = [[x-y for x, y in zip(r1, r2)] for r1, r2 in zip(proj(V, G2), proj(U, G2))]\n+ assert mul(p, p) == p\n+ projs[key] = p\n+ while True:\n+ Lw = [[Q(rng.randint(-2, 2)) if j < i else Q(int(i == j)) for j in range(m)] for i in range(m)]\n+ Up = [[Q(rng.randint(-2, 2)) if j > i else Q(int(i == j)) for j in range(m)] for i in range(m)]\n+ S0 = mul(Lw, Up); S0i = inv(S0)\n+ conj = {k_: mul(mul(S0, p), S0i) for k_, p in projs.items()}\n+ bad = []\n+ unconj_bad = 0\n+ for k_, p in conj.items():\n+ a = m-rank([[Q(int(i == j))-x for j, x in enumerate(r)] for i, r in enumerate(p)])\n+ kk = m-a\n+ if rank([r[m-kk:] for r in p[:kk]]) < kk: bad.append(k_)\n+ if rank([r[m-kk:] for r in projs[k_][:kk]]) < kk: unconj_bad += 1\n+ print(' unconjugated selected projectors with singular corner: %d / %d' % (unconj_bad, len(projs)))\n+ print(' after one unimodular S0: singular corners %d / %d' % (len(bad), len(projs)))\n+ if not bad: break\n+ # full Bruhat profile of S_p on conjugated selected projectors\n+ keys = list(conj)\n+ if bruhat_count is not None: keys = rng.sample(keys, min(bruhat_count, len(keys)))\n+ okc = 0\n+ for k_ in keys:\n+ p = conj[k_]; Sp = swapmat(p); piv, L1, Mon, L2 = bruhat(Sp)\n+ assert mul(mul(L1, Mon), L2) == Sp\n+ a = sum(1 for i, c in enumerate(piv) if c > i); kk = m-a\n+ cp, *_ = bruhat([r[m-kk:] for r in p[:kk]], track=False)\n+ okc += piv == predicted({l: m-kk+cp[l] for l in range(kk)}, m, kk)\n+ print(' Bruhat profile == k corner swaps + one aligned width-t block on %d / %d selected projectors' % (okc, len(keys)))\n+ return per_role\n+\n+if __name__ == '__main__':\n+ h = int(sys.argv[1]); run(h, int(sys.argv[2]), int(sys.argv[3]), bruhat_count=(None if sys.argv[4] == 'all' else int(sys.argv[4])))" + }, + { + "sha": "1d0c379fb8490f6f51717888da5904c9c1168e44", + "filename": "research/deferred-signed/swapnil-round7/independent/partial-swap/moment.py", + "status": "added", + "additions": 48, + "deletions": 0, + "changes": 48, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fmoment.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fmoment.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Fmoment.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,48 @@\n+\"\"\"Exact batched moment for the two-stage bit network (independent of batched_two_stage.py).\n+Psi(1-a) = sum_i w_i exp(a log(1/r_i)) <= sum_i w_i/(1 - a l_i), l_i rigorous rational upper bounds.\"\"\"\n+from fractions import Fraction as Q\n+from math import comb, log\n+\n+def log_ub(x, terms=40):\n+ \"\"\"Rigorous upper bound for log x, x>1 rational: 2*sum z^(2j+1)/(2j+1) + tail, z=(x-1)/(x+1).\"\"\"\n+ x = Q(x); k = 0\n+ while x > 2: x /= 2; k += 1 # extract powers of two\n+ def at(z):\n+ s = sum(2*z**(2*j+1)/(2*j+1) for j in range(terms))\n+ return s + 2*z**(2*terms+1)/((2*terms+1)*(1-z*z))\n+ return k*at(Q(1, 3)) + (at((x-1)/(x+1)) if x > 1 else 0)\n+\n+def classes(h, R, data):\n+ v, m, c0 = comb(h, 3), h*h, h\n+ N = v*v; W = 2*N+2*v*(R+c0); L = 2*v*h*c0; s = W*m-N+2*L\n+ cl = [(2*v*(R+c0), m-2*h)] # aux: rank m-h -> h corners + block t=m-2h\n+ if data == 'correct': cl.append((2*N, m-4*h+2)) # stage-2 data entrances: rank m-2h+1 -> t=m-4h+2\n+ if data == 'as-script': cl.append((2*N, m-2*h))\n+ return dict(m=m, W=W, s=s, cl=cl)\n+\n+def bound(c, a):\n+ m, W, s = c['m'], c['W'], c['s']\n+ single = s-sum(B*t for B, t in c['cl'])\n+ tot = Q(single, W*m)/(1-a*log_ub(m))\n+ for B, t in c['cl']: tot += Q(B*t, W*m)/(1-a*log_ub(Q(m, t)))\n+ return tot\n+\n+def true_root(c):\n+ m, W, s = c['m'], c['W'], c['s']; single = s-sum(B*t for B, t in c['cl'])\n+ f = lambda a: single/(W*m)*m**a + sum(B*t/(W*m)*(m/t)**a for B, t in c['cl'])\n+ lo, hi = 0.0, 1e-3\n+ for _ in range(200):\n+ mid = (lo+hi)/2; lo, hi = (mid, hi) if f(mid) < 1 else (lo, mid)\n+ return lo\n+\n+if __name__ == '__main__':\n+ assert log_ub(1024) > Q(6931471805599453, 10**15)\n+ for data in ('none', 'correct', 'as-script'):\n+ c = classes(32, 123157, data)\n+ claim = Q(22157, 5*10**9)\n+ b = bound(c, claim)\n+ print('data=%-9s claimed a_b=%s: certified bound %.12f <1: %s, gap %.3e; true root a*=%.6e'\n+ % (data, claim, float(b), b < 1, float(1-b), true_root(c)))\n+ n = int(true_root(c)*10**10)+2\n+ while not bound(c, Q(n, 10**10)) < 1: n -= 1\n+ print(' largest certified a at 1e-10 grid: %s = %.4e' % (Q(n, 10**10), n/1e10))" + }, + { + "sha": "aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0", + "filename": "research/deferred-signed/swapnil-round7/independent/partial-swap/test_factor.py", + "status": "added", + "additions": 102, + "deletions": 0, + "changes": 102, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ftest_factor.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ftest_factor.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpartial-swap%2Ftest_factor.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,102 @@\n+\"\"\"Task 1: exact checks of the partial-swap batching factorization.\n+For idempotent p (rank a, m/2D_sigma(l) (sigma = corner's own Bruhat\n+permutation), H_i<->D_i for i in M=[k, m-k), fixed elsewhere; and S_p = L1 (w D) L2 exactly.\n+Also implements the batched schedule mod a prime and compares with S_p x.\"\"\"\n+import random, sys\n+from fractions import Fraction as Q\n+from factor import bruhat, swapmat, predicted, mul, inv, rank, ident\n+\n+def rand_idem(m, a, rng, lo=-3, hi=3, kind='generic'):\n+ while True:\n+ S = [[Q(rng.randint(lo, hi)) for _ in range(m)] for _ in range(m)]\n+ if kind == 'sparse':\n+ S = [[x if rng.random() < .3 or i == j else Q(0) for j, x in enumerate(r)] for i, r in enumerate(S)]\n+ if rank(S) == m: break\n+ D = [[Q(int(i == j and i < a)) for j in range(m)] for i in range(m)]\n+ return mul(mul(S, D), inv(S))\n+\n+def corner(p, k): m = len(p); return [r[m-k:] for r in p[:k]]\n+\n+def check(p, sim_prime=None, rng=None):\n+ \"\"\"Return ('skip'|'ok'|'FAIL', info).\"\"\"\n+ m = len(p); a = rank(p); k = m-a\n+ assert mul(p, p) == p\n+ C = corner(p, k)\n+ S = swapmat(p)\n+ piv, L1, Mon, L2 = bruhat(S)\n+ assert mul(mul(L1, Mon), L2) == S, 'factorization identity'\n+ assert all(L1[i][j] == 0 for i in range(2*m) for j in range(i+1, 2*m))\n+ assert all(L2[i][j] == 0 for i in range(2*m) for j in range(i+1, 2*m))\n+ nontriv = sum(1 for i, c in enumerate(piv) if c > i)\n+ invol = all(piv[piv[i]] == i for i in range(2*m))\n+ if rank(C) < k:\n+ return 'singular', dict(nontriv=nontriv, a=a, invol=invol,\n+ aligned_mid=all(piv[i] == m+i for i in range(k, m-k)))\n+ cp, *_ = bruhat(C, track=False)\n+ sigma = {l: m-k+cp[l] for l in range(k)}\n+ ok = piv == predicted(sigma, m, k)\n+ if ok and sim_prime: # run the batched schedule over Z/q (field width b=1)\n+ q = sim_prime\n+ def md(x):\n+ return x.numerator*pow(x.denominator, -1, q) % q\n+ x = [rng.randrange(q) for _ in range(2*m)]\n+ y = [sum(md(L2[i][j])*x[j] for j in range(i+1)) % q for i in range(2*m)] # lower: earlier controls\n+ # monomial: out_i = Mon[i][piv[i]] * y[piv[i]]; done as: scale, k corner swaps, ONE block swap\n+ sc = [0]*(2*m)\n+ for i in range(2*m): sc[piv[i]] = md(Mon[i][piv[i]])\n+ y = [sc[j]*y[j] % q for j in range(2*m)] # unit diagonal scaling (column side)\n+ for l in range(k): y[l], y[sigma[l]+m] = y[sigma[l]+m], y[l] # k width-b corner swaps\n+ y[k:m-k], y[m+k:2*m-k] = y[m+k:2*m-k], y[k:m-k] # one contiguous width-(t b) interchange\n+ out = [sum(md(L1[i][j])*y[j] for j in range(i+1)) % q for i in range(2*m)]\n+ want = [sum(md(S[i][j])*x[j] for j in range(2*m)) % q for i in range(2*m)]\n+ assert out == want, 'mod-q schedule mismatch'\n+ return ('ok' if ok else 'FAIL'), dict(nontriv=nontriv, a=a)\n+\n+def denoms(M):\n+ d = 1\n+ for r in M:\n+ for x in r: d = d*x.denominator//__import__('math').gcd(d, x.denominator)\n+ return d\n+\n+if __name__ == '__main__':\n+ tally = {}\n+ rng = random.Random(2026)\n+ cases = []\n+ # all (m, a) with m in 3..12 and every a in (m/2, m), including a = floor(m/2)+1 (t = 1 or 2)\n+ for m in range(3, 13):\n+ for a in range(m//2+1, m):\n+ for rep in range(6): cases.append((m, a, 'generic'))\n+ for rep in range(3): cases.append((m, a, 'sparse'))\n+ for m, a, kind in cases:\n+ p = rand_idem(m, a, rng, kind=kind)\n+ st, info = check(p, sim_prime=1000003, rng=rng)\n+ tally[st] = tally.get(st, 0)+1\n+ if st == 'FAIL': print('FAIL', m, a, kind, info); sys.exit(1)\n+ if st == 'singular':\n+ tally.setdefault('singular_profiles', set()).add((info['nontriv'] == info['a'], info['invol'], info['aligned_mid']))\n+ print('random idempotents:', {k: v for k, v in tally.items()})\n+ # adversarial: corner singular by construction\n+ adv = {}\n+ for m in range(4, 11):\n+ for a in range(m//2+1, m):\n+ k = m-a\n+ # p = diag-type: coordinate projector onto first a coords (corner is zero)\n+ p = [[Q(int(i == j and i < a)) for j in range(m)] for i in range(m)]\n+ st, info = check(p); adv.setdefault('coordinate', []).append((m, a, st, info['nontriv'], info['aligned_mid']))\n+ # projector whose kernel misses the last k coordinates (U_L singular): q = UV with U_L rank-deficient\n+ while True:\n+ U = [[Q(rng.randint(-2, 2)) for _ in range(k)] for _ in range(m)]\n+ U[0] = [Q(0)]*k # first row of U zero -> U_L singular\n+ V = [[Q(rng.randint(-2, 2)) for _ in range(m)] for _ in range(k)]\n+ VU = mul(V, U)\n+ if rank(U) == k and rank(VU) == k: break\n+\n+ qq = mul(mul(U, inv(VU)), V)\n+ p = [[Q(int(i == j))-qq[i][j] for j in range(m)] for i in range(m)]\n+ st, info = check(p); adv.setdefault('U_L singular', []).append((m, a, st, info['nontriv'], info['aligned_mid']))\n+ for k_, v in adv.items():\n+ bad_aligned = [x for x in v if not x[4]]\n+ print('adversarial', k_, ': all singular corners =', all(x[2] == 'singular' for x in v),\n+ '| nontriv==a in', sum(x[3] == x[1] for x in v), '/', len(v),\n+ '| middle NOT aligned in', len(bad_aligned), '/', len(v), 'e.g.', bad_aligned[:2])" + }, + { + "sha": "390bb577fd4ec1fa774ded95887ce5855adc17e7", + "filename": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/README.md", + "status": "added", + "additions": 17, + "deletions": 0, + "changes": 17, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2FREADME.md", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2FREADME.md", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2FREADME.md?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,17 @@\n+# Independent recount of PR #7's role counts\n+\n+This is an independent re-implementation, written from the construction note of\n+CrocSwap/integer-mult-bounds PR #7. It recounts the bit-producer and complex-producer roles\n+that our witness assumes. No code from that PR is executed.\n+\n+```sh\n+python3 export.py 26 /tmp/local26.txt # local paired degree-three producer, n = h - 2\n+clang++ -O2 -std=c++17 global.cpp -o /tmp/global\n+/tmp/global 28 /tmp/local26.txt # merging, star resynthesis, rebuild check (~1 GB)\n+python3 complexside.py 28 # complex producer\n+python3 local.py 8 10 12 # exact small-h support checks\n+```\n+\n+Expected values: 11240978 merged additions, 10857762 final additions, 983178 output uses,\n+11840940 bit roles; and 61022 additions plus 32816 injections, giving 93838 complex roles.\n+These match PR #7's certificate." + }, + { + "sha": "5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6", + "filename": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/complexside.py", + "status": "added", + "additions": 59, + "deletions": 0, + "changes": 59, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Fcomplexside.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Fcomplexside.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Fcomplexside.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,59 @@\n+\"\"\"Complex side: +1/2 * disjoint-triple sum (paired producer) and -1/2 * pair stars,\n+with pieces split while they cover every point outside the target.\"\"\"\n+import sys\n+from itertools import combinations\n+from local import Producer\n+h=int(sys.argv[1]); full=(1<\n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+#include \n+using namespace std;\n+typedef uint32_t U; typedef uint64_t V;\n+\n+struct K7 { array x{}; bool operator==(const K7&o)const{return x==o.x;} };\n+struct HK { size_t operator()(const K7&k)const{ V h=1469598103934665603ULL; for(V y:k.x){ y*=0x9E3779B97F4A7C15ULL; y^=y>>29; h=(h^y)*1099511628211ULL; } return h; } };\n+\n+int h, n, ni;\n+vector> trip; // local triples\n+int main(int argc,char**argv){\n+ h=atoi(argv[1]); const char* lf=argv[2]; int absorb = argc>3 ? atoi(argv[3]) : 1;\n+ FILE* f=fopen(lf,\"r\"); int na; fscanf(f,\"%d %d %d\",&n,&ni,&na); assert(n==h-2);\n+ trip.resize(ni); for(auto&t:trip) fscanf(f,\"%d %d %d\",&t[0],&t[1],&t[2]);\n+ vector> ladd(na); int maxid=ni;\n+ for(auto&r:ladd){ fscanf(f,\"%d %d %d\",&r[0],&r[1],&r[2]); maxid=max(maxid,r[0]); }\n+ vector,int>> lout(ni); for(auto&o:lout) fscanf(f,\"%d %d %d %d\",&o.first[0],&o.first[1],&o.first[2],&o.second);\n+ int ltotal; fscanf(f,\"%d\",<otal); fclose(f);\n+ // local supports (as bitsets over ni) and local cores\n+ int W=(ni+63)/64; unordered_map pos; vector> sup; vector lcore;\n+ auto getpos=[&](int id)->int{ auto it=pos.find(id); assert(it!=pos.end()); return it->second; };\n+ for(int i=0;i s(W,0); s[i/64]|=1ULL<<(i%64); sup.push_back(s);\n+ lcore.push_back((1U< s(W);\n+ for(int w=0;w>(i%64))&1; assert(in==((t&E)==0)); } }\n+ // residual lists per local node with nonempty local core\n+ int L=sup.size(); vector> resid(L); // for core1: pairs of local points (a*32+b); core2: single point\n+ for(int p=ni;p>(i%64))&1){ U t=((1U< fid; vector fmask; fmask.push_back(0);\n+ for(U m=0;m<(1U<> args(v+1,{0,0}); vector core(v+1); for(int i=1;i<=v;i++) core[i]=fmask[i];\n+ vector starm(v+1,0); // for core-4 nodes, residual point mask\n+ unordered_map m3; unordered_map m4; if(h==28){ m3.reserve(7000000); m4.reserve(4000000);}\n+ vector roots; vector> rootinfo; // (C mask, E mask or 0 for total, id)\n+ long long instances=0;\n+ for(int ca=0;ca ord;\n+ for(int x=0;x>x&1) && !(C>>(x+1)&1)){ ord.push_back(x); ord.push_back(x+1);}\n+ for(int x=0;x>x&1) && (C>>(x^1)&1)) ord.push_back(x);\n+ assert((int)ord.size()==n);\n+ auto mapm=[&](U lm){ U g=0; while(lm){int i=__builtin_ctz(lm); lm&=lm-1; g|=1U< gid(L);\n+ for(int i=0;isecond; else { id=args.size(); m3.emplace(k,id); args.push_back({(U)a,(U)b}); core.push_back(gc); starm.push_back(0);} }\n+ else { assert(nc==4); U rm=0; for(U r:resid[p]) rm|=1U<second; else { id=args.size(); m4.emplace(k,id); args.push_back({(U)a,(U)b}); core.push_back(gc); starm.push_back(rm);} }\n+ gid[p]=id; }\n+ for(auto&o:lout){ U E=mapm((1U< act(N,0); vector st(roots.begin(),roots.end()); long long actadds=0, actin=0;\n+ while(!st.empty()){U x=st.back(); st.pop_back(); if(act[x])continue; act[x]=1; if(args[x][0]){actadds++; assert(args[x][0] starsize; map> demand; vector isdem(N,0);\n+ for(size_t x=v+1;x,vector>> cache; long long oldst=0,newst=0;\n+ map>> starGates; map> starOrd; // gates in canonical coords\n+ for(auto& [B,ms]:starsize){ (void)ms; }\n+ for(auto& kv:demand){ U B=kv.first; vector ord;\n+ for(int x=0;x>x&1)&&!(B>>(x^1)&1)) ord.push_back(x);\n+ for(int x=0;x>x&1)&&(B>>(x^1)&1)) ord.push_back(x);\n+ assert((int)ord.size()==h-4);\n+ vector tg; for(U m:kv.second){ U z=0; for(int j=0;j<(int)ord.size();j++) if(m>>ord[j]&1) z|=1U<> terms; set nodes; for(U m:tg){ set s; for(int j=0;j>j&1){ s.insert(1U<> gates;\n+ while(true){ bool any=false; for(auto&t:terms) if(t.size()>1) any=true; if(!any) break;\n+ map,int> fr; for(auto&t:terms){ vector e(t.begin(),t.end()); for(size_t i=0;i best; bool have=false; int bf=0;\n+ for(auto& [p,c]:fr){ U u=p.first|p.second; if(!have){best=p;bf=c;have=true;continue;}\n+ U bu=best.first|best.second;\n+ auto key=make_tuple(-c,__builtin_popcount(u),u,p.first,p.second); auto bk=make_tuple(-bf,__builtin_popcount(bu),bu,best.first,best.second);\n+ if(key c; U s=0; for(U x:t) if((x&~nd)==0){c.push_back(x); s|=x;} if(c.size()>1 && s==nd){ for(U x:c) t.erase(x); t.insert(nd);} }\n+ }\n+ // independent validity check of the template\n+ set have; for(int j=0;jsecond.size();\n+ starGates[B]=it->second; starOrd[B]=vector(ord.begin(),ord.end()); }\n+ // stars that are active but have no demanded node would be fully removable\n+ long long undemanded=0; for(auto&[B,c]:starsize) if(!demand.count(B)) undemanded+=c;\n+ long long opt=actadds-oldst-undemanded+newst;\n+ printf(\"{\\\"stars_with_demand\\\":%zu,\\\"stars_total\\\":%zu,\\\"templates\\\":%zu,\\\"old_star_additions\\\":%lld,\\\"undemanded_star_additions\\\":%lld,\\\"new_star_additions\\\":%lld,\\\"optimized_additions\\\":%lld,\\\"output_uses\\\":%zu,\\\"roles\\\":%lld}\\n\",\n+ demand.size(),starsize.size(),cache.size(),oldst,undemanded,newst,opt,roots.size(),opt+(long long)roots.size());\n+ bool full=h<=16;\n+ // Rebuild the final DAG and check every coefficient exactly (small h).\n+ int FW=full?(v+63)/64:0; vector> fs; fs.push_back(vector(FW,0));\n+ for(int i=1;i<=v;i++){ vector s(FW,0); if(full) s[(i-1)/64]|=1ULL<<((i-1)%64); fs.push_back(s);}\n+ long long finaladds=0; vector remap(N,0); for(int i=1;i<=v;i++) remap[i]=i;\n+ auto addnode=[&](U a,U b){ vector s(FW); for(int w=0;w,U> starnode; // (B, global residual mask) -> final id\n+ for(auto&[B,gates]:starGates){ auto&ord=starOrd[B]; map loc; for(int j=0;j>j&1) gm|=1U<> coef(v+1, vector(v+1,0));\n+ for(size_t r=0;r>((i-1)%64))&1; bool exp= tot ? ((T&C)==C) : ((T&C)==C && (T&E)==0); assert(in==exp); }\n+ if(tot){ for(int s=1;s<=v;s++) if((fmask[s]&C)==C) for(int i=1;i<=v;i++) if((fs[id][(i-1)/64]>>((i-1)%64))&1) coef[s][i]+=1; }\n+ else { int s=fid.at(C|E); for(int i=1;i<=v;i++) if((fs[id][(i-1)/64]>>((i-1)%64))&1) coef[s][i]-=1; } }\n+ for(int s=1;s<=v;s++) for(int i=1;i<=v;i++){ int c=((coef[s][i]%3)+3)%3; assert(c==(s==i)); }\n+ printf(\"{\\\"h\\\":%d,\\\"final_dag_rebuilt\\\":true,\\\"every_root_support_exact\\\":true,\\\"combined_map_identity_mod3\\\":true,\\\"final_additions\\\":%lld}\\n\",h,finaladds);\n+}" + }, + { + "sha": "5e8157d957e67293c66f6793911ef77cf6581135", + "filename": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/local.py", + "status": "added", + "additions": 174, + "deletions": 0, + "changes": 174, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Flocal.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Flocal.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Fpr7-role-counts%2Flocal.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,174 @@\n+\"\"\"Independent re-implementation of the paired degree-three exclusion producer.\n+\n+Problem: points P (n of them), inputs x_U for 3-subsets U. For every E subset of\n+P with |E|<=3 produce D_E = sum of x_U with U disjoint from E, using only\n+disjoint (cancellation-free) additions. Nodes are interned by exact support.\n+\"\"\"\n+from itertools import combinations\n+from collections import defaultdict\n+\n+\n+class DAG:\n+ def __init__(self, nleaves):\n+ self.sup = [0] + [1 << i for i in range(nleaves)]\n+ self.args = [None] * (nleaves + 1)\n+ self.idx = {s: i for i, s in enumerate(self.sup)}\n+\n+ def add(self, a, b):\n+ if not a: return b\n+ if not b: return a\n+ sa, sb = self.sup[a], self.sup[b]\n+ assert sa & sb == 0\n+ s = sa | sb\n+ r = self.idx.get(s)\n+ if r is None:\n+ r = len(self.sup); self.idx[s] = r; self.sup.append(s); self.args.append((a, b))\n+ return r\n+\n+ def tot(self, xs):\n+ # balanced tree, first half = floor(len/2)\n+ xs = list(xs)\n+ if not xs: return 0\n+ if len(xs) == 1: return xs[0]\n+ m = len(xs) // 2\n+ return self.add(self.tot(xs[:m]), self.tot(xs[m:]))\n+\n+ def loo(self, xs):\n+ \"\"\"total and leave-one-out sums via prefix/suffix chains.\"\"\"\n+ n = len(xs); pre = [0]\n+ for x in xs: pre.append(self.add(pre[-1], x))\n+ suf = [0] * (n + 1)\n+ for i in range(n - 1, -1, -1): suf[i] = self.add(xs[i], suf[i + 1])\n+ return pre[n], [self.add(pre[i], suf[i + 1]) for i in range(n)]\n+\n+ def active(self, roots):\n+ seen = set(); st = list(roots)\n+ while st:\n+ x = st.pop()\n+ if not x or x in seen: continue\n+ seen.add(x)\n+ if self.args[x]: st.extend(self.args[x])\n+ return seen\n+\n+\n+def pairs_of(pts):\n+ return [pts[i:i + 2] for i in range(0, len(pts), 2)]\n+\n+\n+class Producer:\n+ def __init__(self, n, base=4, order_style='theirs'):\n+ self.n = n; self.base = base\n+ self.inputs = list(combinations(range(n), 3))\n+ self.d = DAG(len(self.inputs))\n+ w = {t: i + 1 for i, t in enumerate(self.inputs)}\n+ self.res = self.deg3(list(range(n)), w)\n+ self.outputs = {E: self.res[E] for E in self.inputs}\n+ self.total = self.res[()]\n+\n+ # degree <= 2 weighted exclusion: monomials are vertex weights (1 pt) and\n+ # edges (2 pts); returns total, exclude-one, exclude-two (pairs).\n+ def deg2(self, pts, edges, wts):\n+ d = self.d\n+ if len(pts) <= 4:\n+ def f(om):\n+ om = set(om)\n+ return d.tot([x for p, x in edges.items() if not (set(p) & om)] +\n+ [x for p, x in wts.items() if p not in om])\n+ return f(()), {a: f((a,)) for a in pts}, {(a, b): f((a, b)) for a, b in combinations(pts, 2)}\n+ gs = pairs_of(pts); k = len(gs)\n+ E = lambda a, b: edges[(a, b) if a < b else (b, a)]\n+ cedge = {(i, j): d.tot([E(a, b) for a in gs[i] for b in gs[j]]) for i, j in combinations(range(k), 2)}\n+ cw = {i: d.tot([wts[a] for a in g] + [E(a, b) for a, b in combinations(g, 2)]) for i, g in enumerate(gs)}\n+ T, out1, out2 = self.deg2(list(range(k)), cedge, cw)\n+ strip = {}; ssum = {}\n+ for i, g in enumerate(gs):\n+ oth = [j for j in range(k) if j != i]\n+ for a in g:\n+ rest = [u for u in g if u != a]\n+ carry = d.tot([wts[u] for u in rest])\n+ vals = [d.tot([E(u, v) for u in rest for v in gs[j]]) for j in oth]\n+ s, lo = d.loo([carry] + vals)\n+ ssum[a] = s; strip[a] = dict(zip(oth, lo[1:]))\n+ single = {a: d.add(out1[i], ssum[a]) for i, g in enumerate(gs) for a in g}\n+ pair = {}\n+ for i, g in enumerate(gs):\n+ for a, b in combinations(g, 2): pair[a, b] = out1[i]\n+ for i, j in combinations(range(k), 2):\n+ for a in gs[i]:\n+ left = d.add(out2[i, j], strip[a][j])\n+ for b in gs[j]:\n+ cross = d.tot([E(u, v) for u in gs[i] if u != a for v in gs[j] if v != b])\n+ pair[a, b] = d.add(left, d.add(strip[b][i], cross))\n+ return T, single, pair\n+\n+ def deg3(self, pts, w):\n+ d = self.d\n+ subs = [s for r in range(4) for s in combinations(pts, r)]\n+ if len(pts) <= self.base:\n+ return {s: d.tot([x for t, x in w.items() if not (set(s) & set(t))]) for s in subs}\n+ gs = pairs_of(pts); k = len(gs)\n+ gof = {u: i for i, g in enumerate(gs) for u in g}\n+ cparts = defaultdict(list)\n+ for t, x in w.items(): cparts[tuple(sorted({gof[u] for u in t}))].append(x)\n+ cw = {G: d.tot(xs) for G, xs in cparts.items()}\n+ RC = self.deg3(list(range(k)), cw)\n+ one = {}\n+ for u in pts:\n+ g = gof[u]; oth = [j for j in range(k) if j != g]\n+ parts = defaultdict(list)\n+ for t, x in w.items():\n+ if u not in t: continue\n+ rest = [a for a in t if a != u]\n+ if any(gof[a] == g for a in rest): continue\n+ parts[tuple(sorted({gof[a] for a in rest}))].append(x)\n+ c = {G: d.tot(xs) for G, xs in parts.items()}\n+ edges = {G: c.get(G, 0) for G in combinations(oth, 2)}\n+ wts = {j: c.get((j,), 0) for j in oth}\n+ T, s1, s2 = self.deg2(oth, edges, wts)\n+ c0 = c.get((), 0)\n+ one[u] = {(): d.add(c0, T)}\n+ one[u].update({(j,): d.add(c0, x) for j, x in s1.items()})\n+ one[u].update({G: d.add(c0, x) for G, x in s2.items()})\n+ two = {}\n+ for u, v in combinations(pts, 2):\n+ i, j = gof[u], gof[v]\n+ if i == j: continue\n+ oth = [q for q in range(k) if q not in (i, j)]\n+ vals = [d.tot([w.get(tuple(sorted((u, v, a))), 0) for a in gs[q]]) for q in oth]\n+ T, lo = d.loo([w.get((u, v), 0)] + vals)\n+ two[u, v] = {(): T}; two[u, v].update({(q,): x for q, x in zip(oth, lo[1:])})\n+ res = {}\n+ for Ex in subs:\n+ Es = set(Ex); G = tuple(sorted({gof[a] for a in Es}))\n+ surv = [u for i in G for u in gs[i] if u not in Es]\n+ pc = {(): RC[G]}\n+ for u in surv:\n+ pc[(u,)] = one[u][tuple(i for i in G if i != gof[u])]\n+ for u, v in combinations(surv, 2):\n+ pc[(u, v)] = two[u, v][tuple(i for i in G if i not in (gof[u], gof[v]))]\n+ if len(surv) == 3:\n+ a, b, c = surv\n+ pc[(a, b, c)] = w.get((a, b, c), 0)\n+ order = [(), (a,), (b,), (a, b), (c,), (a, c), (b, c), (a, b, c)]\n+ else:\n+ order = [s for r in range(len(surv) + 1) for s in combinations(surv, r)]\n+ res[Ex] = d.tot([pc[s] for s in order])\n+ return res\n+\n+ def check(self):\n+ \"\"\"Every output support equals the exact disjoint family; all adds disjoint.\"\"\"\n+ n = self.n\n+ for E, node in self.res.items():\n+ Es = set(E)\n+ exp = sum(1 << i for i, t in enumerate(self.inputs) if not (Es & set(t)))\n+ assert self.d.sup[node] == exp, E\n+ return True\n+\n+\n+if __name__ == '__main__':\n+ import sys, time\n+ for n in map(int, sys.argv[1:]):\n+ t = time.time(); p = Producer(n); p.check()\n+ act = p.d.active(p.outputs.values()); a1 = sum(1 for x in act if p.d.args[x])\n+ act2 = p.d.active(list(p.outputs.values()) + [p.total]); a2 = sum(1 for x in act2 if p.d.args[x])\n+ print(n, 'outputs-only additions', a1, 'with total', a2, 'time %.1f' % (time.time() - t), flush=True)" + }, + { + "sha": "f2c4ece08c01503a9ef42f67081b3abe0aab9321", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/bruhat8.py", + "status": "added", + "additions": 17, + "deletions": 0, + "changes": 17, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fbruhat8.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fbruhat8.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fbruhat8.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,17 @@\n+\"\"\"Exact Bruhat profile of S_p for data stage-2 entrance projectors p = Q_a1 (x) Q_a2 at h=8 after one S0.\"\"\"\n+import sys, random\n+sys.path.insert(0, __import__('os').path.join(__import__('os').path.dirname(__import__('os').path.abspath(__file__)), '..', 'partial-swap'))\n+from fractions import Fraction as Q\n+from factor import inv, mul, bruhat, swapmat, predicted\n+import corners as C\n+h = 8; m = h*h; trip, G, I, P, Qc = C.setup(h); v = len(trip); rng = random.Random(5)\n+Lw = [[Q(rng.randint(-2, 2)) if j < i else Q(int(i == j)) for j in range(m)] for i in range(m)]\n+Up = [[Q(rng.randint(-2, 2)) if j > i else Q(int(i == j)) for j in range(m)] for i in range(m)]\n+S = mul(Lw, Up); Si = inv(S); ok = 0; n = int(sys.argv[1])\n+for _ in range(n):\n+ a1, a2 = rng.randrange(v), rng.randrange(v); p = mul(mul(S, C.kron(Qc[a1], Qc[a2])), Si); k = 2*h-1\n+ piv, L1, Mon, L2 = bruhat(swapmat(p)); assert mul(mul(L1, Mon), L2) == swapmat(p)\n+ cp, *_ = bruhat([r[m-k:] for r in p[:k]], track=False)\n+ good = piv == predicted({l: m-k+cp[l] for l in range(k)}, m, k); ok += good\n+ print('pair', a1, a2, 'profile ok', good, flush=True)\n+print('h=8 data entrance exact Bruhat profile matches lemma: %d/%d' % (ok, n))" + }, + { + "sha": "9113ef8fe31f59ed446658e856318e03f44f062e", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/cert_rt.py", + "status": "added", + "additions": 38, + "deletions": 0, + "changes": 38, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcert_rt.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcert_rt.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcert_rt.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,38 @@\n+\"\"\"Certify a_b for the retained-total gm producer with copied retained centres (lever A), and the baseline\n+(direct centres, certificate_round6.copied_histogram) at the same h.\n+Usage: python3 cert_rt.py h...\"\"\"\n+import sys, os, json\n+from math import comb\n+import rtgm\n+MODE = os.environ.get('MODE', 'search'); MODE = True if MODE == 'local' else MODE\n+HERE = os.path.dirname(os.path.abspath(__file__)); sys.path[:0] = [os.path.join(HERE, '..', '..', 'scripts'), HERE]\n+import moment, certificate_round6 as c6\n+from certificate_round5 import inner_children\n+\n+def rt_histogram(h, R, rk):\n+ v, m = comb(h, 3), h * h; N = v * v; A = v * R; H = {}\n+ add = lambda w, c: H.__setitem__(w, H.get(w, 0) + c) if c else None\n+ assert sum(r * n for r, n in rk.items()) == h * R\n+ for _ in range(2):\n+ add(m - 2 * h, A); add(h, A) # selected aux edge (flag basis): block + corner run\n+ for r, n in rk.items():\n+ for w in inner_children(r, h): add(w, v * n) # side chains incl. retained slots (to U_c, then F)\n+ for w in inner_children(h - 1, h): add(w, v * h) # copy of each retained total: U_c -> D0, rank h-1\n+ add(m - 4 * h + 2, 2 * N); add(h - 2, 2 * N); add(1, (h + 1) * 2 * N)\n+ for _ in range(2):\n+ add(h - 2, 2 * N); add(1, 2 * N)\n+ add(1, N)\n+ W = 2 * N + 2 * A; L = 2 * v * h * (h - 1); s = W * m - N + L\n+ assert sum(w * n for w, n in H.items()) == s and W * m > s and max(H) <= m - 1\n+ return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=H)\n+\n+if __name__ == '__main__':\n+ res = {}\n+ for h in map(int, sys.argv[1:]):\n+ R, rk, C, G = rtgm.side_ranks(h, MODE)\n+ c = rt_histogram(h, R, rk); a, root = moment.certify(c)\n+ b = c6.copied_histogram(h); ab, rb = moment.certify(b)\n+ print('h=%d retained R=%d a_b=%s (%.6e) | direct R+h=%d a_b=%s (%.6e) | ratio %.4f' % (\n+ h, R, a, float(a), b['R'] + h, ab, float(ab), float(a / ab)), flush=True)\n+ res[h] = dict(R=R, a=str(a), s=c['s'], W=c['W'], L=c['L'], base=str(ab))\n+ json.dump(res, open('cert_rt_%s.json' % '_'.join(sys.argv[1:]), 'w'), indent=1)" + }, + { + "sha": "b5dd1bef63c86ab9acf49e9093fff704267ebd39", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkgm.py", + "status": "added", + "additions": 34, + "deletions": 0, + "changes": 34, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcheckgm.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcheckgm.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcheckgm.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,34 @@\n+\"\"\"Independent exact check of a global side DAG (no use of the generator's support table):\n+recompute every active node's support from the inputs, check disjoint operands, topological order,\n+a common point on every node, every designated output equal to {S : c in S, S cap (T-c) empty},\n+all 3v (centre, target) outputs present. Prints R = active additions + outputs.\"\"\"\n+import sys\n+from itertools import combinations\n+import gmside, orders\n+def check(h, order):\n+ trip,args,outputs=gmside.build(h,order); v=len(trip)\n+ assert len(outputs)==3*v and all(c in T for c,T in outputs)\n+ act=set(); st=list(outputs.values())\n+ while st:\n+ n=st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ sup={}\n+ for n in sorted(act):\n+ if args[n] is None:\n+ assert 1<=n<=v; sup[n]=1<<(n-1); continue\n+ x,y=args[n]; assert x= 2 and key in lookup:\n+ assert sup[lookup[key]] == s, 'sharing merged different supports'\n+ mp[nd] = lookup[key]; shared += 1; continue\n+ k = len(args); mp[nd] = k; args.append((x, y)); sup.append(s); core.append(co); union.append(un)\n+ if bin(co).count('1') >= 2: lookup[key] = k\n+ for (a, b), nd in loc.outputs.items():\n+ A, B = others[a], others[b]\n+ want = Mp[c] & ~Mp[A] & ~Mp[B]\n+ assert sup[mp[nd]] == want, 'wrong output'\n+ outputs[c, tuple(sorted((c, A, B)))] = mp[nd]\n+ assert len(outputs) == 3*v\n+ act = set(); st = list(outputs.values())\n+ while st:\n+ n = st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ # every active addition's operands are built before it (topological) and disjoint (checked above)\n+ assert all(x < n and y < n for n in act if args[n] for x, y in [args[n]])\n+ adds = sum(args[n] is not None for n in act)\n+ return adds+len(outputs), adds, len(outputs), shared\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ mine = check(h); theirs = sidegen.roles(h)\n+ print(h, mine[0], mine[1], mine[2], 'shared', mine[3], 'sidegen', theirs, 'MATCH' if mine[:3] == theirs else 'DIFF', flush=True)" + }, + { + "sha": "810144541f6811b2407df94b5ca95deb25f6ff6d", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/corners.py", + "status": "added", + "additions": 108, + "deletions": 0, + "changes": 108, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcorners.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcorners.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fcorners.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,108 @@\n+\"\"\"Independent corner check for the selected partial-swap projectors of the two-stage bit motif.\n+Closed forms (G = I - J/9, P_a = G-orthogonal projector on t_a, Q_a = I - P_a):\n+ aux s1 exit / s2 entrance : I(x)Q_a , Q_a(x)I rank m-h, k = h\n+ data s2 entrance X and Y : Q_a1 (x) Q_a2 rank m-2h+1, k = 2h-1\n+Part 1 (exact, Fractions): the closed forms equal proj(b)-proj(a) of the label chains.\n+Part 2 (mod prime, rigorous for invertibility): with ONE random unimodular S0, the k x k corner\n+(S0^-1 p S0)[L,R] is invertible for EVERY aux a and EVERY data pair (a1,a2). det != 0 mod q\n+implies det != 0 over Q (all denominators divide 6 and det S0 = 1).\"\"\"\n+import sys, random\n+from fractions import Fraction as Q\n+from itertools import combinations\n+\n+q = 2**61-1\n+\n+def mat_mul(A, B, mod=None):\n+ Bt = list(zip(*B))\n+ if mod: return [[sum(a*b for a, b in zip(r, c)) % mod for c in Bt] for r in A]\n+ return [[sum(a*b for a, b in zip(r, c)) for c in Bt] for r in A]\n+\n+def kron(A, B): return [[a*b for a in ra for b in rb] for ra in A for rb in B]\n+\n+def rank_mod(M, mod):\n+ M = [r[:] for r in M]; rk = 0; n = len(M[0]) if M else 0\n+ for c in range(n):\n+ p = next((i for i in range(rk, len(M)) if M[i][c] % mod), None)\n+ if p is None: continue\n+ M[rk], M[p] = M[p], M[rk]; iv = pow(M[rk][c], mod-2, mod)\n+ M[rk] = [x*iv % mod for x in M[rk]]\n+ for i in range(len(M)):\n+ if i != rk and M[i][c] % mod:\n+ g = M[i][c]; M[i] = [(x-g*y) % mod for x, y in zip(M[i], M[rk])]\n+ rk += 1\n+ return rk\n+\n+def setup(h):\n+ trip = list(combinations(range(h), 3))\n+ G = [[Q(int(i == j))-Q(1, 9) for j in range(h)] for i in range(h)]\n+ P = []\n+ for t in trip:\n+ u = [Q(int(i in t)) for i in range(h)]\n+ Gu = [sum(G[i][j]*u[j] for j in range(h)) for i in range(h)]\n+ d = sum(a*b for a, b in zip(u, Gu)); assert d == 2\n+ P.append([[u[i]*Gu[j]/d for j in range(h)] for i in range(h)])\n+ I = [[Q(int(i == j)) for j in range(h)] for i in range(h)]\n+ Qc = [[[I[i][j]-p[i][j] for j in range(h)] for i in range(h)] for p in P]\n+ return trip, G, I, P, Qc\n+\n+def part1(h, npairs, seed):\n+ sys.path.insert(0, __import__('os').path.join(__import__('os').path.dirname(__import__('os').path.abspath(__file__)), '..', 'partial-swap'))\n+ from frames import Space, tens, perp, proj\n+ trip, G, I, P, Qc = setup(h); v = len(trip); G2 = kron(G, G); m = h*h\n+ F = Space(I, h); FF = tens(F, F); zero = Space([], m)\n+ line = [Space([[Q(int(i in t)) for i in range(h)]], h) for t in trip]; lp = [perp(L, G, h) for L in line]\n+ rng = random.Random(seed)\n+ sub = lambda b, a: [[x-y for x, y in zip(r1, r2)] for r1, r2 in zip(proj(b, G2), proj(a, G2))]\n+ for a in rng.sample(range(v), min(v, 6)):\n+ assert sub(FF, tens(F, line[a])) == kron(I, Qc[a])\n+ assert sub(tens(lp[a], F), zero) == kron(Qc[a], I)\n+ for _ in range(npairs):\n+ a1, a2 = rng.randrange(v), rng.randrange(v); D0 = tens(lp[a1], F); want = kron(Qc[a1], Qc[a2])\n+ assert sub(D0+tens(line[a1], line[a2]), tens(F, line[a2])) == want # X entrance\n+ assert sub(D0, tens(lp[a1], line[a2])) == want # Y entrance\n+ print('h=%d part1: closed forms exact on %d aux and %d data pairs (X and Y)' % (h, min(v, 6), npairs), flush=True)\n+\n+def part2(h, seed, R=2):\n+ trip, G, I, P, Qc = setup(h); v = len(trip); m = h*h; rng = random.Random(seed)\n+ inv6 = pow(6, q-2, q)\n+ red = lambda x: (x.numerator % q) * pow(x.denominator % q, q-2, q) % q\n+ Qm = [[[red(x) for x in r] for r in A] for A in Qc]; Im = [[int(i == j) for j in range(h)] for i in range(h)]\n+ # S0 = Lw Up unimodular; S0^-1 = Up^-1 Lw^-1 computed mod q (exact integer inverse reduces correctly)\n+ Lw = [[rng.randint(-R, R) if j < i else int(i == j) for j in range(m)] for i in range(m)]\n+ Up = [[rng.randint(-R, R) if j > i else int(i == j) for j in range(m)] for i in range(m)]\n+ S = mat_mul(Lw, Up, q)\n+ def tri_inv(T, lower):\n+ n = len(T); X = [[0]*n for _ in range(n)]\n+ for c in range(n):\n+ X[c][c] = 1\n+ rows = range(c+1, n) if lower else range(c-1, -1, -1)\n+ for i in rows:\n+ js = range(c, i) if lower else range(i+1, c+1)\n+ X[i][c] = -sum(T[i][j]*X[j][c] for j in js) % q\n+ return X\n+ Si = mat_mul(tri_inv(Up, False), tri_inv(Lw, True), q)\n+ assert mat_mul(S, Si, q) == [[int(i == j) for j in range(m)] for i in range(m)]\n+ bad = {}\n+ def corner(p, k):\n+ top = Si[:k] # rows L of S^-1\n+ right = [r[m-k:] for r in S] # columns R of S\n+ return rank_mod(mat_mul(mat_mul(top, p, q), right, q), q) == k\n+ for a in range(v):\n+ if not corner(kron(Im, Qm[a]), h): bad['aux1'] = bad.get('aux1', 0)+1\n+ if not corner(kron(Qm[a], Im), h): bad['aux2'] = bad.get('aux2', 0)+1\n+ # data: corner = Si[L] (Qa1 (x) Qa2) S[:,R]; factor Qa1(x)Qa2 = (Qa1(x)I)(I(x)Qa2) for speed\n+ A1 = [mat_mul(Si[:2*h-1], kron(Qm[a], Im), q) for a in range(v)]\n+ B2 = [mat_mul(kron(Im, Qm[a]), [r[m-2*h+1:] for r in S], q) for a in range(v)]\n+ nd = 0\n+ for a1 in range(v):\n+ for a2 in range(v):\n+ nd += 1\n+ if rank_mod(mat_mul(A1[a1], B2[a2], q), q) < 2*h-1: bad['data'] = bad.get('data', 0)+1\n+ print('h=%d m=%d v=%d part2 (one S0, seed %d): aux checked %d, data pairs checked %d, singular corners %s'\n+ % (h, m, v, seed, 2*v, nd, bad or 0), flush=True)\n+ return not bad\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ if h <= 8: part1(h, 6, h)\n+ part2(h, 100+h)" + }, + { + "sha": "a6143f138385df59b936814ec33b4bb6611330ec", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flag_existence.py", + "status": "added", + "additions": 94, + "deletions": 0, + "changes": 94, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflag_existence.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflag_existence.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflag_existence.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,94 @@\n+\"\"\"Mod-p evaluation at one random point of the flag-basis family, at h = 46, 47 (m = h^2).\n+A nonzero value mod p at an integer point proves the corresponding polynomial is not identically zero.\n+Checks: (1) aux/centre corner diagonal factors, every line; corner strictly-upper zero, sampled lines;\n+(2) inner-lemma corner A[0,h-1] for both data rank-(h-1) classes, every line;\n+(3) data entrance corner factors det1 (rows of S) and det2 (columns of S^-1), sampled pairs.\"\"\"\n+import sys, random\n+from itertools import combinations\n+p = (1 << 61)-1\n+h = int(sys.argv[1]); rng = random.Random(int(sys.argv[2])); m = h*h; CR = 10**6\n+iv = lambda x: pow(x % p, p-2, p)\n+nz = lambda: rng.choice([-1, 1])*rng.randint(1, CR)\n+def inv(A):\n+ n = len(A); M = [[x % p for x in r]+[int(i == j) for j in range(n)] for i, r in enumerate(A)]\n+ for c in range(n):\n+ k = next(i for i in range(c, n) if M[i][c]); M[c], M[k] = M[k], M[c]\n+ f = iv(M[c][c]); M[c] = [x*f % p for x in M[c]]\n+ for i in range(n):\n+ if i != c and M[i][c]: g = M[i][c]; M[i] = [(a-g*b) % p for a, b in zip(M[i], M[c])]\n+ return [r[n:] for r in M]\n+def det(A):\n+ M = [[x % p for x in r] for r in A]; n = len(M); d = 1\n+ for c in range(n):\n+ k = next((i for i in range(c, n) if M[i][c]), None)\n+ if k is None: return 0\n+ if k != c: M[c], M[k] = M[k], M[c]; d = -d\n+ d = d*M[c][c] % p; f = iv(M[c][c])\n+ for i in range(c+1, n):\n+ if M[i][c]: g = M[i][c]*f % p; M[i] = [(a-g*b) % p for a, b in zip(M[i], M[c])]\n+ return d % p\n+mm = lambda A, B: [[sum(a*b for a, b in zip(r, c)) % p for c in zip(*B)] for r in A]\n+T = lambda A: [list(r) for r in zip(*A)]\n+mv = lambda A, x: [sum(a*b for a, b in zip(r, x)) % p for r in A]\n+R = [[[nz() if i <= b and j <= b else 0 for j in range(h)] for i in range(h)] for b in range(h)]; R[h-1][h-1][h-1] = 0\n+C = []\n+for b in range(h):\n+ Cb = [[nz() if i >= b and j >= b else 0 for j in range(h)] for i in range(h)]\n+ if b < h-1: Cb[b][b] = 0\n+ for bb in range(b+1, h):\n+ Cb[b][bb] = 0\n+ s = sum(R[bb][i][j]*Cb[i][j] for i in range(b, bb+1) for j in range(b, bb+1)) % p\n+ Cb[b][bb] = -s*iv(R[bb][b][bb]) % p\n+ C.append(Cb)\n+for i in range(h): # trace conditions (all i, j), mod p\n+ for j in range(h): assert sum(R[i][x][y]*C[j][x][y] for x in range(h) for y in range(h)) % p == 0\n+U = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)]; V = [[rng.randint(-CR, CR) for _ in range(h)] for _ in range(h)]\n+Ui, Vi = inv(U), inv(V)\n+trip = list(combinations(range(h), 3)); v = len(trip)\n+inv9, inv2 = iv(9), iv(2)\n+def tg(t): # t = indicator, g = G t / (t^T G t) with G = I - J/9, t^T G t = 2\n+ tv = [int(i in t) for i in range(h)]; g = [(x - 3*inv9) * inv2 % p for x in tv]; return tv, g\n+UT, VT, UiT, ViT = T(U), T(V), T(Ui), T(Vi)\n+bad = 0\n+for t in trip:\n+ tv, g = tg(t)\n+ a, b = mv(VT, tv), mv(Vi, g) # I(x)P: x_beta = R_beta a, y_beta = C_beta b\n+ c, d = mv(UT, tv), mv(Ui, g) # P(x)I: R_beta^T c, C_beta^T d\n+ for be in range(h):\n+ f1 = sum(R[be][be][j]*a[j] for j in range(h)) % p; f2 = sum(C[be][be][j]*b[j] for j in range(h)) % p\n+ f3 = sum(R[be][i][be]*c[i] for i in range(h)) % p; f4 = sum(C[be][i][be]*d[i] for i in range(h)) % p\n+ bad += not (f1 and f2 and f3 and f4)\n+ # inner lemma corners: data s1 uses A = U^T Q U^-T (line of the Q factor), exit A' = V^T Q V^-T\n+ bad += not (c[0]*d[h-1] % p and a[0]*mv(Vi, g)[h-1] % p)\n+print('h=%d v=%d: lines with a zero diagonal or zero inner corner: %d' % (h, v, bad))\n+# explicit corners for sampled lines (lower-triangular check), both orientations\n+for t in rng.sample(trip, 3):\n+ tv, g = tg(t); a, b, c, d = mv(VT, tv), mv(Vi, g), mv(UT, tv), mv(Ui, g)\n+ X1 = [mv(R[be], a) for be in range(h)]; Y1 = [mv(C[be], b) for be in range(h)]\n+ X2 = [mv(T(R[be]), c) for be in range(h)]; Y2 = [mv(T(C[be]), d) for be in range(h)]\n+ up = sum(1 for i in range(h) for j in range(i+1, h) if sum(x*y for x, y in zip(X1[i], Y1[j])) % p or sum(x*y for x, y in zip(X2[i], Y2[j])) % p)\n+ print(' line %s: nonzero strictly-upper corner entries (both orientations): %d' % (t, up))\n+# data entrance factors\n+vecM = lambda M: [M[x][y] % p for x in range(h) for y in range(h)]\n+lam = [vecM(mm(mm(U, R[be]), VT)) for be in range(h)]\n+mu = [vecM(mm(mm(UiT, C[be]), Vi)) for be in range(h)]\n+dot = lambda x, y: sum(a*b for a, b in zip(x, y)) % p\n+assert all(dot(l, u) == 0 for l in lam for u in mu)\n+def proj_out(vs, basis): # random combos of vs projected to annihilate 'basis' vectors\n+ Gr = inv([[dot(x, y) for y in basis] for x in basis]); out = []\n+ for _ in range(h-1):\n+ f = [rng.randint(-CR, CR) for _ in range(m)]; cf = mv(Gr, [dot(f, y) for y in basis])\n+ out.append([(fi - sum(cj*y[k] for cj, y in zip(cf, basis))) % p for k, fi in enumerate(f)])\n+ return out\n+annmu = proj_out(None, mu) # functionals with f . mu_l = 0\n+kerlam = proj_out(None, lam) # vectors with lam_beta . w = 0\n+for _ in range(3):\n+ t1, t2 = rng.choice(trip), rng.choice(trip); tv1, g1 = tg(t1); tv2, g2 = tg(t2)\n+ i0 = next(i for i in range(h) if tv1[i]); j0 = next(i for i in range(h) if g1[i])\n+ E = lambda x, y: [x[i]*y[j] % p for i in range(h) for j in range(h)]\n+ e = lambda k: [int(i == k) for i in range(h)]\n+ Imb = [E(tv1, e(j)) for j in range(h)]+[E(e(i), tv2) for i in range(h) if i != i0]\n+ Rsp = [E(g1, e(j)) for j in range(h)]+[E(e(i), g2) for i in range(h) if i != j0]\n+ d1 = det([[dot(f, x) for x in Imb] for f in lam+annmu])\n+ d2 = det([[dot(f, x) for x in kerlam+mu] for f in Rsp])\n+ print(' pair %s %s: det1 %s, det2 %s' % (t1, t2, 'nonzero' if d1 else 'ZERO', 'nonzero' if d2 else 'ZERO'))" + }, + { + "sha": "98893c5a204513a784e783a5fd25b16570a75f39", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flagbasis.py", + "status": "added", + "additions": 262, + "deletions": 0, + "changes": 262, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflagbasis.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflagbasis.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fflagbasis.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,262 @@\n+\"\"\"Children profiles of every two-stage bit edge class in ONE nested controlled basis S = T (I (x) K).\n+Coordinates (x, y), y fastest; T acts on the slow factor x by G_y on fibre y.\n+Basis modes:\n+ struct : G_y row 0 = row (y+1 mod h) of W^-1, G_y^-1 e_{h-1} = column y of W (W generic unimodular)\n+ -> stage-1 corner M[y,y'] = g_y . k_y' is the cyclic shift (the best possible: diag is forced 0)\n+ nested : generic unimodular G_y, K (negative control: stage-1 corners not merged)\n+ tensor : all G_y equal (negative control: stage-1 aux corner singular)\n+ dense : one generic unimodular S0 (negative control: no stage-2 structure)\n+Pivots of S_p are computed by the rightmost-pivot lower-lower elimination mod q (and exactly over Q at h=6 for\n+a sample, with factor.bruhat). A child is a maximal run H_i -> D_j, H_{i+1} -> D_{j+1}, ... (contiguous, same\n+order). 'other' counts Bruhat moves that are not H<->D transpositions (must be 0).\"\"\"\n+import sys, random\n+sys.path.insert(0, __import__('os').path.join(__import__('os').path.dirname(__import__('os').path.abspath(__file__)), '..', 'partial-swap'))\n+from fractions import Fraction as Q\n+from itertools import combinations\n+q = 2**61-1\n+\n+def red(x): return x.numerator % q * pow(x.denominator % q, q-2, q) % q\n+def mm(A, B):\n+ Bt = list(zip(*B)); return [[sum(a*b for a, b in zip(r, c)) % q for c in Bt] for r in A]\n+def kron(A, B): return [[a*b % q for a in ra for b in rb] for ra in A for rb in B]\n+def eye(n): return [[int(i == j) for j in range(n)] for i in range(n)]\n+\n+def piv_modq(A):\n+ \"\"\"Rightmost-pivot lower-lower elimination; returns {row: col} (singular rows have no pivot).\"\"\"\n+ M = [r[:] for r in A]; n = len(M); out = {}\n+ for i in range(n):\n+ r = M[i]; c = next((j for j in range(len(r)-1, -1, -1) if r[j]), None)\n+ if c is None: continue\n+ out[i] = c; iv = pow(r[c], q-2, q)\n+ for k in range(i+1, n):\n+ if M[k][c]:\n+ f = M[k][c]*iv % q; M[k] = [(x-f*y) % q for x, y in zip(M[k], r)]\n+ return out\n+\n+def swapmat(p):\n+ m = len(p)\n+ return [[(int(i == j)-p[i][j]) % q for j in range(m)]+p[i][:] for i in range(m)] + \\\n+ [p[i][:]+[(int(i == j)-p[i][j]) % q for j in range(m)] for i in range(m)]\n+\n+def children(p):\n+ \"\"\"Children widths of the partial swap S_p from its Bruhat involution (mod q).\"\"\"\n+ m = len(p); w = piv_modq(swapmat(p)); assert len(w) == 2*m\n+ other = sum(1 for i, c in w.items() if c != i and (i < m) == (c < m))\n+ inv_ok = all(w[c] == i for i, c in w.items())\n+ hd = sorted((i, c) for i, c in w.items() if i < m <= c)\n+ out = []; prev = None\n+ for i, c in hd:\n+ if prev and i == prev[0]+1 and c == prev[1]+1: out[-1] += 1\n+ else: out.append(1)\n+ prev = (i, c)\n+ return tuple(sorted(out, reverse=True)), other, inv_ok\n+\n+RR = 10**6 # generic coefficients: the lemma is a Zariski-open statement, small ranges hit coincidences\n+def unimod(n, rng, R=None):\n+ R = R or RR\n+ L = [[rng.randint(-R, R) if j < i else int(i == j) for j in range(n)] for i in range(n)]\n+ U = [[rng.randint(-R, R) if j > i else int(i == j) for j in range(n)] for i in range(n)]\n+ return [[sum(L[i][k]*U[k][j] for k in range(n)) for j in range(n)] for i in range(n)]\n+\n+def inv_int(A):\n+ \"\"\"Exact inverse of an integer matrix as Fractions.\"\"\"\n+ n = len(A); M = [[Q(x) for x in r]+[Q(int(i == j)) for j in range(n)] for i, r in enumerate(A)]\n+ for c in range(n):\n+ p = next(i for i in range(c, n) if M[i][c]); M[c], M[p] = M[p], M[c]\n+ f = M[c][c]; M[c] = [x/f for x in M[c]]\n+ for i in range(n):\n+ if i != c and M[i][c]: g = M[i][c]; M[i] = [a-g*b for a, b in zip(M[i], M[c])]\n+ return [r[n:] for r in M]\n+\n+def basis(h, mode, rng):\n+ \"\"\"Return S, S^-1 as exact Fraction matrices (m x m).\"\"\"\n+ m = h*h\n+ if mode == 'flag':\n+ return flag_basis(h, rng)\n+ if mode == 'dense':\n+ S = unimod(m, rng, 2); Si = inv_int(S); return [[Q(x) for x in r] for r in S], Si\n+ K = unimod(h, rng)\n+ if mode == 'struct':\n+ Wm = unimod(h, rng); Wi = inv_int(Wm); Gs = []\n+ for y in range(h):\n+ w = [Q(Wm[r][y]) for r in range(h)] # k_y = w_y : G_y w_y = e_{h-1}\n+ rows = [Wi[(y+1) % h]] # g_y = dual of w_{y+1}; g_y . w_y = 0\n+ j0 = next(j for j in range(h) if w[j]); u = [Q(int(j == j0))/w[j0] for j in range(h)]\n+ for _ in range(h-2):\n+ r = [Q(rng.randint(-RR, RR)) for _ in range(h)]; d = sum(a*b for a, b in zip(r, w))\n+ rows.append([a-d*b for a, b in zip(r, u)])\n+ r = [Q(rng.randint(-RR, RR)) for _ in range(h)]; d = sum(a*b for a, b in zip(r, w))\n+ rows.append([a-d*b+c for a, b, c in zip(r, u, u)])\n+ Gs.append(rows)\n+ elif mode == 'tensor':\n+ G0 = [[Q(x) for x in r] for r in unimod(h, rng)]; Gs = [G0]*h\n+ else:\n+ Gs = [[[Q(x) for x in r] for r in unimod(h, rng)] for _ in range(h)]\n+ Gi = [inv_int(G) if all(x.denominator == 1 for r in G for x in r) else None for G in Gs]\n+ Gi = [g if g is not None else inv_frac(G) for g, G in zip(Gi, Gs)]\n+ Ki = inv_int(K)\n+ S = [[Q(0)]*m for _ in range(m)]; Si = [[Q(0)]*m for _ in range(m)]\n+ # S = T (I (x) K): S[(x,y),(x',y')] = G_y[x,x'] K[y,y']; S^-1 = (I (x) K^-1) T^-1\n+ for x in range(h):\n+ for y in range(h):\n+ for x2 in range(h):\n+ g = Gs[y][x][x2]; gi = None\n+ for y2 in range(h):\n+ S[x*h+y][x2*h+y2] = g*K[y][y2]\n+ Si[x*h+y][x2*h+y2] = Ki[y][y2]*Gi[y2][x][x2]\n+ return S, Si\n+\n+def flag_basis(h, rng):\n+ \"\"\"First h rows of S <-> matrices U R_b V^T (R_b supported on [0..b]^2), last h columns of S^-1 <->\n+ U^-T C_b V^-1 (C_b supported on [b..h-1]^2). For b < b': R_b^T C_b' = 0 and R_b C_b'^T = 0 identically, so\n+ both stage corners are lower triangular. Trace conditions tr(R_i^T C_j) = 0 (all i, j) make S S^-1 = I.\"\"\"\n+ m = h*h; rnd = lambda: Q(rng.randint(1, RR))\n+ R = []\n+ for b in range(h):\n+ Rb = [[rnd() if i <= b and j <= b else Q(0) for j in range(h)] for i in range(h)]\n+ if b == h-1: Rb[b][b] = Q(0) # i = j trace condition R_b[b][b] C_b[b][b] = 0:\n+ R.append(Rb) # zero R at b = h-1, zero C below (else R_0 = 0)\n+ C = []\n+ for b in range(h):\n+ Cb = [[rnd() if i >= b and j >= b else Q(0) for j in range(h)] for i in range(h)]\n+ if b < h-1: Cb[b][b] = Q(0)\n+ for bb in range(b+1, h): # tr(R_bb^T C_b) = 0, slack entry (b, bb)\n+ Cb[b][bb] = Q(0)\n+ s = sum(R[bb][i][j]*Cb[i][j] for i in range(b, bb+1) for j in range(b, bb+1))\n+ Cb[b][bb] = -s/R[bb][b][bb]\n+ C.append(Cb)\n+ U = [[Q(x) for x in r] for r in unimod(h, rng)]; V = [[Q(x) for x in r] for r in unimod(h, rng)]\n+ Ui, Vi = inv_frac(U), inv_frac(V)\n+ mulq = lambda A, B: [[sum(a*b for a, b in zip(r, c)) for c in zip(*B)] for r in A]\n+ Tr = lambda A: [list(x) for x in zip(*A)]\n+ lam = [sum(mulq(mulq(U, Rb), Tr(V)), []) for Rb in R] # row-major vec, index x*h+y\n+ mu = [sum(mulq(mulq(Tr(Ui), Cb), Vi), []) for Cb in C]\n+ assert all(sum(a*b for a, b in zip(l, u)) == 0 for l in lam for u in mu)\n+ # X = [Z | W | mu] with lam Z = I_h, W a complement of span(mu) in ker(lam); S = X^-1\n+ ker = nullspace(lam, m); cur = [u[:] for u in mu]; W = []\n+ def rc(): # random kernel vector\n+ cf = [rng.randint(-3, 3) for _ in ker]\n+ return [sum(c*x for c, x in zip(cf, col)) for col in zip(*ker)]\n+ while len(W) < m-2*h: # generic complement (not the sparse nullspace basis)\n+ k = [Q(x) for x in rc()]\n+ if rank_frac(cur+[k]) > len(cur): cur.append(k); W.append(k)\n+ Lt = Tr(lam); Gm = mulq(lam, Lt); Z = Tr(mulq(Lt, inv_frac(Gm)))\n+ Z = [[a+b for a, b in zip(z, rc())] for z in Z] # generic preimages of e_1..e_h\n+ X = Tr(Z+W+mu); S = inv_frac(X)\n+ assert S[:h] == lam\n+ return S, X\n+\n+def nullspace(A, n):\n+ M = [r[:] for r in A]; piv = []; r0 = 0\n+ for c in range(n):\n+ p = next((i for i in range(r0, len(M)) if M[i][c]), None)\n+ if p is None: continue\n+ M[r0], M[p] = M[p], M[r0]; f = M[r0][c]; M[r0] = [x/f for x in M[r0]]\n+ for i in range(len(M)):\n+ if i != r0 and M[i][c]: g = M[i][c]; M[i] = [x-g*y for x, y in zip(M[i], M[r0])]\n+ piv.append(c); r0 += 1\n+ out = []\n+ for fc in [c for c in range(n) if c not in piv]:\n+ v = [Q(0)]*n; v[fc] = Q(1)\n+ for i, c in enumerate(piv): v[c] = -M[i][fc]\n+ out.append(v)\n+ return out\n+\n+def rank_frac(A):\n+ M = [r[:] for r in A]; rk = 0\n+ for c in range(len(M[0])):\n+ p = next((i for i in range(rk, len(M)) if M[i][c]), None)\n+ if p is None: continue\n+ M[rk], M[p] = M[p], M[rk]\n+ for i in range(rk+1, len(M)):\n+ if M[i][c]: f = M[i][c]/M[rk][c]; M[i] = [a-f*b for a, b in zip(M[i], M[rk])]\n+ rk += 1\n+ return rk\n+\n+def inv_frac(A):\n+ n = len(A); M = [r[:]+[Q(int(i == j)) for j in range(n)] for i, r in enumerate(A)]\n+ for c in range(n):\n+ p = next(i for i in range(c, n) if M[i][c]); M[c], M[p] = M[p], M[c]\n+ f = M[c][c]; M[c] = [x/f for x in M[c]]\n+ for i in range(n):\n+ if i != c and M[i][c]: g = M[i][c]; M[i] = [a-g*b for a, b in zip(M[i], M[c])]\n+ return [r[n:] for r in M]\n+\n+def setup(h):\n+ trip = list(combinations(range(h), 3))\n+ G = [[Q(int(i == j))-Q(1, 9) for j in range(h)] for i in range(h)]\n+ def projU(vecs): # G-orthogonal projector onto span(vecs) (column convention)\n+ if not vecs: return [[Q(0)]*h for _ in range(h)]\n+ B = []\n+ for v in vecs: # keep an independent subset\n+ if rank_frac(B+[list(v)]) > len(B): B.append(list(v))\n+ Bc = list(map(list, zip(*B)))\n+ GB = [[sum(G[i][k]*Bc[k][j] for k in range(h)) for j in range(len(B))] for i in range(h)]\n+ Gr = [[sum(B[a][k]*GB[k][b] for k in range(h)) for b in range(len(B))] for a in range(len(B))]\n+ Gri = inv_frac(Gr)\n+ BtG = [[sum(B[a][k]*G[k][j] for k in range(h)) for j in range(h)] for a in range(len(B))]\n+ X = [[sum(Bc[i][a]*Gri[a][b] for a in range(len(B))) for b in range(len(B))] for i in range(h)]\n+ return [[sum(X[i][b]*BtG[b][j] for b in range(len(B))) for j in range(h)] for i in range(h)]\n+ tv = [[Q(int(i in t)) for i in range(h)] for t in trip]\n+ P = [projU([t]) for t in tv]\n+ I = [[Q(int(i == j)) for j in range(h)] for i in range(h)]\n+ Qc = [[[I[i][j]-p[i][j] for j in range(h)] for i in range(h)] for p in P]\n+ return trip, tv, G, P, Qc, I, projU\n+\n+def run(h, mode, seed, npairs, nside, exact_sample=0):\n+ rng = random.Random(seed); m = h*h\n+ trip, tv, G, P, Qc, I, projU = setup(h); v = len(trip)\n+ S, Si = basis(h, mode, rng)\n+ Sm = [[red(x) for x in r] for r in S]; Sim = [[red(x) for x in r] for r in Si]\n+ assert mm(Sm, Sim) == eye(m)\n+ Rm = lambda A: [[red(x) for x in r] for r in A]\n+ Pm = [Rm(p) for p in P]; Qm = [Rm(p) for p in Qc]; Im = eye(h)\n+ def conj(A): return mm(mm(Sm, A), Sim)\n+ res = {}\n+ def rec(name, A, rank):\n+ ch = children(conj(A)); res.setdefault(name, {}); key = (rank,)+ch\n+ res[name][key] = res[name].get(key, 0)+1\n+ for a in range(v):\n+ rec('s1 aux exit I(x)Q_b', kron(Im, Qm[a]), m-h)\n+ rec('s1 centre I(x)P_b', kron(Im, Pm[a]), h)\n+ rec('s2 aux entr Q_a(x)I', kron(Qm[a], Im), m-h)\n+ rec('s2 centre P_a(x)I', kron(Pm[a], Im), h)\n+ for _ in range(npairs):\n+ a1, a2 = rng.randrange(v), rng.randrange(v)\n+ rec('data s1 Q_a1(x)P_a2', kron(Qm[a1], Pm[a2]), h-1)\n+ rec('data s2 entr Q_a1(x)Q_a2', kron(Qm[a1], Qm[a2]), m-2*h+1)\n+ rec('data s2 exit P_a1(x)Q_a2', kron(Pm[a1], Qm[a2]), h-1)\n+ for _ in range(nside): # side edges: pi = P_V - P_U for nested source spans / target complements\n+ T_ = trip[rng.randrange(v)]; i = rng.choice(T_)\n+ src = [s for s, t in enumerate(trip) if i in t and set(t) & set(T_) == {i}]\n+ Ss = rng.sample(src, rng.randint(1, len(src)))\n+ U = [tv[s] for s in Ss]; PU = projU(U)\n+ PT = P[trip.index(T_)]; PYt = [[I[r][c]-PT[r][c] for c in range(h)] for r in range(h)]\n+ dU = sum(1 for _ in range(1)) # placeholder\n+ b = rng.randrange(v)\n+ for nm, pi in (('U->F', [[I[r][c]-PU[r][c] for c in range(h)] for r in range(h)]),\n+ ('U->Yt', [[PYt[r][c]-PU[r][c] for c in range(h)] for r in range(h)]),\n+ ('0->U', PU)):\n+ pim = Rm(pi); rk = len(piv_modq(pim))\n+ rec('s1 side %-5s pi(x)P_b' % nm, kron(pim, Pm[b]), rk)\n+ rec('s2 side %-5s P_a(x)pi' % nm, kron(Pm[b], pim), rk)\n+ if exact_sample: # exact Q check of the S_p Bruhat involution on a sample of edges\n+ from factor import bruhat, swapmat as swq, mul\n+ ok = 0; tot = 0\n+ for a in rng.sample(range(v), exact_sample):\n+ for A in (kronQ(I, Qc[a]), kronQ(I, P[a]), kronQ(Qc[a], I), kronQ(P[a], I)):\n+ pp = mul(mul(S, A), Si); piv, *_ = bruhat(swq(pp), track=False)\n+ wq = piv_modq(swapmat(Rm(pp))); tot += 1; ok += all(piv[i] == wq[i] for i in range(2*m))\n+ res['_exact Q == mod q Bruhat'] = {(ok, tot): 1}\n+ return res\n+\n+def kronQ(A, B): return [[a*b for a in ra for b in rb] for ra in A for rb in B]\n+\n+if __name__ == '__main__':\n+ h, mode, seed, npairs, nside = int(sys.argv[1]), sys.argv[2], int(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5])\n+ ex = int(sys.argv[6]) if len(sys.argv) > 6 else 0\n+ RR = int(sys.argv[7]) if len(sys.argv) > 7 else 10**6\n+ res = run(h, mode, seed, npairs, nside, ex)\n+ print('h=%d m=%d mode=%s seed=%d key = (rank, child widths..., other-moves, involution-ok): count' % (h, h*h, mode, seed))\n+ for k in sorted(res):\n+ print(' %-28s' % k, dict(sorted(res[k].items())), flush=True)" + }, + { + "sha": "69862f57d00c67c575e51be323b2db351796172a", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/gmside.py", + "status": "added", + "additions": 33, + "deletions": 0, + "changes": 33, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fgmside.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fgmside.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fgmside.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,33 @@\n+\"\"\"Global-matching side circuit (\"gm\"): Paureel's paired exclusion circuit on h-1 points (sidegen.Excl),\n+lifted to every centre c with the point order of orders.gm, sharing every node whose exact global support\n+(set of triples) is already built. Emits the global DAG: inputs 1..v (triples), args[k]=(x,y), outputs.\"\"\"\n+import sys\n+sys.path.insert(0, __import__('os').path.dirname(__import__('os').path.abspath(__file__)))\n+from itertools import combinations\n+import sidegen, orders\n+def build(h, order=orders.gm):\n+ loc=sidegen.Excl(h-1)\n+ trip=list(combinations(range(h),3)); idx={t:i+1 for i,t in enumerate(trip)}; v=len(trip)\n+ sup=[0]+[1<F or stage-2 entrance 0->D0)\n+ centre aux role : ranks sum to m+2h (central return h counted, plus one extra up-edge h), one edge m-h\n+ data role X / Y : U_a -> ... -> F and 0 -> ... -> U_a^perp, ranks h-1, h-1, m-2h+1, sum m-1\n+ copy correction : one rank-one child per data pair\n+Batching (partial-swap lemma): an edge of rank r > m/2 becomes (m-r) singletons + one block of width 2r-m.\n+Condition: (1/W) * sum_children (width/m)^(1-a) < 1.\"\"\"\n+import sys\n+from fractions import Fraction as Q\n+from math import comb, log\n+\n+def R_of(h):\n+ # side roles per invocation from our generator (additions + outputs)\n+ import os\n+ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\n+ from sidegen import roles\n+ return roles(h)[0]\n+\n+def ln_upper(x):\n+ \"\"\"Rigorous rational upper bound of ln x for rational x > 1: ln x = k ln2 + ln y, y in (1,2];\n+ ln y = 2 atanh z, z=(y-1)/(y+1) <= 1/3; partial sum + geometric tail bound.\"\"\"\n+ x = Q(x); assert x > 1\n+ k = 0\n+ while x > 2: x /= 2; k += 1\n+ def two_atanh_up(z, n=30):\n+ s = sum(z**(2*j+1)/(2*j+1) for j in range(n))\n+ tail = z**(2*n+1)/((2*n+1)*(1-z*z))\n+ return 2*(s+tail)\n+ return k*two_atanh_up(Q(1, 3)) + (two_atanh_up((x-1)/(x+1)) if x > 1 else 0)\n+\n+def histogram(h, R, data_batch):\n+ \"\"\"Exact multiset {width: count} of children, built role by role (not from s).\"\"\"\n+ v, m, c0 = comb(h, 3), h*h, h; N = v*v\n+ hist = {}\n+ def add(w, c): hist[w] = hist.get(w, 0)+c\n+ def edge(r, cnt, batch):\n+ if batch and 2*r > m: add(1, (m-r)*cnt); add(2*r-m, cnt)\n+ else: add(1, r*cnt)\n+ A = v*(R+c0) # aux roles per stage (v invocations, R side + c0 centre each)\n+ for _stage in range(2):\n+ edge(m-h, A, True) # the selected aux edge\n+ edge(h, v*R, False) # rest of each side role: m-(m-h)\n+ edge(3*h, v*c0, False) # rest of each centre role: m+2h-(m-h)\n+ # data: two roles per pair; stage-2 entrance m-2h+1 plus two edges of h-1\n+ edge(m-2*h+1, 2*N, data_batch); edge(2*(h-1), 2*N, False)\n+ add(1, N) # copy correction\n+ W = 2*N+2*A; L = 2*v*h*c0\n+ s = sum(w*c for w, c in hist.items())\n+ assert s == W*m-N+2*L, 'rank sum mismatch'\n+ assert W*m-s == v*(v-4*h*c0)\n+ return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=hist)\n+\n+def F_upper(c, a, lu):\n+ m, W = c['m'], c['W']; tot = Q(0)\n+ for w, cnt in c['hist'].items():\n+ # (w/m)^(1-a) = (w/m) * (m/w)^a <= (w/m) / (1 - a ln(m/w))\n+ l = lu[w]; assert a*l < 1\n+ tot += Q(cnt*w, m)/(1-a*l)\n+ return tot/W\n+\n+def F_float(c, a):\n+ m, W = c['m'], c['W']\n+ return sum(cnt*(w/m)**(1-a) for w, cnt in c['hist'].items())/W\n+\n+def certify(c, den=10**9):\n+ lo, hi = 0.0, 0.05\n+ for _ in range(200):\n+ mid = (lo+hi)/2\n+ lo, hi = (mid, hi) if F_float(c, mid) < 1 else (lo, mid)\n+ lu = {w: ln_upper(Q(c['m'], w)) for w in c['hist']}\n+ n = int(lo*den)+1\n+ while not F_upper(c, Q(n, den), lu) < 1: n -= 1\n+ assert F_upper(c, Q(n, den), lu) < 1\n+ return Q(n, den), lo\n+\n+if __name__ == '__main__':\n+ assert ln_upper(1024) > Q(6931471805599453, 10**15) and ln_upper(1024) < Q(6931471805599454, 10**15)\n+ for arg in sys.argv[1:]:\n+ h, db = arg.split(':'); h = int(h); db = db == '1'\n+ c = histogram(h, R_of(h), db); a, root = certify(c)\n+ print('h=%d data_batch=%d v=%d m=%d R=%d N=%d W=%d L=%d s=%d a_b=%s (=%.6e) root %.6e hist=%s'\n+ % (h, db, c['v'], c['m'], c['R'], c['N'], c['W'], c['L'], c['s'], a, float(a), root,\n+ sorted(c['hist'].items())), flush=True)" + }, + { + "sha": "86df1026f34ea313176aa06fe264d3e6b6469875", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/orders.py", + "status": "added", + "additions": 42, + "deletions": 0, + "changes": 42, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Forders.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Forders.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Forders.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,42 @@\n+def natural(h,c): return [j for j in range(h) if j!=c]\n+def gmatch_end(h,c):\n+ # global pairs (0,1),(2,3)..; h odd -> last point z=h-1 singleton. centre's partner moved next to z at end\n+ z=h-1\n+ if c==z: return list(range(h-1))\n+ cs=c^1\n+ return [j for j in range(h-1) if j not in (c,cs)]+[z,cs]\n+def gmatch_front(h,c):\n+ z=h-1\n+ if c==z: return list(range(h-1))\n+ cs=c^1\n+ return [z,cs]+[j for j in range(h-1) if j not in (c,cs)]\n+def gmatch_mid(h,c):\n+ z=h-1\n+ if c==z: return list(range(h-1))\n+ cs=c^1; r=[j for j in range(h-1) if j not in (c,cs)]; m=(len(r)//4)*2\n+ return r[:m]+[z,cs]+r[m:]\n+def rot(h,c): return [(c+k)%h for k in range(1,h)]\n+def gm(h,c):\n+ # global matching (0,1),(2,3),...; odd h: z=h-1 joins the centre's partner at the end; even h: partner alone at end\n+ if h%2:\n+ z=h-1\n+ if c==z: return list(range(h-1))\n+ cs=c^1; return [j for j in range(h-1) if j not in (c,cs)]+[z,cs]\n+ cs=c^1; return [j for j in range(h) if j not in (c,cs)]+[cs]\n+def gmf(h,c):\n+ if h%2:\n+ z=h-1\n+ if c==z: return list(range(h-1))\n+ cs=c^1; return [z,cs]+[j for j in range(h-1) if j not in (c,cs)]\n+ cs=c^1; return [cs]+[j for j in range(h) if j not in (c,cs)]\n+def gmm(h,c):\n+ r=gm(h,c); \n+ if h%2 and c==h-1: return r\n+ k=2 if h%2 else 1; sp=r[-k:]; r=r[:-k]; m=(len(r)//4)*2\n+ return r[:m]+sp+r[m:]\n+def gmrev(h,c):\n+ # global matching but pairs listed in reverse order (tests order dependence)\n+ r=gm(h,c); k=2 if h%2 else 1\n+ if h%2 and c==h-1: return r[::-1]\n+ body=r[:-k]; pairs=[body[i:i+2] for i in range(0,len(body),2)][::-1]\n+ return [x for p in pairs for x in p]+r[-k:]" + }, + { + "sha": "c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/rtgm.py", + "status": "added", + "additions": 159, + "deletions": 0, + "changes": 159, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Frtgm.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Frtgm.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Frtgm.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,159 @@\n+\"\"\"Retained-total gm producer for the two-stage bit motif (lever A).\n+\n+The gm side circuit (gmside / side_chains) with the h direct centre wires replaced by retained point totals\n+P_c = sum{x_S : c in S}: per centre c, the local pair-exclusion block's grand total (sum of all pairs on the h-1\n+other points) is lifted like every other node, with exact-support sharing, and given one designated terminal\n+use (\"retained output\"). Roles = additions + side outputs + retained uses (compile_ as side_chains, the retained\n+use is an output user ordered after the side outputs).\n+\n+Chains: a side output slot ends 0 < ... < t_T^perp (h-1) < F; a retained slot ends at span(P_c) = U_c\n+(dim h-1, Gram nondegenerate) and then F (rank 1); its copy (PR #36 copied centre) pays U_c -> D0 (rank h-1).\n+Usage: python3 rtgm.py h... (prints R, additions, retained extra additions, chain summary)\"\"\"\n+import sys, os\n+HERE = os.path.dirname(os.path.abspath(__file__)); K = os.path.join(HERE, '..', '..')\n+sys.path[:0] = [os.path.join(K, 'scripts'), HERE]\n+sys.setrecursionlimit(100000)\n+from itertools import combinations\n+from collections import Counter\n+import sidegen, orders, side_chains\n+\n+\n+def build(h, order=orders.gm, exact=False, retain=True):\n+ loc = sidegen.Excl(h - 1)\n+ tot = loc.pairblock(list(range(h - 1)))[0] # same node ids (add() dedups by support)\n+ assert loc.support[tot] == (1 << len(loc.inputs)) - 1\n+ need = set(loc.active)\n+ if retain is True:\n+ st = [tot]\n+ while st:\n+ x = st.pop()\n+ if not x or x in need: continue\n+ need.add(x)\n+ if loc.args[x]: st.extend(loc.args[x])\n+ dl = {nd: side_chains.graph_rank([p for i, p in enumerate(loc.inputs) if loc.support[nd] >> i & 1]) for nd in need}\n+ trip = list(combinations(range(h), 3)); v = len(trip); var = {t: i + 1 for i, t in enumerate(trip)}\n+ args = [None] * (v + 1); dn = [0] + [1] * v\n+ sup = [0] + [1 << i for i in range(v)]; look = {}; outputs = {}; retained = {}\n+ for c in range(h):\n+ pts = order(h, c); mp = {}\n+ for nd in sorted(need):\n+ if loc.args[nd] is None:\n+ a, b = loc.inputs[nd - 1]; mp[nd] = var[tuple(sorted((c, pts[a], pts[b])))]; continue\n+ a, b = (mp[x] for x in loc.args[nd])\n+ assert not sup[a] & sup[b]\n+ s = sup[a] | sup[b]; k = look.get(s)\n+ if k is None:\n+ k = len(sup); sup.append(s); args.append((a, b)); dn.append(dl[nd]); look[s] = k\n+ else:\n+ assert dn[k] == dl[nd]\n+ mp[nd] = k\n+ for (x, y), nd in loc.outputs.items():\n+ outputs[c, tuple(sorted((c, pts[x], pts[y])))] = mp[nd]\n+ if retain is True: retained[c] = mp[tot]\n+ if retain == 'search': # cheapest totals: star(c) = (x + y) + z over active gm nodes\n+ retained = search_totals(h, trip, args, dn, sup, outputs)\n+ roots = list(outputs.values()) + list(retained.values())\n+ act = set(); st = list(roots)\n+ while st:\n+ n = st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ return dict(h=h, trip=trip, args=args, dn=dn, outputs=outputs, retained=retained, active=act, sup=sup)\n+\n+\n+def search_totals(h, trip, args, dn, sup, outputs):\n+ \"\"\"For every centre, star(c) as a disjoint union of the fewest active gm nodes (1 or 2 new additions,\n+ largest node first); appends the new nodes to args/dn/sup and returns {c: node}.\"\"\"\n+ act = set(); st = list(outputs.values())\n+ while st:\n+ n = st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ bysup = {sup[n]: n for n in act}; pc = lambda s: bin(s).count('1'); out = {}\n+ def new(a, b, c):\n+ assert not sup[a] & sup[b]\n+ s = sup[a] | sup[b]\n+ if s in bysup: return bysup[s]\n+ pairs = [tuple(q for q in trip[i] if q != c) for i in range(len(trip)) if s >> i & 1]\n+ k = len(sup); sup.append(s); args.append((a, b)); dn.append(side_chains.graph_rank(pairs)); bysup[s] = k\n+ return k\n+ for c in range(h):\n+ star = sum(1 << i for i, t in enumerate(trip) if c in t)\n+ subs = sorted([n for n in act if sup[n] & ~star == 0], key=lambda n: (-pc(sup[n]), n))\n+ best = None\n+ for x in subs:\n+ if star ^ sup[x] in bysup: best = (x, bysup[star ^ sup[x]]); break\n+ if best is None:\n+ for i, x in enumerate(subs):\n+ rem = star ^ sup[x]\n+ if pc(rem) > 2 * pc(sup[x]): break\n+ for y in subs[i:]:\n+ if sup[y] & ~rem == 0 and (rem ^ sup[y]) in bysup: best = (x, y, bysup[rem ^ sup[y]]); break\n+ if best: break\n+ if best is None: # greedy exact cover, largest active node first\n+ rem = star; best = []\n+ while rem:\n+ x = next(n for n in subs if sup[n] & ~rem == 0); best.append(x); rem ^= sup[x]\n+ acc = best[0]\n+ for x in best[1:]: acc = new(acc, x, c)\n+ out[c] = acc\n+ assert sup[out[c]] == star and dn[out[c]] == h - 1\n+ return out\n+\n+\n+def compile_(G):\n+ \"\"\"side_chains.compile_ with retained uses as extra output users (after the side outputs).\"\"\"\n+ args, act, outputs, retained = G['args'], G['active'], G['outputs'], G['retained']\n+ users = {x: [] for x in act}\n+ for n in sorted(act):\n+ if args[n]:\n+ for pos, x in enumerate(args[n]): users[x].append(('gate', n, pos))\n+ for tgt, n in sorted(outputs.items()): users[n].append(('output', tgt))\n+ for c, n in sorted(retained.items()): users[n].append(('retained', c))\n+ edge = {}; out = {}; ret = {}; size = 0; hold = []\n+ for n in sorted(act):\n+ if args[n]:\n+ pivot = edge[n, 0]; ins = (edge[n, 0], edge[n, 1])\n+ else:\n+ pivot = size; size += 1; ins = (pivot,); hold.append([])\n+ outs = (pivot,) + tuple(range(size, size + len(users[n]) - 1))\n+ for _ in range(len(users[n]) - 1): hold.append([])\n+ size += len(users[n]) - 1\n+ for s in set(ins + outs): hold[s].append(n)\n+ for u, s in zip(users[n], outs):\n+ if u[0] == 'gate': edge[u[1], u[2]] = s\n+ elif u[0] == 'output': out[s] = u[1]\n+ else: ret[s] = u[1]\n+ adds = sum(1 for n in act if args[n])\n+ assert size == adds + len(outputs) + len(retained)\n+ return dict(roles=size, hold=hold, out=out, ret=ret, adds=adds)\n+\n+\n+def chain_dims(G, C, s):\n+ h = G['h']; dn = G['dn']; d = [0]\n+ for n in C['hold'][s]:\n+ if dn[n] != d[-1]: d.append(dn[n])\n+ if s in C['out']: d.append(h - 1)\n+ if s in C['ret']: assert d[-1] == h - 1, (s, d)\n+ d.append(h)\n+ assert all(a < b for a, b in zip(d, d[1:])), (s, d)\n+ return d\n+\n+\n+def side_ranks(h, retain='search'):\n+ G = build(h, retain=retain); C = compile_(G); rk = Counter()\n+ for s in range(C['roles']):\n+ d = chain_dims(G, C, s)\n+ for a, b in zip(d, d[1:]): rk[b - a] += 1\n+ return C['roles'], rk, C, G\n+\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ R0, rk0, C0, _ = side_ranks(h, False)\n+ for mode in (True, 'search'):\n+ R1, rk1, C1, G1 = side_ranks(h, mode)\n+ print('h=%d %s gm R=%d adds=%d | retained R=%d adds=%d (+%d adds, +%d roles; old R+h=%d)' % (\n+ h, mode, R0, C0['adds'], R1, C1['adds'], C1['adds'] - C0['adds'], R1 - R0, R0 + h), flush=True)" + }, + { + "sha": "d08377f94ea85799a1aadac6aef69df4607297fe", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/side_chains.py", + "status": "added", + "additions": 138, + "deletions": 0, + "changes": 138, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fside_chains.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fside_chains.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fside_chains.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,138 @@\n+\"\"\"Exact side-role frame chains of the two-stage bit motif, from the real compiled side program.\n+\n+Producer: Paureel's paired exclusion circuit on h-1 points (sidegen.Excl), lifted to every centre c with a\n+point order (orders.natural = sidegen, orders.gm = global matching), sharing a node iff |core|>=2 and its\n+(core, union) key exists. (For |core|>=2 the support is {T : core in T, T - core in union - core}, so this is\n+exact-support sharing; gmside.build's exact-support rule gives the same DAG.)\n+\n+Compiler: Paureel's ExclusionCircuit.compile (scripts/exclusion_circuit.py @ c82d09e), re-implemented:\n+every active node has a gate (ins, outs); pivot = slot of operand 0 (a leaf allocates a fresh source slot);\n+outs = pivot + one fresh slot per further user; users are gates in node order (operand position) then outputs\n+in sorted (centre, target) order; outs[k] goes to users[k]. Roles = additions + outputs.\n+\n+Frames (two-stage-construction.tex + shared_point_circuit.verify_frames): a gate at node n uses the source-span\n+frame span(n) = span{t_S : S in supp n} on every slot it touches (forward invocation); a source slot is copied\n+at = span(leaf); an output slot is injected at its target-line complement t_T^perp; early mixers at\n+D0 (= 0 in stage 1), cleanup at D1 (= F). Reverse invocation (stage 2): orthogonal complements in reverse order;\n+the edge idempotents P_{U2}-P_{U1} are literally the same set (complement chain of a G-orthogonal flag).\n+So per slot, factor-space chain: 0 < [] <= span(n_0) <= ... <= span(n_k) < [t_T^perp] < F, tensored with\n+P_b (stage 1, second factor fixed triple b) or P_b (x) . (stage 2).\"\"\"\n+import sys, os\n+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\n+sys.setrecursionlimit(100000)\n+from itertools import combinations\n+import sidegen, orders\n+\n+\n+def graph_rank(pairs):\n+ adj = {}\n+ for a, b in pairs: adj.setdefault(a, []).append(b); adj.setdefault(b, []).append(a)\n+ col = {}; bip = 0\n+ for s in adj:\n+ if s in col: continue\n+ col[s] = 0; st = [s]; ok = True\n+ while st:\n+ u = st.pop()\n+ for w in adj[u]:\n+ if w not in col: col[w] = 1-col[u]; st.append(w)\n+ elif col[w] == col[u]: ok = False\n+ bip += ok\n+ return len(adj)-bip\n+\n+ORDERS = {'nat': orders.natural, 'gm': orders.gm}\n+\n+def build(h, order, exact=False):\n+ loc = sidegen.Excl(h-1)\n+ dl = {nd: graph_rank([p for i, p in enumerate(loc.inputs) if loc.support[nd] >> i & 1]) for nd in loc.active}\n+ trip = list(combinations(range(h), 3)); v = len(trip); var = {t: i+1 for i, t in enumerate(trip)}\n+ args = [None]*(v+1); core = [0]+[sum(1 << i for i in t) for t in trip]; union = list(core); dn = [0]+[1]*v\n+ sup = [0]+[1 << i for i in range(v)] if exact else None\n+ lookup = {}; outputs = {}\n+ for c in range(h):\n+ pts = order(h, c); mp = {}\n+ for nd in sorted(loc.active):\n+ if loc.args[nd] is None:\n+ a, b = loc.inputs[nd-1]; mp[nd] = var[tuple(sorted((c, pts[a], pts[b])))]; continue\n+ a, b = (mp[x] for x in loc.args[nd])\n+ co = core[a] & core[b]; un = union[a] | union[b]; key = (co, un)\n+ assert co >> c & 1\n+ if bin(co).count('1') >= 2 and key in lookup:\n+ k = lookup[key]; assert dn[k] == dl[nd]; mp[nd] = k\n+ if exact: assert sup[k] == sup[a] | sup[b]\n+ continue\n+ k = len(args); mp[nd] = k; args.append((a, b)); core.append(co); union.append(un); dn.append(dl[nd])\n+ if exact: assert not sup[a] & sup[b]; sup.append(sup[a] | sup[b])\n+ if bin(co).count('1') >= 2: lookup[key] = k\n+ for (x, y), nd in loc.outputs.items():\n+ outputs[c, tuple(sorted((c, pts[x], pts[y])))] = mp[nd]\n+ act = set(); st = list(outputs.values())\n+ while st:\n+ n = st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ return dict(h=h, trip=trip, args=args, dn=dn, outputs=outputs, active=act, sup=sup)\n+\n+def compile_(G):\n+ args, act, outputs = G['args'], G['active'], G['outputs']\n+ users = {x: [] for x in act}\n+ for n in sorted(act):\n+ if args[n]:\n+ for pos, x in enumerate(args[n]): users[x].append(('gate', n, pos))\n+ for tgt, n in sorted(outputs.items()): users[n].append(('output', tgt))\n+ edge = {}; src = {}; out = {}; size = 0; hold = [] # hold[slot] = nodes whose gate touched the slot\n+ for n in sorted(act):\n+ if args[n]:\n+ ins = (edge[n, 0], edge[n, 1]); pivot = ins[0]\n+ else:\n+ pivot = size; size += 1; ins = (pivot,); src[pivot] = n; hold.append([])\n+ outs = (pivot,)+tuple(range(size, size+len(users[n])-1))\n+ for _ in range(len(users[n])-1): hold.append([])\n+ size += len(users[n])-1\n+ for s in set(ins+outs): hold[s].append(n)\n+ for u, s in zip(users[n], outs):\n+ if u[0] == 'gate': edge[u[1], u[2]] = s\n+ else: out[s] = u[1]\n+ adds = sum(1 for n in act if args[n])\n+ assert size == adds+len(outputs)\n+ return dict(roles=size, hold=hold, src=src, out=out, adds=adds)\n+\n+def chain_dims(G, C, s):\n+ \"\"\"Factor-space dimension chain of slot s (stage-1 forward order), from 0 to h.\"\"\"\n+ h = G['h']; dn = G['dn']; d = [0]\n+ for n in C['hold'][s]:\n+ if dn[n] != d[-1]: d.append(dn[n])\n+ if s in C['out']: d.append(h-1)\n+ d.append(h)\n+ assert all(a < b for a, b in zip(d, d[1:])), (s, d)\n+ return d\n+\n+def chain_type(G, C, s):\n+ \"\"\"(source?, output?, number of nodes held, retired-by-operand-1?)\"\"\"\n+ hold = C['hold'][s]; args = G['args']\n+ last = hold[-1]\n+ retire = s not in C['out'] and len(hold) >= 1 and args[last] is not None and False\n+ return ('src' if s in C['src'] else 'fresh', 'out' if s in C['out'] else 'retire', len(hold))\n+\n+def inner(r, h):\n+ \"\"\"Inner lemma prediction for a rank-r edge pi (x) P_b: children widths.\"\"\"\n+ if 2*r > h: return [1]*(h-r)+([2*r-h] if 2*r > h else [])\n+ return [1]*r\n+\n+if __name__ == '__main__':\n+ from collections import Counter\n+ prod = sys.argv[1]\n+ for h in map(int, sys.argv[2:]):\n+ G = build(h, ORDERS[prod]); C = compile_(G)\n+ ranks = Counter(); types = Counter(); prof = Counter(); seqs = Counter()\n+ for s in range(C['roles']):\n+ d = chain_dims(G, C, s); rr = tuple(b-a for a, b in zip(d, d[1:]))\n+ seqs[rr] += 1; types[chain_type(G, C, s)[:2]] += 1\n+ for r in rr:\n+ ranks[r] += 1\n+ for w in inner(r, h): prof[w] += 1\n+ sing = prof[1]\n+ print('%s h=%d R=%d adds=%d outputs=%d slot types %s singletons/slot %.3f blocks %s' % (\n+ prod, h, C['roles'], C['adds'], len(G['outputs']), dict(types), sing/C['roles'],\n+ sorted((w, c) for w, c in prof.items() if w > 1)), flush=True)\n+ print(' top rank sequences', seqs.most_common(12), flush=True)" + }, + { + "sha": "7ab495d87c762cfc00e485711d5f5d58d97e3fc1", + "filename": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/sidegen.py", + "status": "added", + "additions": 104, + "deletions": 0, + "changes": 104, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fsidegen.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fsidegen.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Findependent%2Ftwo-stage-bit%2Fsidegen.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,104 @@\n+\"\"\"Our own paired-bit side generator (re-implemented from the two-stage notes' description:\n+paired exclusion circuit on h-1 points + cross-common-point sharing). Roles R = additions + outputs.\n+Self-checks: disjoint supports for every addition, exact pair-exclusion outputs.\"\"\"\n+import sys\n+from itertools import combinations\n+sys.setrecursionlimit(10000)\n+\n+class Excl:\n+ def __init__(self, n):\n+ self.n = n; self.inputs = list(combinations(range(n), 2))\n+ self.support = [0]+[1 << i for i in range(len(self.inputs))]\n+ self.args = [None]*len(self.support)\n+ self.lookup = {s: i for i, s in enumerate(self.support)}\n+ self.var = {p: i+1 for i, p in enumerate(self.inputs)}\n+ _, _, self.outputs = self.pairblock(list(range(n)))\n+ self.active = set(); st = list(self.outputs.values())\n+ while st:\n+ x = st.pop()\n+ if not x or x in self.active: continue\n+ self.active.add(x)\n+ if self.args[x]: st.extend(self.args[x])\n+ def add(self, a, b):\n+ if not a: return b\n+ if not b: return a\n+ assert not self.support[a] & self.support[b]\n+ s = self.support[a] | self.support[b]\n+ if s in self.lookup: return self.lookup[s]\n+ k = len(self.support); self.lookup[s] = k; self.support.append(s); self.args.append((a, b)); return k\n+ def total(self, vals):\n+ if not vals: return 0\n+ if len(vals) == 1: return vals[0]\n+ h = len(vals)//2; return self.add(self.total(vals[:h]), self.total(vals[h:]))\n+ def loo(self, vals): # total and leave-one-out via prefix/suffix\n+ n = len(vals); pre = [0]\n+ for x in vals: pre.append(self.add(pre[-1], x))\n+ suf = [0]*(n+1)\n+ for i in range(n-1, -1, -1): suf[i] = self.add(vals[i], suf[i+1])\n+ return pre[-1], [self.add(pre[i], suf[i+1]) for i in range(n)]\n+ def pairblock(self, pts):\n+ return self.block(pts, {(a, b): self.var[a, b] for a, b in combinations(pts, 2)}, {a: 0 for a in pts})\n+ def block(self, pts, edges, wts):\n+ if len(pts) <= 4:\n+ tot = lambda om: self.total([x for p, x in edges.items() if not set(p) & set(om)]+[x for p, x in wts.items() if p not in om])\n+ return tot(()), {a: tot((a,)) for a in pts}, {(a, b): tot((a, b)) for a, b in combinations(pts, 2)}\n+ gr = [pts[i:i+2] for i in range(0, len(pts), 2)]; ng = len(gr)\n+ e = lambda a, b: edges[tuple(sorted((a, b)))]\n+ coarse = {(i, j): self.total([e(a, b) for a in gr[i] for b in gr[j]]) for i, j in combinations(range(ng), 2)}\n+ wt = {i: self.total([wts[a] for a in g]+[e(a, b) for a, b in combinations(g, 2)]) for i, g in enumerate(gr)}\n+ total, outside, far = self.block(list(range(ng)), coarse, wt)\n+ strips = {}; sums = {}\n+ for i, g in enumerate(gr):\n+ other = [j for j in range(ng) if j != i]\n+ for a in g:\n+ carry = self.total([wts[u] for u in g if u != a])\n+ vals = [self.total([e(u, w) for u in g if u != a for w in gr[j]]) for j in other]\n+ st, one = self.loo([carry]+vals)\n+ strips[a] = dict(zip(other, one[1:])); sums[a] = st\n+ out = {}\n+ single = {a: self.add(outside[i], sums[a]) for i, g in enumerate(gr) for a in g} # omit one vertex\n+ for i, g in enumerate(gr):\n+ for a, b in combinations(g, 2): out[a, b] = outside[i]\n+ for i, j in combinations(range(ng), 2):\n+ for a in gr[i]:\n+ left = self.add(far[i, j], strips[a][j])\n+ for b in gr[j]:\n+ cross = self.total([e(u, w) for u in gr[i] if u != a for w in gr[j] if w != b])\n+ out[a, b] = self.add(left, self.add(strips[b][i], cross))\n+ return total, single, out\n+\n+def roles(h):\n+ loc = Excl(h-1)\n+ for (a, b), nd in loc.outputs.items(): # exact pair-exclusion check\n+ assert loc.support[nd] == sum(1 << i for i, p in enumerate(loc.inputs) if a not in p and b not in p)\n+ for nd in loc.active:\n+ if loc.args[nd]:\n+ x, y = loc.args[nd]; assert not loc.support[x] & loc.support[y]\n+ inputs = list(combinations(range(h), 3)); var = {t: i+1 for i, t in enumerate(inputs)}\n+ args = [None]*(len(inputs)+1); core = [0]+[sum(1 << i for i in t) for t in inputs]; union = list(core)\n+ points = [[j for j in range(h) if j != i] for i in range(h)]\n+ lookup = {}; outputs = {}\n+ for c in range(h):\n+ mp = {}\n+ for nd in sorted(loc.active):\n+ if loc.args[nd] is None:\n+ a, b = loc.inputs[nd-1]; mp[nd] = var[tuple(sorted((c, points[c][a], points[c][b])))]; continue\n+ a, b = (mp[x] for x in loc.args[nd])\n+ co = core[a] & core[b]; un = union[a] | union[b]; key = (co, un)\n+ if bin(co).count(\"1\") >= 2 and key in lookup: mp[nd] = lookup[key]; continue\n+ k = len(args); mp[nd] = k; args.append((a, b)); core.append(co); union.append(un)\n+ if bin(co).count(\"1\") >= 2: lookup[key] = k\n+ for pair, nd in loc.outputs.items():\n+ outputs[c, tuple(sorted((c, *(points[c][x] for x in pair))))] = mp[nd]\n+ act = set(); st = list(outputs.values())\n+ while st:\n+ n = st.pop()\n+ if n in act: continue\n+ act.add(n)\n+ if args[n]: st.extend(args[n])\n+ adds = sum(args[n] is not None for n in act)\n+ return adds+len(outputs), adds, len(outputs)\n+\n+if __name__ == '__main__':\n+ for h in map(int, sys.argv[1:]):\n+ print(h, roles(h), flush=True)" + }, + { + "sha": "2577a55fb158a46bb7c82db5e7f53587c5b5e91b", + "filename": "research/deferred-signed/swapnil-round7/lean/Round5.lean", + "status": "added", + "additions": 81, + "deletions": 0, + "changes": 81, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound5.lean", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound5.lean", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound5.lean?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,81 @@\n+set_option maxRecDepth 100000\n+-- Generated by gen.py. Rationals are pairs (numerator, denominator) of naturals, denominators positive.\n+abbrev Q := Nat \u00d7 Nat\n+\n+def norm (a : Q) : Q := let g := Nat.gcd a.1 a.2; if g = 0 then a else (a.1 / g, a.2 / g)\n+def qadd (a b : Q) : Q := norm (a.1 * b.2 + b.1 * a.2, a.2 * b.2)\n+def qmul (a b : Q) : Q := norm (a.1 * b.1, a.2 * b.2)\n+def qdiv (a b : Q) : Q := norm (a.1 * b.2, a.2 * b.1)\n+-- a - b, defined when b <= a\n+def qsub (a b : Q) : Q := norm (a.1 * b.2 - b.1 * a.2, a.2 * b.2)\n+def qlt (a b : Q) : Bool := a.1 * b.2 < b.1 * a.2\n+def qpow (a : Q) : Nat \u2192 Q\n+ | 0 => (1, 1)\n+ | k + 1 => qmul a (qpow a k)\n+\n+-- 2 * (sum_{j (0, 1)\n+ | j + 1 => qadd (atanhSum z j) (qdiv (qpow z (2 * j + 1)) (2 * j + 1, 1))\n+def twoAtanhUp (z : Q) (n : Nat) : Q :=\n+ qmul (2, 1) (qadd (atanhSum z n) (qdiv (qpow z (2 * n + 1)) (qmul (2 * n + 1, 1) (qsub (1, 1) (qmul z z)))))\n+\n+-- halve x until x <= 2, counting the halvings (fuel bounds the loop)\n+def halve (x : Q) (k : Nat) : Nat \u2192 Q \u00d7 Nat\n+ | 0 => (x, k)\n+ | f + 1 => if qlt (2, 1) x then halve (norm (x.1, 2 * x.2)) (k + 1) f else (x, k)\n+\n+def lnUp (x : Q) : Q :=\n+ let p := halve x 0 64\n+ let y := p.1\n+ let base := qmul (p.2, 1) (twoAtanhUp (1, 3) 30)\n+ if qlt (1, 1) y then qadd base (twoAtanhUp (qdiv (qsub y (1, 1)) (qadd y (1, 1))) 30) else base\n+\n+def rankSum (h : List (Nat \u00d7 Nat)) : Nat := h.foldl (fun acc p => acc + p.1 * p.2) 0\n+\n+-- moment bound: every a * L_w < 1, every w < m, and sum n w / (m (1 - a L_w)) < W\n+def momentOK (h : List (Nat \u00d7 Nat)) (a : Q) (m W : Nat) : Bool :=\n+ let step := fun (acc : Bool \u00d7 Q) (p : Nat \u00d7 Nat) =>\n+ let w := p.1; let n := p.2\n+ let l := lnUp (m, w)\n+ let al := qmul a l\n+ let ok := acc.1 && (w < m) && qlt al (1, 1)\n+ if ok then (true, qadd acc.2 (qdiv (n * w, 1) (qmul (m, 1) (qsub (1, 1) al)))) else (false, acc.2)\n+ let r := h.foldl step (true, (0, 1))\n+ r.1 && qlt r.2 (W, 1)\n+\n+def qmax (a b : Q) : Q := if qlt a b then b else a\n+def qmin (a b : Q) : Q := if qlt a b then a else b\n+\n+-- The assembly of scripts/certificate_round3.py (crude guard), for given savings a_b, a_c, beta and the chosen\n+-- eps, x, kappa: every constraint is strict and every cost margin exceeds kappa. C1 = 1 + m_c ln s_c + 1 is\n+-- replaced by the check that the given C1 bounds 2 + m_c * (upper bound of ln s_c).\n+def kappaOK (ab ac beta eps x c1 kappa : Q) (mc sc : Nat) : Bool :=\n+ let gl : Q := (1, 10000000000000000)\n+ let one : Q := (1, 1)\n+ let tau := qsub one ab\n+ let sigma := qsub one ac\n+ let chi := qadd tau (qmul (qsub one beta) (if qlt tau sigma then qsub sigma tau else (0, 1)))\n+ let leaf := qadd sigma (qmul beta (qsub one sigma))\n+ let lam := qadd (qmax (qmax tau sigma) chi) gl\n+ let lamp := qadd (qmax lam leaf) gl\n+ let delta := qdiv (1, 10000000000000000000000) x\n+ let poly := qmul (qadd one x) delta\n+ let c1ok := !(qlt c1 (qadd (2, 1) (qmul (mc, 1) (lnUp (sc, 1)))))\n+ let cons := qlt lamp one && qlt (qmul eps (qsub (2, 1) lamp)) one\n+ && qlt (qmul eps c1) (qadd one x) && qlt (qadd (qmul (2, 1) eps) eps) (qadd one x)\n+ && qlt (qsub (qmul (2, 1) eps) one) (qmul lamp eps) && qlt eps one && qlt delta (1, 8)\n+ let margins := [qsub one eps, qmul eps (qsub one lamp), qsub (qsub one eps) poly, eps,\n+ qmul (qmax eps (qsub one eps)) (qsub one tau)]\n+ c1ok && cons && margins.all (fun g => qlt kappa g)\n+\n+-- bit interchange\n+def bitHist : List (Nat \u00d7 Nat) := [(1, 308619300465), (3, 269071710), (5, 485704110), (7, 154755960), (9, 426259920), (11, 205054890), (13, 528381990), (15, 203530680), (17, 435405180), (19, 256878030), (21, 552769350), (23, 153231750), (25, 516188310), (27, 205054890), (29, 529906200), (31, 487033740), (33, 846941880), (35, 173046480), (37, 3069304920), (39, 973354020), (41, 385625130), (43, 804069420), (45, 1577557350), (47, 13083429480), (2023, 525852450), (2115, 13078856850)]\n+theorem bit_rank_sum : rankSum bitHist = 30052683193215 := by decide\n+theorem bit_moment : momentOK bitHist (15479, 1000000000) 2209 13604709300 = true := by decide\n+-- complex interchange\n+def cxHist : List (Nat \u00d7 Nat) := [(1, 3175994308032), (2, 1150092176688), (3, 437228850240), (4, 621103221648), (5, 530083636992), (6, 411085269504), (7, 297495918720), (8, 351328513536), (9, 182103562368), (10, 272253840768), (11, 137929925952), (12, 244629219744), (13, 156861484416), (14, 239799740544), (15, 146043451008), (16, 251229507984), (17, 136126920384), (18, 265041818496), (19, 156861484416), (20, 240894422496), (21, 232587718272), (22, 213430784112), (23, 270450835200), (24, 201936623616), (25, 48681150336), (26, 313272217440), (27, 246110260032), (28, 2801097936), (729, 105475825728), (756, 311233104), (21141, 70317217152), (21168, 35469841680), (21896, 1007397164592), (21924, 971927322912)]\n+theorem cx_rank_sum : rankSum cxHist = 45772350635112192 := by decide\n+theorem cx_moment : momentOK cxHist (4079603, 250000000000) 21952 2085111546336 = true := by decide\n+-- assembly: kappa = 309575208081/20000000000000000 with the two savings above\n+theorem kappa_assembly : kappaOK (15479, 1000000000) (4079603, 250000000000) (1, 1000) (4999922606197979, 5000000000000000) (842123, 1) (842135, 1) (309575208081, 20000000000000000) 21952 45772350635112192 = true := by decide +kernel" + }, + { + "sha": "50514f86023fd1e948dd9bf9c9be2ec11d12e166", + "filename": "research/deferred-signed/swapnil-round7/lean/Round6.lean", + "status": "added", + "additions": 81, + "deletions": 0, + "changes": 81, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound6.lean", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound6.lean", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound6.lean?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,81 @@\n+set_option maxRecDepth 100000\n+-- Generated by gen.py. Rationals are pairs (numerator, denominator) of naturals, denominators positive.\n+abbrev Q := Nat \u00d7 Nat\n+\n+def norm (a : Q) : Q := let g := Nat.gcd a.1 a.2; if g = 0 then a else (a.1 / g, a.2 / g)\n+def qadd (a b : Q) : Q := norm (a.1 * b.2 + b.1 * a.2, a.2 * b.2)\n+def qmul (a b : Q) : Q := norm (a.1 * b.1, a.2 * b.2)\n+def qdiv (a b : Q) : Q := norm (a.1 * b.2, a.2 * b.1)\n+-- a - b, defined when b <= a\n+def qsub (a b : Q) : Q := norm (a.1 * b.2 - b.1 * a.2, a.2 * b.2)\n+def qlt (a b : Q) : Bool := a.1 * b.2 < b.1 * a.2\n+def qpow (a : Q) : Nat \u2192 Q\n+ | 0 => (1, 1)\n+ | k + 1 => qmul a (qpow a k)\n+\n+-- 2 * (sum_{j (0, 1)\n+ | j + 1 => qadd (atanhSum z j) (qdiv (qpow z (2 * j + 1)) (2 * j + 1, 1))\n+def twoAtanhUp (z : Q) (n : Nat) : Q :=\n+ qmul (2, 1) (qadd (atanhSum z n) (qdiv (qpow z (2 * n + 1)) (qmul (2 * n + 1, 1) (qsub (1, 1) (qmul z z)))))\n+\n+-- halve x until x <= 2, counting the halvings (fuel bounds the loop)\n+def halve (x : Q) (k : Nat) : Nat \u2192 Q \u00d7 Nat\n+ | 0 => (x, k)\n+ | f + 1 => if qlt (2, 1) x then halve (norm (x.1, 2 * x.2)) (k + 1) f else (x, k)\n+\n+def lnUp (x : Q) : Q :=\n+ let p := halve x 0 64\n+ let y := p.1\n+ let base := qmul (p.2, 1) (twoAtanhUp (1, 3) 30)\n+ if qlt (1, 1) y then qadd base (twoAtanhUp (qdiv (qsub y (1, 1)) (qadd y (1, 1))) 30) else base\n+\n+def rankSum (h : List (Nat \u00d7 Nat)) : Nat := h.foldl (fun acc p => acc + p.1 * p.2) 0\n+\n+-- moment bound: every a * L_w < 1, every w < m, and sum n w / (m (1 - a L_w)) < W\n+def momentOK (h : List (Nat \u00d7 Nat)) (a : Q) (m W : Nat) : Bool :=\n+ let step := fun (acc : Bool \u00d7 Q) (p : Nat \u00d7 Nat) =>\n+ let w := p.1; let n := p.2\n+ let l := lnUp (m, w)\n+ let al := qmul a l\n+ let ok := acc.1 && (w < m) && qlt al (1, 1)\n+ if ok then (true, qadd acc.2 (qdiv (n * w, 1) (qmul (m, 1) (qsub (1, 1) al)))) else (false, acc.2)\n+ let r := h.foldl step (true, (0, 1))\n+ r.1 && qlt r.2 (W, 1)\n+\n+def qmax (a b : Q) : Q := if qlt a b then b else a\n+def qmin (a b : Q) : Q := if qlt a b then a else b\n+\n+-- The assembly of scripts/certificate_round3.py (crude guard), for given savings a_b, a_c, beta and the chosen\n+-- eps, x, kappa: every constraint is strict and every cost margin exceeds kappa. C1 = 1 + m_c ln s_c + 1 is\n+-- replaced by the check that the given C1 bounds 2 + m_c * (upper bound of ln s_c).\n+def kappaOK (ab ac beta eps x c1 kappa : Q) (mc sc : Nat) : Bool :=\n+ let gl : Q := (1, 10000000000000000)\n+ let one : Q := (1, 1)\n+ let tau := qsub one ab\n+ let sigma := qsub one ac\n+ let chi := qadd tau (qmul (qsub one beta) (if qlt tau sigma then qsub sigma tau else (0, 1)))\n+ let leaf := qadd sigma (qmul beta (qsub one sigma))\n+ let lam := qadd (qmax (qmax tau sigma) chi) gl\n+ let lamp := qadd (qmax lam leaf) gl\n+ let delta := qdiv (1, 10000000000000000000000) x\n+ let poly := qmul (qadd one x) delta\n+ let c1ok := !(qlt c1 (qadd (2, 1) (qmul (mc, 1) (lnUp (sc, 1)))))\n+ let cons := qlt lamp one && qlt (qmul eps (qsub (2, 1) lamp)) one\n+ && qlt (qmul eps c1) (qadd one x) && qlt (qadd (qmul (2, 1) eps) eps) (qadd one x)\n+ && qlt (qsub (qmul (2, 1) eps) one) (qmul lamp eps) && qlt eps one && qlt delta (1, 8)\n+ let margins := [qsub one eps, qmul eps (qsub one lamp), qsub (qsub one eps) poly, eps,\n+ qmul (qmax eps (qsub one eps)) (qsub one tau)]\n+ c1ok && cons && margins.all (fun g => qlt kappa g)\n+\n+-- bit interchange\n+def bitHist : List (Nat \u00d7 Nat) := [(1, 2191713447), (3, 5667200), (5, 11716936), (7, 6970656), (9, 14731178), (11, 4445210), (13, 35572306), (15, 13905892), (17, 4562096), (19, 9740500), (21, 18900112), (23, 141952734), (439, 6272882), (483, 141952734)]\n+theorem bit_rank_sum : rankSum bitHist = 78410006675 := by decide\n+theorem bit_moment : momentOK bitHist (36667, 1000000000) 529 148225616 = true := by decide\n+-- complex interchange\n+def cxHist : List (Nat \u00d7 Nat) := [(1, 184811440), (2, 107199136), (3, 50583808), (4, 53478128), (5, 33031680), (6, 27611408), (7, 14767104), (8, 20195472), (9, 6217728), (10, 14119424), (11, 5051904), (12, 13742960), (13, 4663296), (14, 14864256), (15, 4849504), (16, 13014320), (17, 10196912), (18, 33371712), (19, 13601280), (20, 22774048), (22, 44038192), (23, 16479408), (24, 4048), (529, 8193152), (552, 199193984)]\n+theorem cx_rank_sum : rankSum cxHist = 119453132304 := by decide\n+theorem cx_moment : momentOK cxHist (36926111, 500000000000) 576 207387136 = true := by decide\n+-- assembly: kappa = 3666565558019/100000000000000000 with the two savings above\n+theorem kappa_assembly : kappaOK (36667, 1000000000) (36926111, 500000000000) (1, 1000) (2499908335861049, 2500000000000000) (14695, 1) (14694, 1) (3666565558019, 100000000000000000) 576 119453132304 = true := by decide +kernel" + }, + { + "sha": "b523099790aadab761c9a7a1085583f988d16d9b", + "filename": "research/deferred-signed/swapnil-round7/lean/Round7.lean", + "status": "added", + "additions": 87, + "deletions": 0, + "changes": 87, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound7.lean", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound7.lean", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2FRound7.lean?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,87 @@\n+set_option maxRecDepth 100000\n+-- Generated by gen.py. Rationals are pairs (numerator, denominator) of naturals, denominators positive.\n+abbrev Q := Nat \u00d7 Nat\n+\n+def norm (a : Q) : Q := let g := Nat.gcd a.1 a.2; if g = 0 then a else (a.1 / g, a.2 / g)\n+def qadd (a b : Q) : Q := norm (a.1 * b.2 + b.1 * a.2, a.2 * b.2)\n+def qmul (a b : Q) : Q := norm (a.1 * b.1, a.2 * b.2)\n+def qdiv (a b : Q) : Q := norm (a.1 * b.2, a.2 * b.1)\n+-- a - b, defined when b <= a\n+def qsub (a b : Q) : Q := norm (a.1 * b.2 - b.1 * a.2, a.2 * b.2)\n+def qlt (a b : Q) : Bool := a.1 * b.2 < b.1 * a.2\n+def qpow (a : Q) : Nat \u2192 Q\n+ | 0 => (1, 1)\n+ | k + 1 => qmul a (qpow a k)\n+\n+-- 2 * (sum_{j (0, 1)\n+ | j + 1 => qadd (atanhSum z j) (qdiv (qpow z (2 * j + 1)) (2 * j + 1, 1))\n+def twoAtanhUp (z : Q) (n : Nat) : Q :=\n+ qmul (2, 1) (qadd (atanhSum z n) (qdiv (qpow z (2 * n + 1)) (qmul (2 * n + 1, 1) (qsub (1, 1) (qmul z z)))))\n+\n+-- halve x until x <= 2, counting the halvings (fuel bounds the loop)\n+def halve (x : Q) (k : Nat) : Nat \u2192 Q \u00d7 Nat\n+ | 0 => (x, k)\n+ | f + 1 => if qlt (2, 1) x then halve (norm (x.1, 2 * x.2)) (k + 1) f else (x, k)\n+\n+def lnUp (x : Q) : Q :=\n+ let p := halve x 0 64\n+ let y := p.1\n+ let base := qmul (p.2, 1) (twoAtanhUp (1, 3) 30)\n+ if qlt (1, 1) y then qadd base (twoAtanhUp (qdiv (qsub y (1, 1)) (qadd y (1, 1))) 30) else base\n+\n+def rankSum (h : List (Nat \u00d7 Nat)) : Nat := h.foldl (fun acc p => acc + p.1 * p.2) 0\n+\n+-- moment bound: every a * L_w < 1, every w < m, and sum n w / (m (1 - a L_w)) < W\n+def momentOK (h : List (Nat \u00d7 Nat)) (a : Q) (m W : Nat) : Bool :=\n+ let step := fun (acc : Bool \u00d7 Q) (p : Nat \u00d7 Nat) =>\n+ let w := p.1; let n := p.2\n+ let l := lnUp (m, w)\n+ let al := qmul a l\n+ let ok := acc.1 && (w < m) && qlt al (1, 1)\n+ if ok then (true, qadd acc.2 (qdiv (n * w, 1) (qmul (m, 1) (qsub (1, 1) al)))) else (false, acc.2)\n+ let r := h.foldl step (true, (0, 1))\n+ r.1 && qlt r.2 (W, 1)\n+\n+def qmax (a b : Q) : Q := if qlt a b then b else a\n+def qmin (a b : Q) : Q := if qlt a b then a else b\n+\n+-- The assembly of scripts/certificate_round3.py (crude guard), for given savings a_b, a_c, beta and the chosen\n+-- eps, x, kappa: every constraint is strict and every cost margin exceeds kappa. C1 = 1 + m_c ln s_c + 1 is\n+-- replaced by the check that the given C1 bounds 2 + m_c * (upper bound of ln s_c).\n+def kappaOK (ab ac beta eps x c1 kappa : Q) (mc sc : Nat) : Bool :=\n+ let gl : Q := (1, 10000000000000000)\n+ let one : Q := (1, 1)\n+ let tau := qsub one ab\n+ let sigma := qsub one ac\n+ let chi := qadd tau (qmul (qsub one beta) (if qlt tau sigma then qsub sigma tau else (0, 1)))\n+ let leaf := qadd sigma (qmul beta (qsub one sigma))\n+ let lam := qadd (qmax (qmax tau sigma) chi) gl\n+ let lamp := qadd (qmax lam leaf) gl\n+ let delta := qdiv (1, 10000000000000000000000) x\n+ let poly := qmul (qadd one x) delta\n+ let c1ok := !(qlt c1 (qadd (2, 1) (qmul (mc, 1) (lnUp (sc, 1)))))\n+ let cons := qlt lamp one && qlt (qmul eps (qsub (2, 1) lamp)) one\n+ && qlt (qmul eps c1) (qadd one x) && qlt (qadd (qmul (2, 1) eps) eps) (qadd one x)\n+ && qlt (qsub (qmul (2, 1) eps) one) (qmul lamp eps) && qlt eps one && qlt delta (1, 8)\n+ let margins := [qsub one eps, qmul eps (qsub one lamp), qsub (qsub one eps) poly, eps,\n+ qmul (qmax eps (qsub one eps)) (qsub one tau)]\n+ c1ok && cons && margins.all (fun g => qlt kappa g)\n+\n+-- bit interchange, staircase entrance corner\n+def bitHist : List (Nat \u00d7 Nat) := [(1, 1690297301), (3, 1356586), (5, 354200), (7, 3580962), (9, 1526602), (11, 5093396), (13, 2164162), (15, 7948248), (17, 8476006), (18, 6272882), (19, 1639946), (21, 6906900), (23, 61280142), (439, 6272882), (483, 61280142), (485, 545468), (487, 173558), (489, 293986), (491, 580888), (493, 14168), (495, 322322), (497, 17710), (499, 1129898), (501, 127512), (503, 410872), (505, 99176), (507, 1186570), (509, 340032), (511, 322322), (513, 106260), (515, 1583274), (517, 626934), (519, 2854852), (521, 13711082), (523, 4629394), (525, 5653032), (527, 6233920)]\n+theorem bit_rank_sum : rankSum bitHist = 57403754177 := by decide\n+theorem bit_moment : momentOK bitHist (31987, 500000000) 529 108516254 = true := by decide\n+-- bit interchange, round-six entrance corner\n+def bitplainHist : List (Nat \u00d7 Nat) := [(1, 1803209177), (3, 1356586), (5, 354200), (7, 3580962), (9, 1526602), (11, 5093396), (13, 2164162), (15, 7948248), (17, 8476006), (19, 1639946), (21, 6906900), (23, 61280142), (439, 6272882), (483, 61280142), (485, 545468), (487, 173558), (489, 293986), (491, 580888), (493, 14168), (495, 322322), (497, 17710), (499, 1129898), (501, 127512), (503, 410872), (505, 99176), (507, 1186570), (509, 340032), (511, 322322), (513, 106260), (515, 1583274), (517, 626934), (519, 2854852), (521, 13711082), (523, 4629394), (525, 5653032), (527, 6233920)]\n+theorem bitplain_rank_sum : rankSum bitplainHist = 57403754177 := by decide\n+theorem bitplain_moment : momentOK bitplainHist (12599, 200000000) 529 108516254 = true := by decide\n+-- complex interchange (round six)\n+def cxHist : List (Nat \u00d7 Nat) := [(1, 184811440), (2, 107199136), (3, 50583808), (4, 53478128), (5, 33031680), (6, 27611408), (7, 14767104), (8, 20195472), (9, 6217728), (10, 14119424), (11, 5051904), (12, 13742960), (13, 4663296), (14, 14864256), (15, 4849504), (16, 13014320), (17, 10196912), (18, 33371712), (19, 13601280), (20, 22774048), (22, 44038192), (23, 16479408), (24, 4048), (529, 8193152), (552, 199193984)]\n+theorem cx_rank_sum : rankSum cxHist = 119453132304 := by decide\n+theorem cx_moment : momentOK cxHist (36926111, 500000000000) 576 207387136 = true := by decide\n+-- assembly: kappa = 1599247689723/25000000000000000 with the two savings above\n+theorem kappa_assembly : kappaOK (31987, 500000000) (36926111, 500000000000) (1, 1000) (9999360300924109, 10000000000000000) (14695, 1) (14694, 1) (1599247689723, 25000000000000000) 576 119453132304 = true := by decide +kernel\n+-- assembly: kappa = 6299103187973/100000000000000000 with the savings bitplain and cx above\n+theorem kappaplain_assembly : kappaOK (12599, 200000000) (36926111, 500000000000) (1, 1000) (9999370089681201, 10000000000000000) (14695, 1) (14694, 1) (6299103187973, 100000000000000000) 576 119453132304 = true := by decide +kernel" + }, + { + "sha": "dcc74f0aa73809eed6a1b60b6a4630945864e964", + "filename": "research/deferred-signed/swapnil-round7/lean/dump.py", + "status": "added", + "additions": 20, + "deletions": 0, + "changes": 20, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,20 @@\n+\"\"\"Dump the round-five bit and complex child-width histograms for the Lean check (run from the repository root).\"\"\"\n+import sys, json, os\n+sys.path.insert(0, 'scripts'); sys.path.insert(0, 'independent/two-stage-bit')\n+from fractions import Fraction as Q\n+import certificate_round5 as c5, moment\n+a_b, cb = c5.bit_saving(side=True)\n+d = json.load(open(sys.argv[1])) # from independent/complex-network/fullbatch_hist.py 28 OUT sf\n+hc = {int(k): v for k, v in d['hist'].items()}\n+out = dict(bit=dict(a=[a_b.numerator, a_b.denominator], m=cb['m'], W=cb['W'], s=cb['s'], hist=sorted(cb['hist'].items())),\n+ cx=dict(a=[4079603, 25*10**10], m=d['m'], W=d['W'], s=d['s'], hist=sorted(hc.items())))\n+# python-side check with the atanh ln bound used by the Lean file\n+for k in ('bit', 'cx'):\n+ o = out[k]; c = dict(m=o['m'], W=o['W'], hist=dict(o['hist']))\n+ lu = {w: moment.ln_upper(Q(o['m'], w)) for w in c['hist']}\n+ print(k, 'sum==s', sum(w*n for w, n in o['hist']) == o['s'], 'F_upper<1', moment.F_upper(c, Q(*o['a']), lu) < 1, 'widths', len(o['hist']))\n+from certificate_round3 import evaluate\n+r = evaluate(a_b, Q(*out['cx']['a']), Q(1, 1000), 'crude', m_c=d['m'], s_c=d['s'])\n+fr = lambda q: [Q(q).numerator, Q(q).denominator]\n+out['kappa'] = dict(beta=[1, 1000], eps=fr(r['eps']), x=fr(r['x']), c1=fr(r['c1']), kappa=fr(r['kappa']), mc=d['m'])\n+json.dump(out, open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'round5-histograms.json'), 'w'))" + }, + { + "sha": "564d980dd46da700b9cef392e8273bb2f02b6cc4", + "filename": "research/deferred-signed/swapnil-round7/lean/dump6.py", + "status": "added", + "additions": 18, + "deletions": 0, + "changes": 18, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump6.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump6.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump6.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,18 @@\n+\"\"\"Dump the round-six bit and complex child-width histograms and the assembly parameters for the Lean check.\n+Usage (from the repository root): python3 lean/dump6.py COMPLEX_HIST_JSON\"\"\"\n+import sys, json, os\n+from fractions import Fraction as Q\n+sys.path.insert(0, 'scripts'); sys.path.insert(0, 'independent/two-stage-bit')\n+import certificate_round6 as c6\n+from certificate_round3 import evaluate\n+a_b, cb = c6.retained_saving()\n+d = json.load(open(sys.argv[1])); hc = {int(k): v for k, v in d['hist'].items()}\n+a_c = Q(36926111, 5 * 10**11)\n+r = evaluate(a_b, a_c, Q(1, 1000), 'crude', m_c=d['m'], s_c=d['s'])\n+fr = lambda q: [Q(q).numerator, Q(q).denominator]\n+out = dict(bit=dict(a=fr(a_b), m=cb['m'], W=cb['W'], s=cb['s'], hist=sorted(cb['hist'].items())),\n+ cx=dict(a=fr(a_c), m=d['m'], W=d['W'], s=d['s'], hist=sorted(hc.items())),\n+ kappa=dict(beta=[1, 1000], eps=fr(r['eps']), x=fr(r['x']), c1=fr(r['c1']), kappa=fr(r['kappa']), mc=d['m']))\n+assert sum(w * n for w, n in out['bit']['hist']) == out['bit']['s'] and sum(w * n for w, n in out['cx']['hist']) == out['cx']['s']\n+json.dump(out, open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'round6-histograms.json'), 'w'))\n+print('kappa', r['kappa'], r['ok'])" + }, + { + "sha": "44046768cb7bd1a34158321385f0ebad726a968d", + "filename": "research/deferred-signed/swapnil-round7/lean/dump7.py", + "status": "added", + "additions": 23, + "deletions": 0, + "changes": 23, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump7.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump7.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fdump7.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,23 @@\n+\"\"\"Dump the round-seven bit histograms (staircase and round-six entrance corners) with the round-six complex\n+histogram, and both assemblies, for the Lean check. The bit histograms are rebuilt from the frozen schedule by\n+scripts/certificate_round7.py; the complex side is round six's (lean/round6-histograms.json).\n+Usage (from the repository root): python3 lean/dump7.py\"\"\"\n+import sys, json, os\n+from fractions import Fraction as Q\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, os.path.join(HERE, '..', 'scripts'))\n+import certificate_round7 as c7\n+\n+fr = lambda q: [Q(q).numerator, Q(q).denominator]\n+cx = json.load(open(os.path.join(HERE, 'round6-histograms.json')))['cx']\n+_, res = c7.certify(c7.HEADLINE)\n+out = dict(sides=[['bit', 'bit interchange, staircase entrance corner'], ['bitplain', 'bit interchange, round-six entrance corner'],\n+ ['cx', 'complex interchange (round six)']],\n+ kappas=[['kappa', 'bit'], ['kappaplain', 'bitplain']], cx=cx)\n+for side, kk, key in (('bit', 'kappa', 'staircase'), ('bitplain', 'kappaplain', 'plain')):\n+ a, k, c = res[key]\n+ out[side] = dict(a=fr(a), m=c['m'], W=c['W'], s=c['s'], hist=sorted(c['hist'].items()))\n+ out[kk] = dict(beta=[1, 1000], eps=fr(k['eps']), x=fr(k['x']), c1=fr(k['c1']), kappa=fr(k['kappa']), mc=cx['m'])\n+ assert sum(w * n for w, n in out[side]['hist']) == c['s'] and cx['m'] == c7.M_C and cx['s'] == c7.S_C\n+ print(side, 'a_b', a, 'kappa', k['kappa'], k['ok'])\n+json.dump(out, open(os.path.join(HERE, 'round7-histograms.json'), 'w'))" + }, + { + "sha": "a19afaa20c5024ff12f9f57252d49832906dbf44", + "filename": "research/deferred-signed/swapnil-round7/lean/gen.py", + "status": "added", + "additions": 107, + "deletions": 0, + "changes": 107, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fgen.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fgen.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fgen.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,107 @@\n+\"\"\"Emit a Lean 4 (core only) file that checks, in the kernel with exact arithmetic, the moment certificates of a\n+witness (round five by default; rounds six and seven from their histogram files): for every child-width histogram,\n+ (1) the widths times multiplicities sum to the total rank s;\n+ (2) every width w < m, and the rational upper bound L_w of ln(m/w) is computed from its series formula\n+ (ln x = k ln 2 + 2 atanh((y-1)/(y+1)), partial sum of 30 terms plus a geometric tail);\n+ (3) a * L_w < 1 and sum_w n_w * w / (m * (1 - a * L_w)) < W (the moment bound at the claimed saving a).\n+The analytic facts behind (2) and (3) -- the atanh tail bound and (m/w)^a <= 1/(1 - a ln(m/w)) -- are premises,\n+not checked here: Lean core has no real logarithm.\"\"\"\n+import json, os, sys\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+SRC = sys.argv[1] if len(sys.argv) > 1 else 'round5-histograms.json'\n+DST = sys.argv[2] if len(sys.argv) > 2 else 'Round5.lean'\n+D = json.load(open(os.path.join(HERE, SRC)))\n+\n+HEAD = r'''set_option maxRecDepth 100000\n+-- Generated by gen.py. Rationals are pairs (numerator, denominator) of naturals, denominators positive.\n+abbrev Q := Nat \u00d7 Nat\n+\n+def norm (a : Q) : Q := let g := Nat.gcd a.1 a.2; if g = 0 then a else (a.1 / g, a.2 / g)\n+def qadd (a b : Q) : Q := norm (a.1 * b.2 + b.1 * a.2, a.2 * b.2)\n+def qmul (a b : Q) : Q := norm (a.1 * b.1, a.2 * b.2)\n+def qdiv (a b : Q) : Q := norm (a.1 * b.2, a.2 * b.1)\n+-- a - b, defined when b <= a\n+def qsub (a b : Q) : Q := norm (a.1 * b.2 - b.1 * a.2, a.2 * b.2)\n+def qlt (a b : Q) : Bool := a.1 * b.2 < b.1 * a.2\n+def qpow (a : Q) : Nat \u2192 Q\n+ | 0 => (1, 1)\n+ | k + 1 => qmul a (qpow a k)\n+\n+-- 2 * (sum_{j (0, 1)\n+ | j + 1 => qadd (atanhSum z j) (qdiv (qpow z (2 * j + 1)) (2 * j + 1, 1))\n+def twoAtanhUp (z : Q) (n : Nat) : Q :=\n+ qmul (2, 1) (qadd (atanhSum z n) (qdiv (qpow z (2 * n + 1)) (qmul (2 * n + 1, 1) (qsub (1, 1) (qmul z z)))))\n+\n+-- halve x until x <= 2, counting the halvings (fuel bounds the loop)\n+def halve (x : Q) (k : Nat) : Nat \u2192 Q \u00d7 Nat\n+ | 0 => (x, k)\n+ | f + 1 => if qlt (2, 1) x then halve (norm (x.1, 2 * x.2)) (k + 1) f else (x, k)\n+\n+def lnUp (x : Q) : Q :=\n+ let p := halve x 0 64\n+ let y := p.1\n+ let base := qmul (p.2, 1) (twoAtanhUp (1, 3) 30)\n+ if qlt (1, 1) y then qadd base (twoAtanhUp (qdiv (qsub y (1, 1)) (qadd y (1, 1))) 30) else base\n+\n+def rankSum (h : List (Nat \u00d7 Nat)) : Nat := h.foldl (fun acc p => acc + p.1 * p.2) 0\n+\n+-- moment bound: every a * L_w < 1, every w < m, and sum n w / (m (1 - a L_w)) < W\n+def momentOK (h : List (Nat \u00d7 Nat)) (a : Q) (m W : Nat) : Bool :=\n+ let step := fun (acc : Bool \u00d7 Q) (p : Nat \u00d7 Nat) =>\n+ let w := p.1; let n := p.2\n+ let l := lnUp (m, w)\n+ let al := qmul a l\n+ let ok := acc.1 && (w < m) && qlt al (1, 1)\n+ if ok then (true, qadd acc.2 (qdiv (n * w, 1) (qmul (m, 1) (qsub (1, 1) al)))) else (false, acc.2)\n+ let r := h.foldl step (true, (0, 1))\n+ r.1 && qlt r.2 (W, 1)\n+\n+def qmax (a b : Q) : Q := if qlt a b then b else a\n+def qmin (a b : Q) : Q := if qlt a b then a else b\n+\n+-- The assembly of scripts/certificate_round3.py (crude guard), for given savings a_b, a_c, beta and the chosen\n+-- eps, x, kappa: every constraint is strict and every cost margin exceeds kappa. C1 = 1 + m_c ln s_c + 1 is\n+-- replaced by the check that the given C1 bounds 2 + m_c * (upper bound of ln s_c).\n+def kappaOK (ab ac beta eps x c1 kappa : Q) (mc sc : Nat) : Bool :=\n+ let gl : Q := (1, 10000000000000000)\n+ let one : Q := (1, 1)\n+ let tau := qsub one ab\n+ let sigma := qsub one ac\n+ let chi := qadd tau (qmul (qsub one beta) (if qlt tau sigma then qsub sigma tau else (0, 1)))\n+ let leaf := qadd sigma (qmul beta (qsub one sigma))\n+ let lam := qadd (qmax (qmax tau sigma) chi) gl\n+ let lamp := qadd (qmax lam leaf) gl\n+ let delta := qdiv (1, 10000000000000000000000) x\n+ let poly := qmul (qadd one x) delta\n+ let c1ok := !(qlt c1 (qadd (2, 1) (qmul (mc, 1) (lnUp (sc, 1)))))\n+ let cons := qlt lamp one && qlt (qmul eps (qsub (2, 1) lamp)) one\n+ && qlt (qmul eps c1) (qadd one x) && qlt (qadd (qmul (2, 1) eps) eps) (qadd one x)\n+ && qlt (qsub (qmul (2, 1) eps) one) (qmul lamp eps) && qlt eps one && qlt delta (1, 8)\n+ let margins := [qsub one eps, qmul eps (qsub one lamp), qsub (qsub one eps) poly, eps,\n+ qmul (qmax eps (qsub one eps)) (qsub one tau)]\n+ c1ok && cons && margins.all (fun g => qlt kappa g)\n+'''\n+\n+def lst(h): return '[' + ', '.join('(%d, %d)' % (w, n) for w, n in h) + ']'\n+\n+body = []\n+SIDES = D.get('sides', [['bit', 'bit interchange'], ['cx', 'complex interchange']])\n+for k, label in SIDES:\n+ o = D[k]\n+ body.append('-- %s' % label)\n+ body.append('def %sHist : List (Nat \u00d7 Nat) := %s' % (k, lst(o['hist'])))\n+ body.append('theorem %s_rank_sum : rankSum %sHist = %d := by decide' % (k, k, o['s']))\n+ body.append('theorem %s_moment : momentOK %sHist (%d, %d) %d %d = true := by decide' % (k, k, o['a'][0], o['a'][1], o['m'], o['W']))\n+# each assembly: (kappa entry, bit side it uses); the default is the single headline assembly of rounds five and six\n+for kk, bk in D.get('kappas', [['kappa', 'bit']]):\n+ kap = D.get(kk)\n+ if not kap: continue\n+ name = 'kappa_assembly' if kk == 'kappa' else kk + '_assembly'\n+ body.append('-- assembly: kappa = %d/%d with the two savings above' % tuple(kap['kappa']) if bk == 'bit' else\n+ '-- assembly: kappa = %d/%d with the savings %s and cx above' % (tuple(kap['kappa']) + (bk,)))\n+ body.append('theorem %s : kappaOK (%d, %d) (%d, %d) (%d, %d) (%d, %d) (%d, %d) (%d, %d) (%d, %d) %d %d = true := by decide +kernel' % (\n+ name, *D[bk]['a'], *D['cx']['a'], *kap['beta'], *kap['eps'], *kap['x'], *kap['c1'], *kap['kappa'], kap['mc'], D['cx']['s']))\n+open(os.path.join(HERE, DST), 'w').write(HEAD + '\\n' + '\\n'.join(body) + '\\n')\n+print('wrote', DST)" + }, + { + "sha": "d04e8b717dda125c010e7d1717f68530c79b03a6", + "filename": "research/deferred-signed/swapnil-round7/lean/round5-histograms.json", + "status": "added", + "additions": 1, + "deletions": 0, + "changes": 1, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround5-histograms.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround5-histograms.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround5-histograms.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1 @@\n+{\"bit\": {\"a\": [15479, 1000000000], \"m\": 2209, \"W\": 13604709300, \"s\": 30052683193215, \"hist\": [[1, 308619300465], [3, 269071710], [5, 485704110], [7, 154755960], [9, 426259920], [11, 205054890], [13, 528381990], [15, 203530680], [17, 435405180], [19, 256878030], [21, 552769350], [23, 153231750], [25, 516188310], [27, 205054890], [29, 529906200], [31, 487033740], [33, 846941880], [35, 173046480], [37, 3069304920], [39, 973354020], [41, 385625130], [43, 804069420], [45, 1577557350], [47, 13083429480], [2023, 525852450], [2115, 13078856850]]}, \"cx\": {\"a\": [4079603, 250000000000], \"m\": 21952, \"W\": 2085111546336, \"s\": 45772350635112192, \"hist\": [[1, 3175994308032], [2, 1150092176688], [3, 437228850240], [4, 621103221648], [5, 530083636992], [6, 411085269504], [7, 297495918720], [8, 351328513536], [9, 182103562368], [10, 272253840768], [11, 137929925952], [12, 244629219744], [13, 156861484416], [14, 239799740544], [15, 146043451008], [16, 251229507984], [17, 136126920384], [18, 265041818496], [19, 156861484416], [20, 240894422496], [21, 232587718272], [22, 213430784112], [23, 270450835200], [24, 201936623616], [25, 48681150336], [26, 313272217440], [27, 246110260032], [28, 2801097936], [729, 105475825728], [756, 311233104], [21141, 70317217152], [21168, 35469841680], [21896, 1007397164592], [21924, 971927322912]]}, \"kappa\": {\"beta\": [1, 1000], \"eps\": [4999922606197979, 5000000000000000], \"x\": [842123, 1], \"c1\": [842135, 1], \"kappa\": [309575208081, 20000000000000000], \"mc\": 21952}}\n\\ No newline at end of file" + }, + { + "sha": "d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3", + "filename": "research/deferred-signed/swapnil-round7/lean/round6-histograms.json", + "status": "added", + "additions": 1, + "deletions": 0, + "changes": 1, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround6-histograms.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround6-histograms.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround6-histograms.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1 @@\n+{\"bit\": {\"a\": [36667, 1000000000], \"m\": 529, \"W\": 148225616, \"s\": 78410006675, \"hist\": [[1, 2191713447], [3, 5667200], [5, 11716936], [7, 6970656], [9, 14731178], [11, 4445210], [13, 35572306], [15, 13905892], [17, 4562096], [19, 9740500], [21, 18900112], [23, 141952734], [439, 6272882], [483, 141952734]]}, \"cx\": {\"a\": [36926111, 500000000000], \"m\": 576, \"W\": 207387136, \"s\": 119453132304, \"hist\": [[1, 184811440], [2, 107199136], [3, 50583808], [4, 53478128], [5, 33031680], [6, 27611408], [7, 14767104], [8, 20195472], [9, 6217728], [10, 14119424], [11, 5051904], [12, 13742960], [13, 4663296], [14, 14864256], [15, 4849504], [16, 13014320], [17, 10196912], [18, 33371712], [19, 13601280], [20, 22774048], [22, 44038192], [23, 16479408], [24, 4048], [529, 8193152], [552, 199193984]]}, \"kappa\": {\"beta\": [1, 1000], \"eps\": [2499908335861049, 2500000000000000], \"x\": [14695, 1], \"c1\": [14694, 1], \"kappa\": [3666565558019, 100000000000000000], \"mc\": 576}}\n\\ No newline at end of file" + }, + { + "sha": "830484689b2a0801992ce6b6e884014bc9c933fe", + "filename": "research/deferred-signed/swapnil-round7/lean/round7-histograms.json", + "status": "added", + "additions": 1, + "deletions": 0, + "changes": 1, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround7-histograms.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround7-histograms.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Flean%2Fround7-histograms.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1 @@\n+{\"sides\": [[\"bit\", \"bit interchange, staircase entrance corner\"], [\"bitplain\", \"bit interchange, round-six entrance corner\"], [\"cx\", \"complex interchange (round six)\"]], \"kappas\": [[\"kappa\", \"bit\"], [\"kappaplain\", \"bitplain\"]], \"cx\": {\"a\": [36926111, 500000000000], \"m\": 576, \"W\": 207387136, \"s\": 119453132304, \"hist\": [[1, 184811440], [2, 107199136], [3, 50583808], [4, 53478128], [5, 33031680], [6, 27611408], [7, 14767104], [8, 20195472], [9, 6217728], [10, 14119424], [11, 5051904], [12, 13742960], [13, 4663296], [14, 14864256], [15, 4849504], [16, 13014320], [17, 10196912], [18, 33371712], [19, 13601280], [20, 22774048], [22, 44038192], [23, 16479408], [24, 4048], [529, 8193152], [552, 199193984]]}, \"bit\": {\"a\": [31987, 500000000], \"m\": 529, \"W\": 108516254, \"s\": 57403754177, \"hist\": [[1, 1690297301], [3, 1356586], [5, 354200], [7, 3580962], [9, 1526602], [11, 5093396], [13, 2164162], [15, 7948248], [17, 8476006], [18, 6272882], [19, 1639946], [21, 6906900], [23, 61280142], [439, 6272882], [483, 61280142], [485, 545468], [487, 173558], [489, 293986], [491, 580888], [493, 14168], [495, 322322], [497, 17710], [499, 1129898], [501, 127512], [503, 410872], [505, 99176], [507, 1186570], [509, 340032], [511, 322322], [513, 106260], [515, 1583274], [517, 626934], [519, 2854852], [521, 13711082], [523, 4629394], [525, 5653032], [527, 6233920]]}, \"kappa\": {\"beta\": [1, 1000], \"eps\": [9999360300924109, 10000000000000000], \"x\": [14695, 1], \"c1\": [14694, 1], \"kappa\": [1599247689723, 25000000000000000], \"mc\": 576}, \"bitplain\": {\"a\": [12599, 200000000], \"m\": 529, \"W\": 108516254, \"s\": 57403754177, \"hist\": [[1, 1803209177], [3, 1356586], [5, 354200], [7, 3580962], [9, 1526602], [11, 5093396], [13, 2164162], [15, 7948248], [17, 8476006], [19, 1639946], [21, 6906900], [23, 61280142], [439, 6272882], [483, 61280142], [485, 545468], [487, 173558], [489, 293986], [491, 580888], [493, 14168], [495, 322322], [497, 17710], [499, 1129898], [501, 127512], [503, 410872], [505, 99176], [507, 1186570], [509, 340032], [511, 322322], [513, 106260], [515, 1583274], [517, 626934], [519, 2854852], [521, 13711082], [523, 4629394], [525, 5653032], [527, 6233920]]}, \"kappaplain\": {\"beta\": [1, 1000], \"eps\": [9999370089681201, 10000000000000000], \"x\": [14695, 1], \"c1\": [14694, 1], \"kappa\": [6299103187973, 100000000000000000], \"mc\": 576}}\n\\ No newline at end of file" + }, + { + "sha": "65b9e9129a5c4ebe205c0c971f8559a571808b95", + "filename": "research/deferred-signed/swapnil-round7/notes/complex-source-frames.tex", + "status": "added", + "additions": 68, + "deletions": 0, + "changes": 68, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcomplex-source-frames.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcomplex-source-frames.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcomplex-source-frames.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,68 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Source frames for the complex interchange}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+This note moves the stage-two rank of every auxiliary role of the complex interchange into a single\n+child, by starting the role in a nonzero phase frame. It is the complex analogue of PR~\\#13's auxiliary\n+source frames on the bit side.\n+\n+\\paragraph{Phase frames.} For $\\phi:\\mathbb F_2^m\\to\\mathbb Z/4$ write $D_\\phi=H^{\\otimes m}\\operatorname{diag}(i^{\\phi})H^{\\otimes m}$.\n+All phase frames share the eigenbasis $H^{\\otimes m}$, so $D_\\psi D_\\phi^{-1}=D_{\\psi-\\phi}$. For a subspace $U$ let\n+$q_U(y)$ be the weight of the orthogonal projection of $y$ onto $U$ modulo $4$ when $U$ has an orthonormal basis;\n+the frame of a label $U$ is $D_{q_U}$.\n+\n+\\begin{lemma}[Auxiliary source frames]\\label{lem:src}\n+In the common-frame form of the complex interchange, route $w$ applies $\\epsilon_w D_{\\phi_{\\mathrm{sink}}(\\rho w)-\\phi_{\\mathrm{src}}(w)}$.\n+An auxiliary role ($\\rho(w)=w$, $\\epsilon_w=+1$) may start at $D_{q_{D_0}}$ provided its sink is $D_{\\mathrm{wt}+q_{D_0}}$.\n+Every gate, interior edge and other role is unchanged, and the network still restores arbitrary scratch.\n+\\end{lemma}\n+\\begin{proof}\n+The common-frame identity holds for any invertible frames, so the route operator is\n+$D_{\\mathrm{wt}+q_{D_0}-q_{D_0}}=D_{\\mathrm{wt}}=C^{\\otimes m}$, the same as with source $0$ and sink $D_{\\mathrm{wt}}$.\n+The logical scratch is $g=D_{-q_{D_0}}f$; since $f$ is arbitrary so is $g$, and the output is\n+$D_{\\mathrm{wt}+q_{D_0}}D_{-q_{D_0}}f=C^{\\otimes m}f$.\n+\\end{proof}\n+\n+\\begin{lemma}[Costs]\\label{lem:cost}\n+Suppose $D_0\\subseteq U$ and $D_0\\subseteq V$, where $U$ and $V$ are the role's first and last stage-two labels,\n+$U=D_0\\perp L_1$ and $V=D_0\\perp L_2$. Then the entrance edge costs $\\dim L_1$ and the exit edge to the sink costs\n+$m-\\dim L_2$. The exit residual $G=D_0\\perp V^\\perp$ has an orthonormal basis.\n+\\end{lemma}\n+\\begin{proof}\n+Weights of orthogonal parts add modulo $4$, because orthogonal parts overlap in an even number of coordinates.\n+So $q_U-q_{D_0}=q_{U\\cap D_0^\\perp}=q_{L_1}$, of rank $\\dim L_1$, and\n+$\\mathrm{wt}+q_{D_0}-q_V=q_{V^\\perp}+q_{D_0}=q_G$, of rank $m-\\dim L_2$. $G$ is an orthogonal sum of nondegenerate\n+spaces, so it is nondegenerate. It is nonalternating because $D_0$ contains an odd vector\n+($e_j\\otimes e_k\\otimes t_B$ with $j\\notin A$). A nondegenerate nonalternating space over $\\mathbb F_2$ has an orthonormal basis.\n+\\end{proof}\n+\n+So the exit is exactly the operator of an increasing edge $0\\to G$, and PR~\\#10's whole-residual child and its\n+$Z_B$ sign wrapper apply to it. Every stage-two label of the form $(B\\otimes F\\perp P\\otimes L)\\otimes Q$ contains\n+$D_0=B\\otimes F\\otimes Q$, so the hypothesis holds for every addition and piece role.\n+\n+\\begin{remark}[Excluded roles]\n+Retained roles end at $D_0$; a source frame would give them an exit of rank $m$, which is not a contraction, so\n+they keep source $0$. Input-pivot slots meet stage two first at the copy into the data frame, which is not a\n+frame above $D_0$; they also keep source $0$. The rank sum $s$ and the deficit are unchanged.\n+\\end{remark}\n+\n+\\paragraph{Effect.} For each affected role the stage-two entrance child (rank $h^2-h$) and exit child (rank $m-h^2$)\n+merge into one child of rank $m-h$. In \\texttt{independent/complex-network/fullbatch\\_hist.py} this is the\n+\\texttt{sf} option. For PR~\\#7's network at $h=28$ under full batching the certified saving rises from\n+$1048009/(2.5\\cdot10^{11})$ to $4079603/(2.5\\cdot10^{11})\\approx1.632\\cdot10^{-5}$; every child has width at most\n+$m-h\\le m-1$, so the topology-free guard is unchanged.\n+\n+\\paragraph{Checks.} On PR~\\#7's network at $h=8$ and $h=10$, every source-framed role has $D_0$ inside its first\n+and last stage-two labels (\\texttt{sourceframe\\_trace.py}, which traces every role through PR~\\#7's stage-two schedule), and the exact label and phase checks pass: entrance and exit phase identities, $G$\n+nondegenerate and nonalternating, ranks $m-h$ and $m-h+1$ (\\texttt{sourceframe\\_labels.py}). A full three-stage\n+scalar simulation of PR~\\#7's network with source frames (\\texttt{sourceframe\\_sim.py}), in the Hadamard domain\n+modulo $2^{64}-59$ with random gate phases, random data-endpoint phases and arbitrary scratch, restores scratch\n+and exchanges the data exactly at $h=8$. The same script runs a negative control (sink $\\mathrm{wt}$ alone, which\n+must fail to restore scratch) and a baseline without source frames.\n+\n+\\end{document}" + }, + { + "sha": "cdcc820c95c9aa984a703460a968421bb37189a0", + "filename": "research/deferred-signed/swapnil-round7/notes/copied-centres.tex", + "status": "added", + "additions": 58, + "deletions": 0, + "changes": 58, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcopied-centres.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcopied-centres.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fcopied-centres.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,58 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Copied centres in the two-stage interchange}\n+\\date{Draft, October 9, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+This note applies PR~\\#36's copied retained-centre schedule (icekylinx) to our two-stage bit interchange, where the\n+centres are direct centre wires rather than retained totals. In that setting the schedule is simpler: the original\n+centre never leaves its frame.\n+\n+\\paragraph{The central return.} In each stage a centre $c$ runs the dirty-scratch word $R\\,G\\,R\\,G$: the scatter $R$\n+reads $c$ at the frame $D_0$, and the gather $G$ acts at $D_1$. So the centre's frame path is\n+$D_0\\to D_1\\to D_0\\to D_1$, with ranks $h,h,h$ beyond its endpoint edge; this descent and re-ascent is the central-return\n+loss, and it is what makes the rank budget $s=Wm-N+2L$.\n+\n+\\begin{lemma}[Copied centres]\\label{lem:copy}\n+In either stage, replace the second scatter's reads of $c$ by reads of a temporary copy $t$: after the first gather,\n+copy $c$ into a fresh zero stream $t$ at $D_1$, move $t$ to $D_0$, let the second scatter read $t$, and erase $t$; the\n+original $c$ stays at $D_1$ for the final gather. The scalar action, the endpoints of every role and the restoration of\n+arbitrary scratch are unchanged. Each centre then has two children of width $h$ per stage instead of three, and the rank\n+budget becomes $s=Wm-N+L$.\n+\\end{lemma}\n+\\begin{proof}\n+The scatter reads do not change $c$, so after the first gather the second scatter sees the same value whether it reads\n+$c$ or a copy of it; the final gather therefore receives the same value at the same frame $D_1$. The copy is a fresh\n+zero stream, so erasing it touches no arbitrary scratch. The move of $t$ from $D_1$ to $D_0$ is the matrix of the old\n+return edge, an involution with the same projector ($I\\otimes P_t$ in stage one, $P_t\\otimes I$ in stage two), so the\n+flag basis compiles it to one run of width $h$, as before; the original's return and re-ascent, each of rank $h$, are\n+gone. Summing over the $c_0=h$ centres of the $2v$ invocations removes $L=2vhc_0$ from the rank budget.\n+\\end{proof}\n+\n+\\paragraph{Tape cost.} Making the copy is a pointwise gate on $(c,t)$ at the common frame $D_1$; the reads are pointwise\n+at $D_0$; erasure is linear in the stream volume $V/W$. The copy has the full role shape, so its child calls are ordinary\n+children of the batched recursion, and $F_k\\le(s/W)F_{k-1}+O(1)$ holds with the new $s$. The copy is a temporary, not a\n+role, so $W$ is unchanged. The schedule needs $W+1$ role tapes, and while the copy's children run it parks $W$ streams\n+instead of $W-1$; both are fixed. No row of the assembly certificate changes: the bit network enters only through\n+$\\tau=1-a_b$, and the crude guard depends only on the complex network.\n+\n+\\paragraph{Saving.} The deficit is now $Wm-s=N-L=v(v-2h^2)$, positive for much smaller $h$, and the optimum moves from\n+$h=47$ to $h=25$. With the flag basis, the gm side circuit ($R=52788$ at $h=25$), the side roles batched one level down\n+and the data-entrance run, \\texttt{scripts/certificate\\_round6.py} certifies $a_b=34919/10^9$.\n+\n+\\paragraph{Retained totals.} The direct centre wires can be replaced by retained point totals\n+$P_c=\\operatorname{star}(c)$, built as side roles from existing side nodes (each a disjoint union of three of them, two\n+additions). A total sits at $U_c$ of dimension $h-1$; its copy pays $U_c\\to D_0$ (rank $h-1$) and the original\n+$U_c\\to F$ (rank $1$), so the loss per centre is $h-1$ and the centre roles leave $W$. At $h=23$ this certifies\n+$a_b=36667/10^9$ (\\texttt{independent/two-stage-bit/rtgm.py}, \\texttt{cert\\_rt.py}); the scalar identity, frames,\n+side-edge genericity and nesting are checked as for direct centres.\n+\n+\\paragraph{Checks.} The full-stage word (all $h$ centres, all targets, real excluded sums) is checked over\n+$\\mathbb F_2$ at $h=5,\\dots,8$ and with signed Gaussian integers; a control that copies before the first gather fails.\n+The frame sequences of old and copied centres are checked exactly at $h=5,6$. At $h=25$ every flag-basis, side-lemma,\n+data-entrance and frame condition is checked at one integer point, as at $h=47$ in round five.\n+\n+\\end{document}" + }, + { + "sha": "76c91c10c96bbb0432f7f4996c5734e5eee0b956", + "filename": "research/deferred-signed/swapnil-round7/notes/data-edge-batching.tex", + "status": "added", + "additions": 39, + "deletions": 0, + "changes": 39, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdata-edge-batching.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdata-edge-batching.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdata-edge-batching.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,39 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\title{Data-edge batching in the two-stage interchange}\n+\\date{Draft}\n+\\begin{document}\n+\\maketitle\n+\n+\\paragraph{Setting.} The two-stage bit motif with partial-swap frames, $m=h^2$, $v=\\binom h3$, $N=v^2$, with\n+every auxiliary role's selected edge compiled by the partial-swap batching lemma\n+(\\texttt{partial-swap-batching.tex}). Write $P_a$ for the $G$-orthogonal projector onto $\\langle t_a\\rangle$ and\n+$Q_a=I-P_a$.\n+\n+\\begin{lemma}[Data entrances]\n+For every data pair, the stage-two entrance edges of the $X$ and $Y$ roles both have idempotent difference\n+$Q_1\\otimes Q_2$, of rank $(h-1)^2=m-2h+1$.\n+\\end{lemma}\n+\\begin{proof}\n+Since $t_1^\\perp\\otimes F\\perp t_1\\otimes t_2$ under $G\\otimes G$, the $X$ entrance is\n+$\\operatorname{proj}(D_0+t_1\\otimes t_2)-\\operatorname{proj}(F\\otimes t_2)=Q_1\\otimes I+P_1\\otimes P_2-I\\otimes P_2=Q_1\\otimes Q_2$.\n+The $Y$ entrance is $\\operatorname{proj}(D_0)-\\operatorname{proj}(t_1^\\perp\\otimes t_2)=Q_1\\otimes I-Q_1\\otimes P_2=Q_1\\otimes Q_2$.\n+\\end{proof}\n+\n+For $h\\ge4$, $(h-1)^2>m/2$, so the partial-swap batching lemma applies with $k=2h-1$ corner transpositions and\n+one aligned block of width $t=m-4h+2$. The common basis is the one already used for the auxiliary edges: each\n+data corner adds one nonzero polynomial condition $\\det(S^{-1}U)_L\\det(VS)_R$ on $S$, nonzero on the big cell\n+$S=L\\,U$ (unit lower times unit upper), so finitely many conditions have a common integral unimodular solution.\n+\n+\\paragraph{Accounting.} Per data role the ranks are $(h-1)+(m-2h+1)+(h-1)=m-1$; with one copy-correction child\n+of width $1$ per pair this reproduces $s=Wm-N+2L$, and $Wm-s=v(v-4h^2)>0$ for $h\\ge28$.\n+\n+\\paragraph{Saving.} With the side-role counts of our generator (valid for $28\\le h\\le50$), the batched moment\n+certifies $a_b=10033/10^9$ at $h=47$ ($R=418678$), against $10027/10^9$ at $h=46$ and $4431/10^9$ at $h=32$\n+without data batching.\n+\n+\\paragraph{Checks.} Corners invertible under one common $S_0$ for every auxiliary edge and every data pair at\n+$h=6,7,8$ (all $3136$ pairs at $h=8$); exact Bruhat profiles match; the closed form is checked in rationals.\n+\n+\\end{document}" + }, + { + "sha": "3b6dab87052c5c941a38e857d9caba60423c944a", + "filename": "research/deferred-signed/swapnil-round7/notes/deferred-readout.tex", + "status": "added", + "additions": 110, + "deletions": 0, + "changes": 110, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdeferred-readout.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdeferred-readout.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fdeferred-readout.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,110 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{proposition}{Proposition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Deferred readouts in the two-stage bit interchange}\n+\\date{Draft, October 9, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+This note describes the round-seven bit side. It keeps the round-six interchange (flag basis, retained point totals\n+with copied centres, side roles batched one level down, data-entrance run) and changes three things: the side\n+program comes from PR~\\#62's producer, its frames are lifted and its fan-out copies are made late, and the stage-one\n+word is reordered so that most slots read their garbage out at a nonzero frame. All objects are frozen in\n+\\texttt{certificates/round7/}; \\texttt{scripts/certificate\\_round7.py} rebuilds the child-width histogram from the\n+schedule, and the checks in \\texttt{independent/deferred-readout/} verify every fact used below. Throughout, $h=23$,\n+$m=h^2$, $v=\\binom h3$, $N=v^2$, $G=I-J/9$, and for a triple $T$ the root frame of the output wire $y_T$ is\n+$t_T^\\perp=\\ker\\,(9t_T-3\\mathbf 1)^{\\mathsf T}$; the frame of a retained total of $c$ is $U_c=\\ker(\\mathbf 1-3e_c)^{\\mathsf T}$.\n+\n+\\section{The side program: PR \\#62's producer}\n+The side DAG has the $v$ triples as leaves and disjoint additions as nodes; its roots are the $3v$ outputs\n+$\\mathrm{out}(c,T)=\\{S: S\\cap T=\\{c\\}\\}$ and the $h$ retained totals $\\mathrm{star}(c)$. We build it with PR~\\#62's\n+producer (ikeboy): interval strips and core-aware pair assembly, with PR~\\#41's alternating order and links\n+(RaD/hipotures), and links chosen by a moment-weighted matching in the spirit of PR~\\#44 (rohanarun). A link hands the\n+non-pivot slot of a donor gate to a later use of the same value, so the number of slots is\n+$R=\\#\\text{additions}+3v+h-\\#\\text{links}=28866$. Only the DAG enters the certificate, and it is checked from the\n+definitions: every addition is disjoint, every output and total has the support above, and every node is reachable\n+from a root (\\texttt{check\\_lifted.py}, part~A; \\texttt{check\\_word.py}, part~A).\n+\n+\\section{Lifted frames and late copies}\n+For an addition $n$ let $U_n$ be the common kernel of the root covectors reachable from $n$ and $F_j$ the span of\n+the first $j$ rows of a fixed integer flag matrix. The gate of $n$ acts at\n+\\[ M_n=\\operatorname{span}(n)+(U_n\\cap F_{j(n)}), \\]\n+with a lift index $j(n)$ per addition. This is Paureel's complement-frame construction: it is valid for any frames\n+with (H1) leaf frames $\\langle t_S\\rangle$, (H2) frames nested along every slot (DAG edges, links, copies),\n+(H3) roots inside $t_T^\\perp$ or $U_c$, (H4) $G$ nondegenerate on every frame. Nesting is a theorem given\n+$j(n)\\le j(t)$ on every slot successor pair, $\\operatorname{span}(x)\\le\\operatorname{span}(t)$ on every link and\n+$\\operatorname{span}(n)$ inside every root it reaches directly; then $U_n\\le U_t$ and $M_n\\le M_t$. In this witness\n+every lifted frame equals $U_n$. Dimensions are exact (modular law, ranks with Hadamard certificates or Bareiss).\n+\n+\\paragraph{Late copies.} A node with several free uses is copied for each of them. A copy made early sits at $M_n$;\n+a \\emph{late} copy for the user $\\ell_i$ of an ordered list $\\ell_1,\\dots,\\ell_k$ is made when the pivot has climbed to\n+\\[ C_i=\\textstyle\\bigcap_{i'\\ge i} M(\\ell_{i'}), \\qquad M_n\\le C_1\\le\\dots\\le C_{k-1}\\le M(\\ell_k), \\]\n+and starts there, so the copy saves the rank $\\dim C_i-\\dim M_n$. Each copy is placed as late as possible (before its\n+user's gate, the pivot's next gate and the next copy). The intersections are needed: without them consecutive pivot\n+frames are not nested (1396 of 1396), and a copy moved after the pivot's next gate breaks the replay.\n+\n+\\section{The B-defer word}\n+In stage one each slot $u$ starts with its garbage $z_u$, and the word reads it out of every target it reaches:\n+$y_T\\mathrel{-}=C_{T,u}z_u$, where $C=JL$ is given by the transpose sweep of $L$. In rounds five and six all these\n+readouts happen at frame $0$, before the second pass. B-defer splits the second pass in two phases.\n+\n+\\begin{itemize}\n+\\item \\emph{Phase 1} is the closure of the retained totals' last operations under per-slot sequence precedence: every\n+ op that must precede a total's completion. The totals complete, and their copies read every target containing\n+ their centre at $0$ (copied centres, as in round six).\n+\\item A slot that phase 1 neither reads nor writes still holds its garbage after phase 1. It reads it out\n+ \\emph{now}, at a frame $\\sigma_u\\le F_0(u)\\cap\\bigcap_{T}t_T^\\perp$ (over its targets $T$), then the rest of $L$ runs,\n+ then the output reads at $t_T^\\perp$, then $L^{-1}$ and $V^{-1}$ exactly mirror it.\n+\\end{itemize}\n+Only the topological order of the word changes, so it is still a mirror and still restores arbitrary scratch. The\n+slot's chain now starts at $\\sigma_u$: its corner has rank $r_u=h-\\dim\\sigma_u$ and its auxiliary edge rank $m-r_u$.\n+\n+\\paragraph{The sorting rule.} On a target $y_T$ the readout frames, in time order, are $0$ (non-deferred slots and\n+centre copies), the deferred $\\sigma_u$, and $t_T^\\perp$; they must form a chain. The word reads the deferred slots\n+in increasing $\\dim\\sigma_u$, and applies the deferred $V$ gates (below) in increasing $\\dim F_0$. With this rule\n+every $y_T$ sequence is nested in time order, exactly over $\\mathbb Q$, for both the $\\mathbb Z$ and the\n+$\\mathbb F_2$ supports of $C$; the reversed order breaks 11879 chains.\n+\n+\\section{V leaves as late copies on $X_S$}\n+A leaf $S$ is used by several gates. Instead of copying $x_S$ by fan-out, every use $i$ gets its own $V$ gate on the\n+data wire $X_S$, into a slot that starts at\n+\\[ s_i=N_i\\cap N_{i+1}\\cap\\cdots \\qquad(\\text{falling back to }\\langle t_S\\rangle\\text{ if $G$ is degenerate on it}), \\]\n+where $N_j$ is the first frame of use $j$. The $V$ gates are then late copies on $X_S$: its frame chain\n+$\\langle t_S\\rangle\\le s_{i_1}\\le s_{i_2}\\le\\dots\\le F$ has total rank $h-1$, as before, and the use slots start at\n+$s_i$ instead of $\\langle t_S\\rangle$. The $V$ gates of deferred slots come after their readouts; in time the $X_S$ chain\n+is $\\langle t_S\\rangle$, the early $V$ frames (by dimension), the deferred $V$ frames (by the rule above), $F$, and it\n+is checked nested exactly in that order. The number of slots is unchanged.\n+\n+\\section{What the certificate uses}\n+\\paragraph{Only the $\\mathbb F_2$ flag identity.} The bit network is used over $\\mathbb F_2$: the word must add exactly\n+$x_T$ to every $y_T$ and restore every slot, for arbitrary scratch. The replay checks this over $\\mathbb F_2$ with\n+the parity coefficients (the actual circuit) and, separately, over $\\mathbb Z$ with the exact path-count\n+coefficients; the histogram and $a_b$ are the same with either support.\n+\n+\\paragraph{The stage-two complement.} Stage two is the complement time-reversal of stage one, with the same edge\n+multiset. This is the same assumption as in round six; it is stated, not machine-checked here.\n+\n+\\paragraph{Frames and genericity.} Every $\\sigma_u$ and $s_i$ is a primitive integer basis (entries at most 13).\n+Exactly over $\\mathbb Q$: $\\sigma_u\\le F_0(u)$, $\\sigma_u\\le t_T^\\perp$, $t_S\\le s_i\\le N_i$, $G$ nondegenerate. Every\n+high-rank step ($2r>h$) that the reordered word adds (slot starts, gauged corners $\\sigma_u\\to F$, $y_T$ and $X_S$\n+chain steps) has the generic north-east pivots under both conjugations at the integer point of\n+\\texttt{check\\_lifted.py}, so the side lemma batches it.\n+\n+\\section{Accounting}\n+Per stage and invocation: every slot contributes its auxiliary edge (block $m-2r_u$) and its corner, both batched\n+by the inner lemma, and its chain steps; every centre copy its step $U_c\\to0$ of rank $h-1$; every $y_T$ and every\n+$X_S$ its chain of total rank $h-1$; the data entrance its block $m-4h+2$ and corner; one copy-correction singleton per\n+pair. The rank sum is exactly $s=Wm-N+L$ with $W=2N+2vR$, $L=2vh(h-1)$, so the histogram re-partitions the round-six\n+budget. The moment certificate gives\n+\\begin{align*}\n+ a_b&=31987/(5\\cdot10^8) &&\\text{(staircase entrance corner, runs $h-2,h-5,1^6$)},\\\\\n+ a_b&=12599/(2\\cdot10^8) &&\\text{(round-six entrance corner)},\n+\\end{align*}\n+and with round six's complex interchange ($a_c=36926111/(5\\cdot10^{11})$, $h=24$) the assembly gives\n+$\\kappa=1599247689723/(2.5\\cdot10^{16})\\approx6.39699\\times10^{-5}$ with the staircase corner and\n+$\\kappa=6299103187973/10^{17}$ with the round-six corner. The staircase corner is certified by\n+\\texttt{check\\_stair.py} at the same integer point; the entrance edge is not changed by the reordering.\n+\n+\\end{document}" + }, + { + "sha": "331789a6f16c5aef87a37eedef147a3146450b86", + "filename": "research/deferred-signed/swapnil-round7/notes/fine-field-lemma.tex", + "status": "added", + "additions": 308, + "deletions": 0, + "changes": 308, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Ffine-field-lemma.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Ffine-field-lemma.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Ffine-field-lemma.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,308 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{claim}{Claim}\n+\\theoremstyle{definition}\\newtheorem{definition}{Definition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Idea A made precise: line passes on the fine field of one axis}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+This replaces the paragraph ``Idea A'' of \\texttt{notes/stack-notes.tex}. It refers to the\n+pinned upstream sections \\texttt{02-streams.tex} (machine model,\n+Lemma~elementary-streams and its counter paragraph) and \\texttt{07-resampling.tex}\n+(lem:tensor-resampling), to \\texttt{notes/segmented-inverse.tex} and to PR~\\#5's\n+chirped-correlation blocks. A machine-level simulation of every data movement below is\n+\\texttt{scripts/check\\_fine\\_field.py}; it checks outputs against the linewise maps\n+and checks the movement bounds of Lemma~\\ref{lem:fine} case by case.\n+\n+\\section{Setting}\n+\n+Fix an axis $i$ of the padded box. Its box length is $n=t_i\\in\\{r/2,r\\}$, a power of two.\n+Collapse the address fields before axis $i$ to one field $X$ and those after it to one\n+field $Y$ (upstream's collapsing convention). An entry is a record of $b=O(p)$ bits.\n+Movement is counted in records; a record move costs $b$ head steps. Put\n+$V=|X|\\,n\\,|Y|$ (records), choose $f$ with $2^f\\mid n$, write the axis coordinate as\n+\\[ j=J2^f+u,\\qquad 0\\le u<2^f,\\quad 0\\le J1-1/\\sigma-W2^{-f}$, a positive fraction of $J$ since $\\theta$ is small.\n+For $(s,t,2^f,W)=(1009,1024,64,8)$, 6 of 16 slabs fail (\\texttt{scripts/check\\_fine\\_field.py}). Anchoring at the\n+lowest input, as above, keeps three slabs.\n+\\end{remark}\n+\n+\\subsection{Virtual slabs and the wrap splice}\n+For an X-group, the \\emph{extended array} holds virtual slabs $v=v_{\\rm lo},\\dots,v_{\\rm hi}$ in\n+order $(v,Y,u)$, where entry $(v,Y,u)$ is $\\tilde x_{v2^f+u}$ of line $(X,Y)$. Here\n+$v_{\\rm lo}=J'(0)=\\lfloor-W/2^f\\rfloor=-1$ and $v_{\\rm hi}=\\max\\{J'(J)+2: J2^fn_\\pi$: the virtual range maps to one physical interval of length $2^f$\n+starting at $v2^f+u\\bmod\\pi$, which meets two consecutive slabs, split at the shift $\\rho$.\n+\\end{itemize}\n+When $\\rho=0$ (the input period of $B_0$ is $t_i$) every virtual row is an aligned copy.\n+\\end{claim}\n+\\begin{proof}\n+$[v2^f,(v+1)2^f)$ has length $2^f<\\pi$ and lies in $[-\\pi,2\\pi)$, so it contains at most one\n+multiple of $\\pi$. If none, its image mod $\\pi$ is one interval of length $2^f$, which meets at\n+most two slabs, each in an increasing run. If it contains $\\pi$ it is $v=n_\\pi$, its part below\n+$\\pi$ is $[n_\\pi2^f,\\pi)$ inside slab $n_\\pi$, and its part above maps to $[0,2^f-\\rho)$ inside\n+slab~$0$. It cannot contain $0$ unless $v=0$, where the range starts at $0$.\n+\\end{proof}\n+\n+\\paragraph{Building it.} Tape IN holds the array; first copy the X-group to tape CP ($G$ reads,\n+$G$ writes, one return). For each $v$ park IN at row $(a_v,0)$ and CP at row $(b_v,0)$. For\n+$Y=0,\\dots,|Y|-1$ read the two runs in $u$ order, each head finishing its slab row, and write\n+every value to E0, E1, E2 in the same step. Each head advances exactly $2^f$ per $Y$, so $B$ per\n+virtual slab. A single head would pay $|Y|2^f$ per row to jump between the two physical slabs,\n+i.e.\\ $\\Theta(|Y|B)$ per spliced slab; the second head is what makes the splice linear. The\n+sequence of $a_v$ is $n_\\pi-1$ (for $v=-1$), $0,1,\\dots,n_\\pi$, then small indices again, so IN\n+seeks across the group at most four times and CP at most twice.\n+\n+\\subsection{Forward schedule}\\label{sec:fwd}\n+Tapes: IN, CP, E0, E1, E2, OUT, ST (state), VB (validity bitmap over $Y$), AX (auxiliary rows),\n+FIN (final states), BUF (window buffer), DJ (per-slab data), descriptor and counter tapes.\n+\n+\\emph{Validity.} VB holds $\\prod_h[y_h<\\text{bound}_h]$ over $Y$ in $Y$ order. Build it from the\n+innermost $Y$ axis outward: the bitmap for axes $h..$ is the concatenation over digit values of\n+copies of the bitmap for axes $h+1..$, or of zeros above the bound. Each level costs twice its\n+size and sizes at least double, so building costs at most $2|Y|$ per tape. $X$-validity is\n+computed once per group by an odometer, $O(L)$ against a group of $G\\ge n$ records.\n+\n+For each $X$ in order:\n+\\begin{enumerate}\n+\\item If $X$ is invalid, advance IN by $G$ and write $n_sB$ zeros to OUT, $n_s|Y|\\xi$ to AX and\n+$|Y|\\Sigma$ to FIN.\n+\\item Otherwise build the extended array and write $|Y|\\Sigma$ zero states to ST.\n+\\item For $J=0,\\dots,n_s-1$: if $J2^f\\ge m$ write a zero slab and zero auxiliary rows. Otherwise\n+seek E$r$ to row $(J'(J)+r,0)$ for $r=0,1,2$, and ST, VB to their starts. For each $Y$:\n+read the VB bit; copy $2^f$ records from each of E0, E1, E2 into BUF, which then holds\n+$\\tilde x$ on $[J'2^f,(J'+3)2^f)$; read the $\\Sigma$-record state. If valid, run $K_J$ with\n+$D_J$, step ST back $\\Sigma$ and write the new state. Write the $2^f$ outputs (zeros if invalid\n+or $k\\ge m$) to OUT and the $\\xi$-record auxiliary row to AX.\n+\\item Copy ST to FIN.\n+\\end{enumerate}\n+\n+\\emph{Invariant.} At the start of $(J,Y)$, head E$r$ is at row $(J'(J)+r,Y)$, ST at record $Y$,\n+VB at bit $Y$, and OUT, AX at position $(X,J,Y)$ of slab order. It holds at $Y=0$ by the seeks,\n+and each step advances E$r$ by one row, ST by $\\Sigma$, VB by one, OUT by $2^f$ and AX by $\\xi$.\n+\n+\\emph{Correctness.} By induction on $J$, state record $Y$ of group $X$ equals the linewise\n+state of line $(X,Y)$ after slabs $0..J-1$: only step $(J,Y)$ touches record $Y$, and the slabs\n+of each line are visited in increasing $J$. By Claims~\\ref{cl:window} and \\ref{cl:splice}, BUF\n+contains the exact values the linewise kernel reads, so outputs, states and auxiliary rows\n+agree. Invalid lines keep a zero state and get zero outputs, as the linewise rule writes. No\n+padded box entry $j\\in[\\pi,n)$ is read (Claim~\\ref{cl:splice}), and every output position is\n+written once, so the box keeps its full size and slab order.\n+\n+\\emph{Movement per valid group.} IN: $\\le6G+n_eB$ (entering the group, copy, return, four\n+cross-group seeks, the build reads). CP: $\\le3G+n_eB$. Each E$r$: $n_eB$ writes, a return\n+after the build and one at the next group, and in the main loop $B$ per slab plus a re-seek of\n+at most $B$ (head ends at $J'+r+1$, needs $J'(J+1)+r\\in[J'+r,J'+r+2]$), so $\\le3n_eB+2n_sB$.\n+OUT: $G$, plus one final return of $V$ in total. ST: $4|Y|\\Sigma$ per slab and $4|Y|\\Sigma$ at\n+the ends. VB: $2|Y|$ per slab. AX: $|Y|\\xi$ per slab plus a final return. Summing with\n+$G=n_sB$:\n+\\[\n+ |X|B(16n_s+11n_e)+V+\\tfrac{4\\Sigma+2\\xi+2}{2^f}V+4|X||Y|\\Sigma ,\n+\\]\n+which is the bound in (b). Invalid groups cost less.\n+\n+\\subsection{Backward schedule}\\label{sec:bwd}\n+Input is the forward output Z (slab order), AX and FIN. For each valid $X$: copy its $|Y|\\Sigma$\n+final states from FIN to ST; for $J$ from $\\lfloor(m-1)/2^f\\rfloor$ down to $0$, seek Z and the\n+output tape to slab $(X,J)$ and AX to row $(X,J,0)$; for each $Y$ read the slab row into BUF and\n+its auxiliary row, read the state, run the backward kernel over $u$ \\emph{decreasing} inside\n+BUF, write the new state, and write the $2^f$ outputs in increasing $u$. Lines are independent,\n+so visiting $Y$ in increasing order inside a decreasing-$J$ sweep is legitimate; only the order\n+along each line matters. Invariant and induction are as in the forward case with $J$\n+descending, and AX row $(X,J,Y)$ is read at the position where it was written.\n+\n+Movement: Z and the output each read or write $B$ and seek back $2B$ per slab, plus entering\n+the group ($\\le2G$): $\\le5G$ each, and one final return of the output ($V$). AX:\n+$3|Y|\\xi$ per slab. ST: $\\le4|Y|\\Sigma$ per slab plus loading. VB: $2|Y|$ per slab. This gives\n+(c). If a backward-type kernel needs neighbouring slabs (the second $M^{-1}$ after the backward\n+solve), use the three-tape window of Section~\\ref{sec:fwd} with $J$ descending: $J'$ is\n+non-increasing with steps at most $2$, and the forward bound applies.\n+\n+\\subsection{Per-slab data and setup}\n+$D_J$ consists of $J'(J)$, the centres $c(k)$ and fractional offsets for $k$ in slab $J$, the\n+block boundaries and $q$-counters, the list of wraps in slab $J$, and (for Woodbury) the\n+elimination factors of the wraps in slab $J$. None depends on $X$ or $Y$. They are produced once\n+per axis by incrementing the $q$-counters along $J$, $O(2^fp)$ bit operations per slab, and stored\n+on DJ in $J$ order; DJ is swept once per X-group. Since it is read once per group and not per\n+line, the total is $|X|\\cdot|D|$, with $|D|$ the size of all $D_J$ (bounded in\n+Section~\\ref{sec:instances}). This replaces the notes' per-chunk odometer test, which is no\n+longer needed: validity is one VB bit per slab row. A block of the line algorithm that\n+straddles a slab boundary is recomputed from BUF by both slabs; with blocks of length at most\n+$W\\le2^f/4$, at most two partial blocks occur per slab row, so kernel work is at most\n+$(1+2W/2^f)\\le3/2$ times linewise.\n+\n+\\subsection{Instances and the conditions (W1)--(W3)}\\label{sec:instances}\n+\\begin{itemize}\n+\\item $\\mathsf S'$, $A$, $B_0$, $E$: windowed, no state ($\\Sigma=\\xi=0$). $W=3m+3$ for\n+$\\mathsf S'$ (notes), the halo of $E$.\n+\\item $M^{-1}$ via PR~\\#5's chirped correlation: each segment block has length at most\n+$\\lambda=\\lfloor1/\\theta\\rfloor+1$ and reads a halo $w$; take $W\\ge\\lambda+2w$ so every segment\n+meeting slab $J$ lies in BUF and is recomputed there. No state. The segment crossing the period\n+boundary (``stitched from the two line ends'' in \\texttt{segmented-inverse.tex}) is read through\n+$\\tilde x$, i.e.\\ through the halo slabs $v=-1$ and $v\\ge n_\\pi$; no separate stitching.\n+\\item Woodbury. $N$ is the same matrix on every line of axis $i$, so $C=I+V^{\\mathsf T}M^{-1}U$\n+and all its elimination factors are line-independent and live in $D_J$: $O(w^2)$ words of\n+precision $P$ per wrap, $|D|=O((\\theta n+1)w^2P/b)$ records per axis, read once per group, a\n+fraction $O(\\theta w^2P/b)$ of $V$ even when $|Y|=1$. Per line only right-hand sides are\n+carried. Forward sweep: the state is the running reduced right-hand side of the current block\n+row ($2w$ words) and the cyclic-border accumulator for the last block row ($2w$ words), so\n+$\\Sigma=4wP/b$; the auxiliary row stores the reduced right-hand side of each wrap in the slab,\n+$\\xi=(\\lceil\\theta2^f\\rceil+1)\\,2wP/b$. After slab $n_s-1$ every line of the group solves its\n+last $2w\\times2w$ border system (factor in $D$) for $x_{\\rm last}$, kept in FIN. Backward sweep:\n+state $(x_{k+1},x_{\\rm last})$, $4w$ words; it reads the auxiliary rows in reverse.\n+\\item Conditions. With the recentred sub-blocks $P\\le2Q+O(\\log s)=O(b)$. Then (W3) needs\n+$2^f\\ge C w$ and $\\theta w\\le c$; with $\\alpha^2\\approx Q/(48d)$, $w=O(\\sqrt d)$ and\n+$\\theta\\approx1/(4dL^y)$, so $\\theta w\\to0$, and (W1) with $W\\ge\\lambda+2w=\\Theta(dL^y)$ gives\n+$2^f=\\Theta(dL^y)$, $f=O(\\log L)$. (W2) holds since $s_i\\ge\\tfrac45 t_i\\ge r/4\\gg2^f$.\n+\\end{itemize}\n+\n+\\subsection{Total}\n+Per axis: exposure and restoration $12fVb$; each forward-type pass at most $28Vb$ and each\n+backward-type pass at most $11Vb$ up to the terms $11|X|(n_e-n_s)B=O(V2^f/n)$,\n+$O(V(\\Sigma+\\xi)/2^f)$ and $O(|X||Y|\\Sigma)$, all $O(V)$ by (W3) and $o(V)$ as $n_s\\to\\infty$;\n+the setup terms above are $o(Vb)$. Over $d$ axes this is $O(Vb\\,d(\\log L+P))$, as the notes\n+claim. \\qed\n+\n+\\section{Changes to the notes' paragraph}\n+\\begin{enumerate}\n+\\item The centred window $J'-1..J'+1$ with $J'=\\lfloor J/\\sigma\\rfloor$ misses inputs; anchor\n+$J'$ at the lowest input read and use $J',J'+1,J'+2$ (Claim~\\ref{cl:window}), with\n+$2^f\\ge4W+4$. $J'$ moves by $0$, $1$ or $2$ per slab (2 occurs for $B_0$).\n+\\item The wrap splice needs two heads advancing in lockstep over $Y$ (Claim~\\ref{cl:splice});\n+copying ``the boundary slabs'' with one head costs $\\Theta(|Y|)$ per record. The tail splice\n+pairs slab $n_\\pi$ with slab~$0$, and the halo slabs pair consecutive slabs shifted by\n+$\\pi\\bmod2^f$. (W2) $\\pi\\ge3\\cdot2^f$ keeps every virtual slab on at most two physical slabs.\n+\\item Per-line state for all $|Y|$ interleaved lines is an array in $Y$ order on its own tape,\n+swept once per slab; auxiliary data for the backward sweep is an array in $(X,J,Y)$ order. Both\n+must fit in a slab row, which is (W3), and this is what lower-bounds $2^f$ besides the window.\n+\\item The Woodbury factors are line-independent; only right-hand sides are per line. Storing\n+factors per line (as ``per-line state'' suggests) would cost $\\Theta(w^2)$ per wrap per line and\n+violate (W3) when $\\theta w^2P/b$ is not small.\n+\\item Per-chunk validity by an odometer over $Y$ is replaced by a precomputed bitmap read in\n+lockstep; the hypothesis ``chunk volume $\\gg\\ell^2$'' is not needed.\n+\\end{enumerate}\n+\n+\\section{Machine check}\n+\\texttt{scripts/check\\_fine\\_field.py} represents every array as a tape with one head and counts every head\n+step. It runs exposure, a forward pass (windowed periodic map with $k$-dependent weights, a\n+two-word recurrence state, sparse wrap records to AX), a backward pass seeded from FIN that\n+reads AX in reverse, and restoration, for twelve shapes: $s\\in\\{13,29,53,61,103,107,127\\}$\n+(prime, so $s\\bmod2^f\\ne0$), $2^f\\in\\{4,8,16\\}$, $|Y|\\in\\{1,\\dots,32\\}$ with invalid $Y$\n+coordinates, $|X|\\in\\{2,3,4\\}$ with invalid groups, and expansion, compression and $s\\to s$\n+maps. All outputs equal the linewise maps; every case satisfies the bounds (a)--(c). Measured\n+forward $12.8$--$25.8\\,V$, backward $3.8$--$9.6\\,V$, exposure exactly $6V$ per bit; on longer\n+lines ($n=256$--$1024$, $2^f=16$--$64$) forward $18.4$--$21.3\\,V$ and backward $9.0$--$11.3\\,V$,\n+independent of $|Y|\\in\\{1,16,64\\}$.\n+\\end{document}" + }, + { + "sha": "5647021edd381d28fbb44ced0f8f7bcfcdeaa72f", + "filename": "research/deferred-signed/swapnil-round7/notes/flag-basis.tex", + "status": "added", + "additions": 88, + "deletions": 0, + "changes": 88, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fflag-basis.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fflag-basis.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fflag-basis.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,88 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{proposition}{Proposition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{A common flag basis for the two-stage interchange}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+The partial-swap batching lemma (\\texttt{partial-swap-batching.tex}) compiles an edge of rank $a>m/2$ into\n+$m-a$ corner transpositions and one aligned block, after one unimodular change of basis $S_0$. A generic $S_0$\n+puts every corner in the open Bruhat cell, so the corner transpositions are reversed and each costs one\n+singleton call. This note gives one rational basis in which the corners of every auxiliary and centre edge of\n+the two-stage motif are lower triangular, so their transpositions form one contiguous run.\n+\n+\\paragraph{Runs.} For an idempotent $p$ of any rank, the lower--lower Bruhat involution of $S_p$ is exactly\n+$\\{H_i\\leftrightarrow D_j:(i,j)\\text{ a rightmost pivot of }p\\}$: the rank function of the blocks of rows $1..i$ and\n+columns $j..2m$ of $S_p$ is that of $p$ on the $H\\times D$ part and that of the identity elsewhere, for the $H$ rows\n+and the $D$ rows alike. In particular $S_p$ has exactly $\\operatorname{rank}p$ transpositions, with no condition on\n+$\\operatorname{rank}p$. A maximal run of pivots\n+$(i,j),(i+1,j+1),\\dots,(i+w-1,j+w-1)$ is one interchange of the contiguous chunks $H_{[i,i+w)}$ and $D_{[j,j+w)}$:\n+the aligned case is PR~\\#10's middle block, and shifted runs are already PR~\\#10's corner block.\n+An edge of rank $r\\le m/2$ is one child exactly when its $r\\times r$ block (first $r$ rows, last $r$ columns) is\n+lower triangular with nonzero diagonal; an edge of rank $r>m/2$ compiles to two children (the corner run and the\n+aligned middle block of width $2r-m$) exactly when its $(m-r)\\times(m-r)$ corner is lower triangular with nonzero\n+diagonal. These are closed conditions, so they must hold through the structure of the basis.\n+\n+\\paragraph{Construction.} Write $F=\\mathbb Q^h$ with the dot product, and let $U,V\\in GL_h(\\mathbb Q)$ be generic.\n+For $0\\le\\betah/2$, the edges $\\pi\\otimes P_b$ and $P_b\\otimes\\pi$ compile to $h-r$\n+singletons and one block of width $2r-h$;\n+\\item every data-entrance corner (size $2h-1$) is nonsingular.\n+\\end{itemize}\n+\\end{proposition}\n+\\begin{proof}\n+The first two items are Lemma~\\ref{lem:flag}. For the third, the block of $\\pi\\otimes P_b$ is\n+$A_b\\pi A_b^{-1}C_b$ with $A_b=\\tilde A_bU^{\\mathsf T}$, so its Bruhat permutation is that of the $h\\times h$ idempotent\n+$A_b\\pi A_b^{-1}$, and the partial-swap lemma applies one level down, with a nonzero-polynomial corner condition in $U$\n+(in $V$ for the other stage). For the fourth, nonsingularity reduces to four intersection conditions\n+($\\lambda$ restricted to the null space has rank $h$; the null space meets $\\operatorname{span}\\mu$ trivially; the dual null\n+space restricted to $\\operatorname{span}\\mu$ has rank $h$; the dual span meets $\\operatorname{span}\\lambda$ trivially), each with an\n+explicit witness ($U^{\\mathsf T}t_1=V^{\\mathsf T}t_2=e_0$; $e_0,e_{h-2}$; $e_{h-1},e_{h-1}$; $e_{h-1},e_1$), followed by the choice of $W$.\n+The motif has finitely many edge classes, so the product of all these nonzero polynomials is nonzero on the\n+irreducible parameter space, and a rational point avoids its zero set.\n+\\end{proof}\n+\n+\\paragraph{Saving.} With the global-matching side circuit (\\texttt{independent/two-stage-bit/gmside.py}, $R=403248$\n+at $h=47$) and the profiles above, with every side-role edge charged by its factor rank through the third item\\n(the side chains come from \\texttt{side\\_chains.py}), the batched moment certifies $a_b=15479/10^9$ at $h=47$.\n+\n+\\paragraph{Checks.} \\texttt{flagbasis.py} builds $S$ exactly (with generic coefficients; the statements are\n+Zariski-open, so small coefficient ranges can hit the closed exceptional set) and computes the full Bruhat profile of every edge class\n+modulo $2^{61}-1$ (and exactly over $\\mathbb Q$ for a sample at $h=6$): all auxiliary lines in both stages, all centre\n+edges and sampled data pairs at $h=6,7,8$ match the proposition. At the working dimensions, \\texttt{flag\\_existence.py 47} (and \\texttt{46}) evaluates every\n+nonvanishing condition at one integer point modulo $2^{61}-1$: the corner diagonal factors and inner corners on every\n+line, and both data-entrance factors on sampled pairs (the family is invariant under $GL_h\\times GL_h$, which acts\n+transitively on the pairs, so one nonzero value per condition suffices). A nonzero value modulo $p$ at an integer\n+point shows the polynomial is not identically zero. Negative controls: a dense generic basis gives\n+singleton corners; PR~\\#16's nested basis merges the stage-two class only.\n+\n+\\end{document}" + }, + { + "sha": "319f6447632924760047f4a49d0f070a3094de37", + "filename": "research/deferred-signed/swapnil-round7/notes/partial-swap-batching.tex", + "status": "added", + "additions": 110, + "deletions": 0, + "changes": 110, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fpartial-swap-batching.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fpartial-swap-batching.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fpartial-swap-batching.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,110 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{proposition}{Proposition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Batched recursion for partial-swap frames}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+\\paragraph{Setting.} In the two-stage bit motif (Paureel's fork of \\texttt{CrocSwap/integer-mult-bounds},\n+\\texttt{notes/two-stage-construction.tex} and \\texttt{notes/direct-swap-transfer.tex}), frames are partial\n+swaps\n+\\[\n+ S_p=\\begin{pmatrix}I-p&p\\\\p&I-p\\end{pmatrix}\n+\\]\n+on the paired fields $(H,D)$, where $p$ is an idempotent of rank $a$ in $m$ coordinates. A frame change\n+along an edge is a partial swap $S_{V\\ominus U}$. In the recursion each lower--lower Bruhat transposition is\n+one recursive interchange call. Batched recursion (\\texttt{CrocSwap/integer-mult-bounds} PR~\\#10,\n+\\texttt{notes/projector-batching.tex}) charges an order-preserving run of $t$ aligned transpositions as a\n+single interchange of width $tb$. Below we show that the same batching applies to partial-swap frames.\n+\n+\\begin{lemma}[Partial-swap factorization]\\label{lem:psbatch}\n+Let $p$ be an idempotent of rank $a$ with $m/22^{-18},\n+\\]\n+from four components. It points to where each one is proved or checked.\n+\n+\\section{Components}\n+\n+\\paragraph{The stack.} Ideas A--E (\\texttt{stack-notes.tex}, \\texttt{segmented-inverse.tex},\n+\\texttt{fine-field-lemma.tex}) drive $\\epsilon$ toward $1$. The binding row is then the simultaneous\n+butterflies, $\\epsilon(1-\\lambda')$, with $\\lambda'>\\max(\\tau,\\sigma,\\chi,\\text{leaf})$. The reservations force\n+$\\epsilon<1/(2-\\lambda')$, so the supremum of $\\kappa$ is $\\min(a_b,(1-\\beta)a_c)/(1+\\cdot)$.\n+\n+\\paragraph{Bit side: the batched two-stage interchange.} This is the two-stage bit motif with partial-swap\n+frames, with the batched recursion extended to partial-swap frames (\\texttt{partial-swap-batching.tex},\n+its Lemma~1). At $h=32$, $m=1024$, it certifies $a_b=22157/(5\\cdot10^9)\\approx4.43\\cdot10^{-6}$.\n+This side does not bind.\n+\n+\\paragraph{Complex side: PR~\\#7's network, fully batched.} PR~\\#7's complex network at $h=28$\n+($m=21952$), evaluated under PR~\\#15's full batching: every nonzero residual edge, of every rank, is one\n+whole-residual child call. We rebuilt the residual histogram from our own producer, labels and role\n+compilation (\\texttt{independent/complex-network/fullbatch\\_hist.py}) and certified the saving by exact\n+bisection on the moment equation with certified upper bounds on $\\ln$\n+(\\texttt{fullbatch\\_cert.py}). This gives $a_c\\ge1048009/(2.5\\cdot10^{11})\\approx4.192\\cdot10^{-6}$ (PR~\\#15 reports\n+$4191487/10^{12}$ from its own labels), and this side binds.\n+\n+\\paragraph{Guard.} The coefficient-depth guard needs no path-topology assumption. Every child call of the\n+batched recursion acts on at most $(m-1)/m$ of its parent's axes, and a node has at most $s_c$ children in\n+sequence. So the dependency depth is at most $d^{C_1}$ with $C_1=1+m_c\\ln s_c$, and Idea~D takes $x$ with\n+$\\epsilon C_1<1+x$ (\\texttt{scripts/certificate\\_round3.py}, guard mode \\texttt{crude}). Any finite $C_1$\n+gives the same $\\kappa$, since $x$ does not enter it; with $x\\approx8.4\\cdot10^5$ the packed-product and\n+record-regime rows hold for sufficiently large $L$. The witness is stated with this guard only.\n+\n+\\section{Certificate}\n+\n+\\texttt{scripts/certificate\\_round3.py} evaluates the rows and constraints exactly for any pair $(a_b,a_c)$.\n+With $a_b=22157/(5\\cdot10^9)$, $a_c=1048009/(2.5\\cdot10^{11})$, $\\beta=1/1000$ and the crude guard:\n+\\begin{itemize}\n+\\item every constraint is strict;\n+\\item the binding row is the simultaneous butterflies;\n+\\item $\\kappa=13086957581/(3.125\\cdot10^{15})$.\n+\\end{itemize}\n+\\texttt{independent/complex-network/fullbatch\\_hist.py 28} followed by \\texttt{fullbatch\\_cert.py}\n+recomputes $a_c$ and $\\kappa$. Our histogram differs from PR~\\#15's in the smallest ranks, with the same total\n+$s_c$, and certifies at least its value.\n+\n+\\section{What this rests on}\n+\n+\\begin{itemize}\n+\\item The pinned upstream manuscript and its interfaces.\n+\\item Colkitt's compact controls.\n+\\item PR~\\#5's chirped correlation, with PR~\\#10's correction of its Gaussian input error.\n+\\item PR~\\#7's ternary producer and complex network.\n+\\item PR~\\#10's batched recursion and controlled projector basis; we checked its edge forms and found basis witnesses at $h=8$ to $14$.\n+\\item PR~\\#13's third whole-residual class and PR~\\#15's full batching of every residual rank, with an orthonormal residual basis on every edge.\n+\\item Paureel's two-stage motif.\n+\\end{itemize}\n+Our own components:\n+\\begin{itemize}\n+\\item Ideas A--E;\n+\\item the partial-swap batching lemma;\n+\\item an independent rebuild and certification of the fully batched complex saving;\n+\\item the topology-free guard.\n+\\end{itemize}\n+\n+\\end{document}" + }, + { + "sha": "09ad215ccf3876d604fbbea1f25e772cd63e875b", + "filename": "research/deferred-signed/swapnil-round7/notes/segmented-inverse.tex", + "status": "added", + "additions": 316, + "deletions": 0, + "changes": 316, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fsegmented-inverse.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fsegmented-inverse.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fsegmented-inverse.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,316 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{proposition}{Proposition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Segmented inversion of the Gaussian correction and large-coefficient precision}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+\\section*{Setting}\n+This uses PR~\\#5's chirped-correlation lemma for the correlations and its parameter conventions. PR~\\#5 is unmerged on \\texttt{CrocSwap/integer-mult-bounds}.\n+\n+Keep the notation of the one-dimensional resampling lemma:\n+$2\\le s0$, and set $p=6b'$. Then $T\\in[4n/b',8n/b')$,\n+the volume is $Tp=\\Theta(n)$, and the address length is $\\log_2T=b-(1+x)\\log_2b+O(1)$.\n+Choose $d=\\lfloor b^\\epsilon\\rfloor$ and $r$, $\\ell$ from $T$ as before.\n+The capacity bound becomes $c_j<2^{3b'}$, and the final error bound becomes\n+\\[\n+ 2^{2b'+4}S\\cdot28\\cdot2^\\gamma T^2L\\cdot2^{-6b'}<448\\,b'\\,2^{-b'+\\gamma}<\\tfrac12\n+ \\quad\\text{whenever }\\gamma\\le b'/4 .\n+\\]\n+With $\\alpha^2=\\lfloor b'/(8d)\\rfloor$ we have $\\gamma=2d\\alpha^2\\le b'/4$, and with\n+$\\theta\\approx1/(4dL^y)$, $\\alpha^2\\theta\\ge b'/(32d^2L^y)\\ge1$ once $2\\epsilon+y<1+x$. All uses of\n+$r\\ge2^{a_rp/d}$ in the layer and transform proofs only need $r$ to outgrow every fixed\n+power of $p$. Here $r=2^{\\Theta(b^{1-\\epsilon})}$ and $p=\\Theta(b^{1+x})$, so that still holds.\n+\n+\\paragraph{Cutoffs.} Every ``for large $L$'' in this note and in the stack notes is asymptotic only: with $\\epsilon=0.9999$ the axis width is $\\ell=L^{10^{-4}}$, and conditions such as $\\ell-1>3G$ or $\\lambda^2\\le s/p$ hold only for astronomically large $L$. This is enough for the $O(\\cdot)$ statement and gives no concrete range.\n+\n+\\section{Gaussian row}\n+\n+With whole segments as blocks, $w^2=O(d)$ and the oversampling $\\theta\\approx1/(4d)$ give\n+$\\theta w^3=O(d^{1/2})$ coupling work per output. With the recentred sub-blocks and reduced\n+oversampling of the next section, the coupling work is $O(1)$ per output. The Gaussian row is\n+then $O(d\\,p^\\delta)$, with exponent $\\epsilon+(1+x)\\delta$ measured in powers of $\\log n$. This\n+is the row used in the certificate.\n+\n+\\section{Sub-blocks with recentred chirps}\n+\n+\\begin{lemma}[Recentred blocks]\\label{lem:recentred}\n+Let $\\ell,j$ and a centre $c$ lie in one segment. Put $u=\\ell-c$, $v=j-c$ and $h=j-\\ell$. Then\n+\\[\n+ X_{\\ell,j}=\\sigma h^2+2\\beta_ch+\\theta(v^2-u^2).\n+\\]\n+Hence the principal block of $N$ on any run of consecutive indices inside a segment\n+starting at $c$ equals $D_cT_cD_c^{-1}$, with $D_c=\\operatorname{diag}(e^{\\pi\\alpha^2\\theta u^2})$ and\n+$T_c$ the Toeplitz matrix with symbol $e^{-\\pi\\alpha^2(\\sigma h^2+2\\beta_ch)}$.\n+\\end{lemma}\n+\\begin{proof}\n+In a segment $\\beta_\\ell=\\beta_c+\\theta u$ and $\\beta_j=\\beta_c+\\theta v$. Expand\n+$X=(\\sigma h+\\beta_\\ell)^2-\\beta_j^2$, use $\\sigma-\\theta=1$ and $2hu=v^2-u^2-h^2$.\n+\\end{proof}\n+This was checked in exact rational arithmetic for three centres per pair on all five test cases.\n+\n+\\paragraph{One Toeplitz inverse serves all blocks.} For $b\\in[-1/2,1/2]$ let $T^{(b)}$ be the\n+$\\lambda\\times\\lambda$ Toeplitz matrix with symbol $e^{-\\pi\\alpha^2(\\sigma h^2+2bh)}$, so\n+$T_c=T^{(\\beta_c)}$ and $T_\\lambda=T^{(-1/2)}$. With $\\rho_c=e^{-\\pi\\alpha^2(2\\beta_c+1)}\\in(0,1]$\n+and $G_c=\\operatorname{diag}(\\rho_c^{-i})$ we have $T_c=G_cT_\\lambda G_c^{-1}$, so\n+$(T_c^{-1})_{ab}=\\rho_c^{\\,b-a}(T_\\lambda^{-1})_{ab}$.\n+\n+\\begin{lemma}[Envelope]\\label{lem:envelope}\n+Let $|b|\\le1/2$, $\\alpha^2\\ge4$, $\\alpha^2\\theta\\ge1$, $\\mu_\\pm=e^{-\\pi\\alpha^2(\\sigma\\pm2b)}\\le e^{-\\pi\\alpha^2\\theta}$\n+and $c_\\pm=2\\mu_\\pm\\le2e^{-\\pi}$. Then\n+$|(T^{(b)})^{-1}_{ij}|\\le\\mathcal E(j-i)$, where $\\mathcal E(0)=1.12$,\n+$\\mathcal E(h)=2.0001\\,c_+^{h}$ for $h>0$ and $\\mathcal E(h)=2.0001\\,c_-^{|h|}$ for $h<0$.\n+\\end{lemma}\n+\\begin{proof}\n+$\\|T^{(b)}-I\\|_\\infty\\le\\mu_++\\mu_-+\\sum_{|h|\\ge2}e^{-\\pi\\alpha^2(\\sigma h^2-|h|)}<0.087$, which gives\n+the bound $1/(1-0.087)<1.12$ for every entry. For $h=j-i>0$ conjugate by $R=\\operatorname{diag}(c_+^{\\,i})$:\n+$RT^{(b)}R^{-1}$ has entries $t_hc_+^{-h}$, whose off-diagonal row sums are at most\n+$\\tfrac12+\\sum_{h\\ge2}2^{-h}e^{-\\pi\\alpha^2\\sigma h(h-1)}+\\sum_{m\\ge1}2^{m}e^{-\\pi\\alpha^2\\sigma m(m+1)}<\\tfrac12+10^{-10}$.\n+So $\\|(RT^{(b)}R^{-1})^{-1}\\|_\\infty<2.0001$ and $|(T^{(b)})^{-1}_{ij}|\\le2.0001\\,c_+^{h}$. The case\n+$h<0$ is the same with $R=\\operatorname{diag}(c_-^{-i})$.\n+\\end{proof}\n+\n+\\emph{Gohberg--Semencul vectors.} Put $x_c=T_c^{-1}e_0$, $y_c=T_c^{-1}e_{\\lambda-1}$, $J$ the\n+reversal and $Z$ the down shift. Then\n+$T_c^{-1}=x_{c,0}^{-1}\\bigl(L(x_c)U(Jy_c)-L(Zy_c)U(ZJx_c)\\bigr)$, with $x_{c,0}\\in[0.9,1.1]$.\n+Every entry of the four vectors is an entry of $T_c^{-1}$, so Lemma~\\ref{lem:envelope} bounds it,\n+and each triangular factor has $\\infty$-norm at most $\\sum_h\\mathcal E(h)\\le1.31$.\n+The partial products need no cancellation: for all $a,b$,\n+\\[\n+ \\sum_k|x_{c,a-k}(Jy_c)_{b-k}|\\le1.13\\,\\mathcal E(b-a),\\qquad\n+ \\sum_k|(Zy_c)_{a-k}(ZJx_c)_{b-k}|\\le4c_+c_-\\,\\mathcal E(b-a)\\le16e^{-2\\pi\\alpha^2}\\mathcal E(b-a),\n+\\]\n+because the second sum is dominated by $|(T_c^{-1})_{a-1,\\lambda-1}(T_c^{-1})_{\\lambda-b,0}|$. So\n+$L(Zy_c)U(ZJx_c)$ is a correction of relative size $e^{-2\\pi\\alpha^2}$ to $L(x_c)U(Jy_c)$, and both obey the envelope of $T_c^{-1}$ itself.\n+\n+\\emph{Rescaling.} The vectors of $T_c$ are those of $T_\\lambda$ rescaled by $G_c$ as whole\n+\\emph{columns}: $x_{c,i}=\\rho_c^{-i}x_i$ and $y_{c,i}=\\rho_c^{\\lambda-1-i}y_i$. Conjugating each\n+triangular factor by $G_c$ separately gives the same product, but moves a factor $\\rho_c^{\\mp\\lambda}$\n+into $L(Zy)$ and $U(ZJx)$. That factor is up to $2^{9.06\\alpha^2\\lambda}$, which a fixed-point\n+correlation would have to carry as extra bits. Under the parameters of the last section\n+$9.06\\alpha^2\\lambda\\approx1.23\\,QL^{y/2}$, which is not $O(p)$, so the column rescaling is required.\n+\n+\\emph{Storage in two frames.} Store $x^+=(T^{(1/2)})^{-1}e_0$ and $y=T_\\lambda^{-1}e_{\\lambda-1}$,\n+both bounded by Lemma~\\ref{lem:envelope}, in fixed point with absolute precision $2^{-P}$. Then\n+\\[\n+ x_{c,i}=r_c^{\\,i}x^+_i,\\quad r_c=e^{-\\pi\\alpha^2(1-2\\beta_c)}\\le1,\\qquad\n+ y_{c,i}=\\rho_c^{\\,\\lambda-1-i}y_i,\\quad\\rho_c\\le1 .\n+\\]\n+Every rescaling factor is at most $1$, so it only contracts stored errors. Storing $T_\\lambda$'s\n+own $x$ in fixed point instead loses $\\min(2^{-P},|x_i|)$, which $\\rho_c^{-i}$ amplifies by up to\n+$2^{9.06\\alpha^2 i}$. Storing it in floating point avoids that loss, but the setup then needs absolute\n+precision $P+9.06\\alpha^2\\lambda$.\n+\n+\\emph{Error.} Form $r_c^{\\,i}$ and $\\rho_c^{\\,i}$ by repeated multiplication in fixed point, so\n+every vector entry has error at most $(\\lambda+1)2^{-P}$. Let the four correlations round to\n+$2^{-P}$. Then for $\\|z\\|_\\infty\\le1$, the computed $T_c^{-1}z$ is within\n+$7(\\lambda+1)^22^{-P}$. Applying $M_c^{-1}=D_cT_c^{-1}D_c^{-1}$ scales the input by\n+$D_c^{-1}\\le1$ and the output by at most $2^{R_D}$, with $R_D=4.53\\,\\alpha^2\\theta(\\lambda-1)^2\\le Q$.\n+The block error is therefore at most $7(\\lambda+1)^22^{R_D-P}\\|v\\|_\\infty$. Corner entries for\n+the capacitance are single entries of the same form, with error at most $7(\\lambda+1)2^{-P}$.\n+Hence\n+\\[\n+ P=2Q+2\\log_2(\\lambda+1)+\\log_2s+8=O(p)\n+\\]\n+suffices, with $\\lambda=O(dL^{y/2})$ under the parameters of the last section.\n+\n+\\paragraph{Cuts.} Cut every segment into near-equal blocks of length between $2w$ and\n+$\\lambda$, and treat each cut like a wrap.\n+\\begin{itemize}\n+\\item Coupling entries across a cut have $n=h$ and $X=h(h+2\\beta_j)\\ge|h|(|h|-1)$, which is\n+at least $2\\theta$ for $h=\\pm1$. So they are at most $e^{-2\\pi\\alpha^2\\theta}\\le e^{-2\\pi}$, and\n+only entries with $|h|\\le w$ matter.\n+\\item All block solves use principal blocks of $N=I+E$, hence $\\|M^{-1}\\|\\le2$.\n+\\item With $\\|\\Delta\\|\\le e^{-2\\pi\\alpha^2\\theta}+2.01e^{-2\\pi\\alpha^2}$, we get\n+$\\|C-I\\|\\le\\|M^{-1}\\|\\|\\Delta\\|<0.005$. Also $C^{-1}=I-V^{\\mathsf T}N^{-1}U$ gives\n+$\\|C^{-1}\\|\\le1+\\|N^{-1}\\|\\|\\Delta\\|<1.01$.\n+\\item The capacitance is cyclic block tridiagonal, with one block per cut or wrap, because\n+every block has length at least $2w$. Eliminate without pivoting.\n+\\end{itemize}\n+\n+\\paragraph{Precision and cost.} Inside a block, the chirp $D_c$ spans at most\n+$e^{\\pi\\alpha^2\\theta\\lambda^2}$, that is $4.53\\,\\alpha^2\\theta\\lambda^2$ bits. Choose\n+\\[\n+ \\lambda=\\Bigl\\lfloor\\sqrt{Q/(4.53\\,\\alpha^2\\theta)}\\Bigr\\rfloor,\n+\\]\n+so that the $D_c$ precision reserve is at most $Q$. The working precision is $P=2Q+O(\\log s)=O(p)$. Couplings occur with density\n+$1/\\lambda+\\theta$ per output, each costing $O(w^3)$ with $w^2=O(Q/\\alpha^2)$.\n+\n+\\paragraph{Replaced hypothesis.} Upstream's resampling lemma assumes $\\theta>p/\\alpha^4$, which is used only\n+to get $\\alpha^2\\theta>1$ and to bound its Neumann count. Here the Neumann series is gone, so that\n+hypothesis is replaced by $\\alpha^2\\theta\\ge1$. PR~\\#5's lemmas, which assume the hypotheses of the\n+upstream lemma, are used under this replacement. Every remaining use of $\\alpha^2\\theta\\ge1$ is\n+$\\|N-I\\|<2.01e^{-\\pi\\alpha^2\\theta/2}<0.42$.\n+\n+\\paragraph{Reduced oversampling.} Take $\\theta_i\\approx\\eta=1/(4dL^y)$ in prime selection\n+(Section~1 of the stack notes), so the padding factor is $\\prod_i(1+\\theta_i)=1+o(1)$.\n+Take $\\alpha^2=\\lfloor Q/(48d)\\rfloor$ with $Q=\\Theta(p)$. Then $\\gamma=2d\\alpha^2\\le b'/4$, and\n+$\\alpha^2\\theta\\ge1$ once $Q\\ge192\\,d^2L^y$, which holds when $2\\epsilon+y<1+x$. This gives\n+$w^2=O(d)$ and $\\lambda=\\Theta(dL^{y/2})$, so the coupling costs\n+$O(w^3(1/\\lambda+\\theta))=O(d^{1/2}L^{-y/2}+d^{1/2}L^{-y})=O(1)$ per output for $y=\\epsilon$.\n+Including the $O(1)$ chirped correlations, each axis costs $O(p^{1+\\delta})$ per output. The\n+Gaussian row is therefore $O(d\\,p^\\delta)$: exponent $\\epsilon+(1+x)\\delta$.\n+\n+\n+\\paragraph{Tape schedule and setup.} Process one line in increasing index order.\n+\\begin{itemize}\n+\\item For each block, compute $\\beta_c$ from the counters that already generate $q_j$, in $O(p)$\n+time.\n+\\item Form $r_c^{\\,i}$ and $\\rho_c^{\\,i}$ for $0\\le i\\le\\lambda$ by repeated multiplication in\n+fixed point at precision $P$. Both are at most $1$. That is $2\\lambda$ products, so\n+$O(P^{1+\\delta})$ per output.\n+\\item Rescale the two stored vectors $x^+$ and $y$ into the four Gohberg--Semencul vectors of\n+$T_c$, and apply the four triangular Toeplitz products as correlations of length $\\lambda$ in\n+fixed point. Each block uses the packed multiplication of the chirped-correlation lemma, at\n+$O(\\lambda P^{1+\\delta})$ per block.\n+\\item Write the block's corner entries ($O(w^2)$ numbers) to a capacitance tape in index order.\n+\\item The cyclic block-tridiagonal solve makes one forward sweep and one backward sweep over\n+that tape, reading fixed-width records in each direction. The single cyclic border is carried\n+on a separate work tape.\n+\\item A second pass applies $M^{-1}$ to $Uz$, which is supported near cuts and wraps, and then\n+subtracts.\n+\\end{itemize}\n+All passes move the line tape $O(1)$ times, so the line costs $O(sP)$ in movement. Arithmetic\n+costs $O(s(1+w^3(1/\\lambda+\\theta))P^{1+\\delta})$. Setup solves $T^{(1/2)}x^+=e_0$ and\n+$T_\\lambda y=e_{\\lambda-1}$, and the same for $\\lambda'$ (the final short block of each segment),\n+once per line at precision $P+O(\\log\\lambda)$. The Neumann iteration $x\\leftarrow e+(I-T)x$\n+contracts by $0.087$ per step, so $O(P)$ steps of $O(\\lambda^2)$ operations suffice, in\n+$O(\\lambda^2P^{2+\\delta})$. This is negligible when $\\lambda^2P\\le s$, which holds for large $L$.\n+No step needs more than $P$ bits.\n+\n+\n+\\paragraph{Numerical check.} \\texttt{scripts/check\\_subblock\\_inverse.py} cuts the\n+segments of the $(60,67)$, $\\alpha^2=9$ instance into blocks of length $2$ and $3$, solves each\n+block by its own recentred Toeplitz system at $120$ digits, couples all cuts and wraps by\n+Woodbury, and matches the direct solve to $3\\cdot10^{-64}$, against a target of $2^{-200}$.\n+\\texttt{scripts/check\\_reuse\\_inverse.py} checks a dense stored inverse of $T_\\lambda$ rescaled per block, with a fixed-point negative control. \\texttt{scripts/check\\_gs\\_path.py} tests this path itself: two stored vectors per block\n+length in fixed point, contracting rescales, four fixed-point triangular products per block,\n+and Woodbury coupling. On $(241,256)$ with $\\alpha^2=17,24$ and $(113,128)$ with $\\alpha^2=8$, at\n+$P=Q+R_D+2\\log_2\\lambda+8$ bits, it matches the direct solve to $2.1\\cdot10^{-49}$,\n+$3.6\\cdot10^{-50}$ and $2.8\\cdot10^{-35}$, against targets $7.0\\cdot10^{-46}$ and $7.9\\cdot10^{-31}$.\n+It fails as predicted in two negative controls. Dropping the reserve $R_D$ from $P$ gives\n+errors of $10^{-26}$ to $1$. Storing $T_\\lambda$'s vectors in fixed point gives\n+$4.7\\cdot10^{-10}$ and $1.1\\cdot10^{-13}$ on $(241,256)$.\n+\n+\\end{document}" + }, + { + "sha": "2c77009e0119100371d9546519f9fa06e5fe814f", + "filename": "research/deferred-signed/swapnil-round7/notes/stack-notes.tex", + "status": "added", + "additions": 204, + "deletions": 0, + "changes": 204, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fstack-notes.tex", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fstack-notes.tex", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fnotes%2Fstack-notes.tex?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,204 @@\n+\\documentclass[11pt]{article}\n+\\usepackage{amsmath,amssymb,amsthm}\n+\\newtheorem{lemma}{Lemma}\n+\\newtheorem{proposition}{Proposition}\n+\\theoremstyle{remark}\\newtheorem*{remark}{Remark}\n+\\title{Layout and precision changes beyond the $a_b/2$ ceiling}\n+\\date{Draft, October 8, 2026}\n+\\begin{document}\n+\\maketitle\n+\n+\\paragraph{Conditional status.} Every statement here assumes the pinned upstream interfaces and these unmerged results on \\texttt{CrocSwap/integer-mult-bounds}: PR~\\#5's chirped-correlation Gaussian lemma and its choice of $\\alpha$; PR~\\#3's compressed complex network; and PR~\\#7's networks, with $a_b=3/(4\\cdot10^8)$, $a_c=39/10^9$, $m=21952$ and $s=45772350635112192$. These are the round-two values; the round-three savings, and the further results they assume, are in \\texttt{round3-combination.tex}; the round-four savings are in \\texttt{data-edge-batching.tex}, \\texttt{complex-source-frames.tex} and \\texttt{scripts/certificate\\_round4.py}.\n+\n+\\paragraph{Deliberate departures from upstream hypotheses.} The prime-interval condition $1-2\\epsilon>0$ is replaced by the prime number theorem (Section~1). The resampling hypothesis $\\theta>p/\\alpha^4$ is replaced by $\\alpha^2\\theta\\ge1$, and the oversampling is reduced to $\\theta\\approx1/(4dL^y)$ (\\texttt{segmented-inverse.tex}). The band $r\\ge2^{a_rp/d}$ is replaced by $r\\ge2^{p^\\mu}$ (Section~1). $K=o(\\ell)$ is dropped (Section~2). The guard exponent uses the certified bound $\\log_ms<3.8376$ in place of~5; the witness also passes with~5.\n+\n+Throughout, $L=\\log_2T$ is the address length, $p$ is the coefficient precision,\n+$d=\\Theta(L^\\epsilon)$ is the number of axes and $\\ell=\\Theta(L^{1-\\epsilon})$ is the axis\n+width. Costs are divided by the logical volume $V=\\Theta(Tp)$ and expressed as powers\n+of $L$. Section and lemma names refer to the pinned upstream source\n+(\\texttt{upstream/build/sections}), to Colkitt's compact-control notes\n+(\\texttt{notes/compact-control-*.tex}), and to PR~\\#5 (\\texttt{notes/fast-gaussian-resampling.tex}).\n+\n+\\section{Idea D: coefficients longer than $\\log n$}\n+\n+\\paragraph{Scope.} Idea~D removes only the precision part of the $\\epsilon<1/2$ wall. On its own it does not move $\\kappa$. PR~\\#5's Gaussian row, $d^2p^\\delta$, comes from about $1/\\theta\\approx4d$ Neumann terms per axis, and it still caps $\\epsilon<1/2$ whatever the precision. Going past $\\epsilon=1/2$ needs Idea~D together with Idea~B$'$ (\\texttt{segmented-inverse.tex}). PR~\\#5's chirped correlation is required: upstream's direct Gaussian windows cost $\\sqrt d\\,p^{1+\\delta}$ per bit once $p\\gg L$.\n+\n+\\paragraph{Change.} Upstream splits each input into $b=\\lceil\\log_2n\\rceil$-bit digits and\n+sets $p=6b$. Instead use $b'=\\lceil b^{1+x}\\rceil$-bit digits for a fixed rational $x>0$,\n+still with $p=6b'$. Then $T\\in[4n/b',8n/b')$, so $Tp=\\Theta(n)$, and\n+$L=b-(1+x)\\log_2b+O(1)$. Set $d=\\lfloor b^\\epsilon\\rfloor$ and choose $r,\\ell$ from $T$ as\n+upstream does.\n+\n+\\paragraph{Consequences to check.}\n+\\begin{enumerate}\n+\\item \\emph{Capacity and rounding} (\\texttt{08-assembly.tex}, eq.~capacity and\n+eq.~final-error). The coefficients satisfy $c_j\\le q(2^{b'}-1)^2<2^{3b'}$, since $q\\le2^{b'}$.\n+The final error is $2^{2b'+4}S\\cdot28\\cdot2^\\gamma T^2L\\cdot2^{-6b'}<448\\,b'\\,2^{-b'+\\gamma}$,\n+using $S\\le T<2^{b'}$ and $L0$.\n+\\item \\emph{Address bound.} $\\log_2(2M)\\le C_Mp$ only becomes easier.\n+\\item \\emph{Chunk-exchange row.} Upstream writes it as $pK^{\\tau-1}$ by counting $O(p/K)$ exchanges from $d\\ell=O(p)$. The true count is $d\\ell/K=L/K$, so the row is $LK^{\\tau-1}$. Idea~C makes it zero.\n+\\item \\emph{Guard.} The coefficient-depth bound $\\Delta=C_0d^{C_1}$ must be $O(p)$. That needs\n+$\\epsilon C_1<1+x$, measured in powers of $b$.\n+\\item \\emph{Prime selection} (\\texttt{08-assembly.tex} 120--160). The cited explicit interval\n+lemma needs $\\log x>8d$, which fails for $\\epsilon\\ge1/2$. Replace it with the prime number theorem. Each interval has length $\\eta x=x/(4dL^y)=x/(\\log x)^{O(1)}$, so the classical prime number theorem with error term $O(x\\exp(-c\\sqrt{\\log x}))$ already gives more than $d$ primes in each interval for every fixed $\\epsilon<1$, with effective constants. The machine only needs existence; it scans and tests by trial division in $n^{o(1)}$ time, since the log of the scan length is $O(\\log p+L/d)=o(L)$.\n+\\item \\emph{Per-bit costs.} Every row whose cost grows with precision carries only a factor\n+$p^\\delta=b^{(1+x)\\delta}$. The pointwise products cost $\\log(rp)=\\Theta(\\ell+\\log p)$ per bit.\n+\\end{enumerate}\n+\n+\\section{Idea C: one chunk per axis}\n+\n+\\paragraph{Change.} Upstream takes $K=\\lfloor d^c\\rfloor$ because the layer cost had a factor\n+$K^\\tau$. Colkitt's compact controls removed that factor. Set $K=\\ell-1$ instead. In the\n+transform-layout lemma (\\texttt{06-transforms.tex}, lem:synthetic-transform-cost), this gives\n+$b=(\\ell-1)\\bmod K=0$ and $q=1$. The target chunk order then equals the source order, so the\n+procedure performs no chunk exchanges. The prefix holds only the top slot of each long axis.\n+\n+\\paragraph{Cost.} The layout costs $O(V d)$ and the rounds cost\n+$O(V\\ell d^{\\lambda'})$. The rows $dK$ and $pK^{\\tau-1}$ become $d$ and $0$.\n+\n+\\paragraph{Layer hypotheses to recheck} (\\texttt{notes/compact-control-layout.tex}).\n+\\begin{itemize}\n+\\item $K/\\log p\\to\\infty$ and $K\\ge G+4\\ell_p+10$ hold.\n+\\item The reservation count is $q_F+q_B\\le3dG/K+2=O(d^2\\log p/L)+2$. In powers of $d$ this has\n+exponent $(2\\epsilon-1)/\\epsilon$, which must stay below $\\lambda'$, that is $\\epsilon<1/(2-\\lambda')$. Upstream's guard implied this, but Idea~D's relaxed guard does not, so the certificate checks it separately.\n+\\item The simultaneous-layer proposition fixes $K=\\lfloor d^c\\rfloor$ (\\texttt{05-layers.tex} lines 21, 852 and 954--958). Restate it with $K$ supplied as input, in the band $\\tfrac12d^{(1-\\epsilon)/\\epsilon}\\le K\\le p$. Nothing else uses $K=o(\\ell)$: its only uses are $K\\le\\ell-1$ and the row $dK$.\n+\\item The bound $K\\ge d^c/2$ used in that note is replaced by $K\\ge\\tfrac12d^{(1-\\epsilon)/\\epsilon}$.\n+\\item The row index uses $q_0=O(\\log d)$ whole axes, unchanged.\n+\\end{itemize}\n+\n+\\section{Idea A: expose only the fine bits of an axis}\n+\n+The full statement and proof, with a 12-tape schedule, the corrected input window and the movement bounds, are in \\texttt{notes/fine-field-lemma.tex}. \\texttt{scripts/check\\_fine\\_field.py} simulates every data movement on explicit tapes and checks outputs and movement bounds. The summary below is superseded where it differs. In particular, a block reads input slabs $J',J'+1,J'+2$ with $J'=\\lfloor(c(J2^f)-W)/2^f\\rfloor$, the lowest input read, not $J'-1,J',J'+1$.\n+\n+\\paragraph{Change.} The tensor interface (\\texttt{07-resampling.tex}, lem:tensor-resampling)\n+makes each axis the innermost address field before running its line algorithm, at cost\n+$O(Tp\\,d^2(1+\\ell^\\tau))$ upstream and $O(Tp\\,d(1+\\ell^\\tau))$ with nonadjacent routing.\n+Instead, write the axis-$i$ coordinate as $j=J2^f+u$ with\n+$f=\\lceil\\log_2(c\\,W_{\\rm line})\\rceil$. Here $W_{\\rm line}$ is the largest window the line\n+algorithm reads: $3m+3$ for $\\mathsf S'$, a block length $\\lambda$ plus $2w$ for the inverse of\n+Idea~B$'$, and the periodic halo. Move only the $f$-bit field $u$ to the innermost address\n+position, leaving $J$ in place.\n+\n+\\paragraph{Execution.} The physical order becomes $(X,J,Y,u)$, where $X$ and $Y$ are the\n+fields of other axes before and after $J$. For fixed $X$, the records with a given $J$ form a\n+contiguous slab of $|Y|2^f$ records.\n+\\begin{itemize}\n+\\item Every block of the line algorithm reads inputs from at most three consecutive slabs,\n+$J'-1,J',J'+1$. The input slab index $J'$ is a non-decreasing function of the output slab\n+index $J$, roughly $J'=\\lfloor J/\\sigma\\rfloor$ for expansion, and the identity for $N$.\n+\\item Keep three read heads on copies of the input array, offset by one slab, and advance them\n+in step with the output over $Y$ and $J$. When $J'$ repeats, the heads rewind at most three slabs per output slab, so the total movement is still $O(V)$. These are three tapes, each holding a copy; copying costs $O(V)$ per pass.\n+\\item The period $s_i$ is not a multiple of $2^f$. The wrap partner of slab~0 is the slab containing $s_i-1$, and the window must be spliced at $u=s_i\\bmod2^f$. For each $X$-group, copy the boundary slabs (about $3|Y|2^f$ records) to a scratch tape and splice from it, at $O(V)$ per pass. The same applies to every application of $E$, whose period is also $s_i$.\n+\\item \\emph{Per-chunk setup.} There are $T/2^f$ chunks and $2^f=\\Theta(W_{\\rm line})$, so upstream's argument that per-line setup is negligible does not apply directly. Compute the block offsets and $q$-counters once per $J$ and copy $O(p)$ bits per chunk. Run the validity test from an odometer over $Y$ with per-axis flags, at $O(\\ell)$ per chunk. Allow one extra partial block per chunk, at $O(mp^{1+\\delta})$. Each chunk has volume at least $cW_{\\rm line}p\\gg\\ell^2,p$, so all of this is $O(\\text{chunk volume}\\cdot p^\\delta)$.\n+\\item The backward sweep of Idea~B$'$'s cyclic block-tridiagonal solve carries state along the line. It uses one more tape for the previous output slab at the same $Y$, and reads fixed-width records right to left.\n+\\end{itemize}\n+\n+\\paragraph{Cost.} Exposing and restoring the fine field are two interchanges of $f$-bit\n+fields, $O(Vf^\\tau)$, or $O(Vf)$ by single-bit moves. Over all axes this gives\n+$O(Vd\\log L)$, with exponent $\\epsilon+o(1)$.\n+\n+\\section{Idea E$'$: reversing the CRT axis order by permuted selected-bit additions}\n+\n+\\paragraph{Problem.} The Chinese remainder layout (\\texttt{08-assembly.tex}, explicit\n+cyclic-convolution layout) reverses the order of the $d$ axes so that every target follows\n+its controls. With chunk interchanges this costs $O(Vd\\ell^\\tau)$, which is the row\n+$(1-\\tau)(1-\\epsilon)$ and caps $\\kappa$ at $a_b/2$.\n+\n+\\paragraph{Primitive.} Colkitt's Proposition~1 (\\texttt{artifacts/compact-control-note.pdf} in his repository,\n+compact-control selected-bit addition) toggles, for slots $x,y$ of $fK$ bits with selected\n+positions $j_i=\\rho+iK$, each $y_{j_i}$ by $x_{j_i}$ at cost $O(V((f\\log p)^\\tau+1))$.\n+\\begin{itemize}\n+\\item Every rotation offset in that construction is computed from fields that precede the\n+rotated field, by Lemma~1 of the note.\n+\\item Replacing the control $z_i=x_{j_i}$ of target segment $i$ by $x_{j_{\\pi^{-1}(i)}}$, for a\n+fixed permutation $\\pi$, changes only those offset formulas:\n+\\[\n+ \\sum_i2x_{j_{\\pi^{-1}(i)}}t_i2^{j_i},\\qquad\n+ \\sum_ix_{j_{\\pi^{-1}(i)}}(1-2t_i)2^{j_i},\\qquad\n+ \\sum_i\\bigl(y_{j_i}\\oplus x_{j_{\\pi^{-1}(i)}}\\bigr)B^i .\n+\\]\n+All three are still computable from preceding fields in polynomial time.\n+\\item The guards, the dirty temporaries $u,t,b$, and the repair argument do not depend on the\n+pairing. The bad-address predicate is a function of the same digits.\n+\\end{itemize}\n+So the permuted selected-bit addition $y_{j_{\\pi(i)}}\\mathrel{\\oplus}=x_{j_i}$ has the same cost. The four-update identity holds for any control bit that stays fixed during it, and $x$ is never written. The bad-address predicate reads only the $t,u$ digits and the guard bits $g_i$, which contain no selected bit, so the ideal map still preserves the bad set.\n+\n+\\paragraph{Reversal.} Let $x$ be axes $1,\\dots,d/2$ and $y$ axes $d/2+1,\\dots,d$, each a slot of\n+$f=d/2$ chunks with $K=\\ell-1$, after the top bits of the long axes are extracted (see the placement constraints below). Let $\\pi$ reverse the chunk order. For each level\n+$\\rho\\in[0,\\ell)$, three permuted additions $x\\oplus=\\pi^{-1}y$, $y\\oplus=\\pi x$,\n+$x\\oplus=\\pi^{-1}y$ exchange bit $\\rho$ of axis $i$ with bit $\\rho$ of axis $d+1-i$ for every\n+$i\\le d/2$. The temporaries are reserved from existing axes as in Colkitt's layout note. The\n+$O(d^2\\log p/L)$ reserved axes are reversed by single-bit moves at $O(V\\ell)$ each, so\n+$O(Vd\\log p)$ in total. Unequal widths $\\ell,\\ell-1$ cost $O(d)$ single-bit moves.\n+\n+\\paragraph{Placement constraints.} These fixes are needed.\n+\\begin{itemize}\n+\\item \\emph{Record regime.} Lemma~1 and the repair need record width beyond every power of $p$. At the CRT stage the records are single coefficients. Treat the innermost axis as the record suffix, keep it out of both slots, and move it by $\\ell$ single-bit moves at $O(V\\ell)$. The back field $b$ sits between $y$ and that suffix.\n+\\item \\emph{Equal-width chunks.} First extract the top bits of the long axes by $O(d)$ single-bit moves, then use $K=\\ell-1$. Alternatively, choose a long/short pattern that is symmetric under reversal.\n+\\item \\emph{Temporaries.} The fields $u,t$ (about $dG$ bits) before $x$ and $b$ after $y$ come from front and back axes excluded from the swap. Reverse the middle axes in place, then re-place the reserved axes and the record axis by single-bit moves, at $O(Vd\\log p+V\\ell)$.\n+\\end{itemize}\n+The certificate uses the better of this row and the pairwise-swap row $(1-\\tau)(1-\\epsilon)$.\n+\n+\\paragraph{Cost.} The reversal costs $O(V\\ell(d\\log p)^\\tau)$, an exponent of\n+$1-\\epsilon(1-\\tau)+o(1)$, so the margin is $\\epsilon(1-\\tau)$. This exceeds\n+$\\kappa<\\epsilon(1-\\lambda')$ because $\\lambda'>\\tau$.\n+\n+\\section{Resulting margins}\n+See \\texttt{certificate.py}. The rows are:\n+\\begin{itemize}\n+\\item prefix moves, $1-\\epsilon$;\n+\\item butterflies, $\\epsilon(1-\\lambda')$, which binds;\n+\\item fine exposures, $1-\\epsilon-o(1)$;\n+\\item the Gaussian maps with recentred sub-blocks (\\texttt{segmented-inverse.tex}, last section), $1-\\epsilon-o(1)$;\n+\\item chirps, $1-\\epsilon-o(1)$;\n+\\item pointwise products, $\\epsilon$;\n+\\item reserved axes, $1-\\epsilon-o(1)$;\n+\\item CRT reversal, $\\epsilon(1-\\tau)$.\n+\\end{itemize}\n+The side conditions are the guard $\\epsilon C_1<1+x$; precision $2\\epsilon+y<1+x$, where the oversampling is $\\theta\\approx1/(4dL^y)$; sub-block coupling $y\\ge\\epsilon$; and\n+$\\lambda'$ above $\\tau$, $\\sigma$, $\\chi$ and the leaf exponent.\n+\n+\n+\\appendix\n+\\section{Finite payload alphabets}\n+\n+The bit network of PR~\\#7 carries ternary payloads. The pinned interchange lemmas are stated for\n+bit arrays and pointwise bit gates (\\texttt{04-swap.tex}: the circuit transfer before\n+prop:power-interchange, its descriptor paragraph, and lem:chunk-swap). The witness needs their\n+versions for a fixed finite alphabet.\n+\n+\\begin{lemma}[Finite alphabet]\\label{lem:finite-alphabet}\n+Let $\\Sigma$ be a fixed finite alphabet. Replace ``bit array'' by ``$\\Sigma$-array'' and ``pointwise\n+bit gates'' by ``pointwise gates on $\\Sigma$'' in lem:elementary-streams, prop:power-interchange\n+and lem:chunk-swap. The statements still hold, with the same exponent $\\tau$ and constants that\n+depend on $|\\Sigma|$.\n+\\end{lemma}\n+\n+\\begin{proof}\n+Encode each symbol of $\\Sigma$ as a fixed-width record of $B_0=\\lceil\\log_2|\\Sigma|\\rceil$ bits.\n+This adds one innermost suffix field $[2^{B_0}]$, which lem:chunk-swap allows ($[B]$ in its\n+statement). Volumes change by the fixed factor $B_0$.\n+\\begin{itemize}\n+\\item Every operation other than a gate is an address permutation. It moves whole records and\n+never reads their contents, so it is unaffected.\n+\\item A pointwise gate on $\\Sigma$ is a fixed finite map applied to records at matching\n+addresses of a fixed number of aligned role streams. That is item~3 of lem:elementary-streams\n+with records of $B_0$ bits, so it costs $O(V)$.\n+\\item The frame identity in prop:power-interchange uses only that a common address permutation\n+commutes with every pointwise gate. That holds for any alphabet.\n+\\item The descriptor paragraph assumes a one-bit payload only to bound $V_j\\ge q^{2e_0}$. With\n+$B_0$-bit records the volume is larger by a factor $B_0$, so the bound still holds.\n+\\end{itemize}\n+The recursion, its rank count $s$, the role split and the depth-first schedule do not refer to\n+payload values, so the recurrence $F_k\\le(s/W)F_{k-1}+O(1)$ and the bound $O(Ve^\\tau)$ hold\n+unchanged.\n+\\end{proof}\n+\n+\\end{document}" + }, + { + "sha": "71c743a58a3d7027b865572f8bb2c5f6afe8c9db", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate.py", + "status": "added", + "additions": 91, + "deletions": 0, + "changes": 91, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,91 @@\n+\"\"\"Exact rational certificate for the conditional witness.\n+\n+Changes combined: A (expose only fine axis bits), B (segmented inverse of the Gaussian\n+correction with recentred sub-blocks and oversampling theta ~ 1/(4 d L^y)), C (one chunk\n+per axis, K = l - 1), D (digits of (log n)^(1+x) bits), E (CRT axis reversal by permuted\n+selected-bit additions).\n+\n+Costs are powers of L = log2 T ~ log n, with precision p = Theta(L^(1+x)),\n+d = Theta(L^eps) axes and axis width l = Theta(L^(1-eps)). Fixed powers of log L are\n+absorbed by the strict gap between the minimum margin and kappa.\n+\n+The network savings a_b, a_c and the complex constants (m, s) are assumptions taken\n+from PR #7 of CrocSwap/integer-mult-bounds.\n+\"\"\"\n+from fractions import Fraction as Q\n+import json\n+\n+A_B, A_C = Q(3, 4 * 10**8), Q(39, 10**9) # PR #7 bit / complex savings\n+M_C, S_C = 21952, 45772350635112192 # PR #7 complex network constants\n+# Certified upper bound on log_m(s). Colkitt's guard uses 5 instead; with 5 this witness still\n+# passes (eps*C1/(1+x) is about 0.75), so the tighter exponent is not load-bearing.\n+LOG_M_S = Q(38376, 10000)\n+\n+DEFAULT = dict(eps=Q(9999, 10**4), x=Q(3), y=Q(9999, 10**4), beta=Q(1, 2), zeta=Q(1, 10**4),\n+ delta=Q(1, 10**6), lam=1 - Q(74999, 10**13), lamp=1 - Q(74998, 10**13),\n+ kappa=Q(7499, 10**12))\n+\n+\n+class Failure(Exception):\n+ pass\n+\n+\n+def evaluate(**overrides):\n+ v = dict(DEFAULT, **overrides)\n+ eps, x, y, beta, zeta, delta = v['eps'], v['x'], v['y'], v['beta'], v['zeta'], v['delta']\n+ lam, lamp, kappa = v['lam'], v['lamp'], v['kappa']\n+ tau, sigma = 1 - A_B, 1 - A_C\n+ if not S_C ** LOG_M_S.denominator < M_C ** LOG_M_S.numerator:\n+ raise Failure('log_m s bound')\n+ chi = tau + (1 - beta) * max(sigma - tau, 0)\n+ leaf = sigma + beta * (1 - sigma)\n+ c1 = LOG_M_S * (1 - beta) + beta + zeta # depth exponent with exact log_m s\n+ poly = (1 + x) * delta # exponent of p^delta measured in L\n+ constraints = {\n+ 'lambda above tau, sigma, chi': lam - max(tau, sigma, chi),\n+ 'lambda_prime above lambda': lamp - lam,\n+ 'lambda_prime above leaf': lamp - leaf,\n+ 'lambda_prime below one': 1 - lamp,\n+ 'guard: eps C1 < 1 + x': 1 + x - eps * c1,\n+ # alpha^2 theta >= 1 with alpha^2 ~ Q/(48 d), theta ~ 1/(4 d L^y), Q = Theta(L^(1+x))\n+ 'precision: 2 eps + y < 1 + x': 1 + x - 2 * eps - y,\n+ # coupling cost w^3 (1/lambda + theta) = O(L^((eps - y)/2)) per output is O(1)\n+ 'sub-block coupling: y >= eps': Q(1) if y >= eps else Q(-1),\n+ 'reservations below layer: (2eps-1)/eps < lambda_prime': lamp - (2 * eps - 1) / eps,\n+ 'record regime: eps < 1': 1 - eps,\n+ 'delta < 1/8': Q(1, 8) - delta,\n+ # Upstream's prime_interval_growth (1 - 2 eps > 0) is replaced by the classical prime\n+ # number theorem with error term: eta = 1/(4d) far exceeds exp(-c sqrt(l)) for eps < 1.\n+ 'prime intervals via PNT: eps < 1': 1 - eps,\n+ # K = l - 1 meets the transform lemma's literal hypothesis K <= l - 1. Upstream's\n+ # K = o(l) (eps(1+c) < 1) is deliberately dropped; no cost bound uses it.\n+ }\n+ margins = {\n+ 'prefix moves and top individual round': 1 - eps,\n+ 'simultaneous butterflies': eps * (1 - lamp),\n+ 'fine-bit exposures (A)': 1 - eps - poly,\n+ 'Gaussian maps (B)': 1 - eps - poly,\n+ 'chirps, twists, scalar products': 1 - eps - poly,\n+ 'packed polynomial products': eps,\n+ 'individually processed reserved axes': 1 - eps - poly,\n+ 'CRT axis reversal, best of E and pairwise swaps': max(eps, 1 - eps) * (1 - tau),\n+ }\n+ for name, value in constraints.items():\n+ if value <= 0:\n+ raise Failure(name)\n+ g = min(margins.values())\n+ if g <= kappa:\n+ raise Failure('kappa below every margin')\n+ return dict(kappa=str(kappa), kappa_float=float(kappa), min_margin=str(g), gap=str(g - kappa),\n+ binding=min(margins, key=margins.get), c1=str(c1),\n+ constraints={k: str(c) for k, c in constraints.items()},\n+ margins={k: str(m) for k, m in margins.items()},\n+ assumptions='PR #7 networks (a_b=3/(4*10^8), a_c=39/10^9); pinned upstream interfaces')\n+\n+\n+if __name__ == '__main__':\n+ out = evaluate()\n+ if not Q(1, 2**27) < Q(out['kappa']) < Q(1, 2**26):\n+ raise SystemExit('dyadic position changed')\n+ json.dump(out, open('certificates/witness.json', 'w'), indent=1)\n+ print('PASS conditional witness kappa =', out['kappa'], '| binding:', out['binding'])" + }, + { + "sha": "c5a9fa429bd88f7134eadf5c85eb7ce39c573e28", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate_round3.py", + "status": "added", + "additions": 86, + "deletions": 0, + "changes": 86, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round3.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round3.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round3.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,86 @@\n+\"\"\"Exact rational certificate for the round-3 combinations.\n+\n+Our stack (A, B, C, D, E) with separate bit and complex savings. Costs are powers of\n+L = log2 T ~ log n, with precision p = Theta(L^(1+x)), d = Theta(L^eps), l = Theta(L^(1-eps)).\n+\n+Guard modes:\n+ 'pathwise' uses the pathwise depth exponent C1 = 6/5 - beta/5 + zeta, which depends on a\n+ path-topology claim of the batched complex recursion.\n+ 'crude' needs no topology claim. Every child call of the batched recursion acts on at most\n+ (m-1)/m of its parent's axes (bulk children have a1 f <= (m-2h)e/m), and a node has at\n+ most s_c children in sequence, so the coefficient dependency depth satisfies\n+ A(e) <= E + s_c A((m-1)e/m), with leaves costing 8e < 8 d^beta. Over at most\n+ m(1-beta) ln d + 1 levels this gives A <= 2(E + 8 d^beta) s_c^(1 + m(1-beta) ln d), a fixed\n+ exponent at most m_c ln s_c + beta, covered by C1 = 1 + ceil(m_c ln s_c) + 1. Idea D then\n+ takes x with eps C1 < 1 + x. The exponent is huge but fixed, so the O() statement holds.\n+ With such an x, the record-regime hypothesis r >= 2^(p^mu) needs a fixed mu below\n+ (1-eps)/(1+x), which is tiny but fixed.\n+\"\"\"\n+from fractions import Fraction as Q\n+import math\n+\n+GL = Q(1, 10**16) # strict gaps tau < lambda < lambda'\n+\n+\n+def crude_c1(m_c, s_c):\n+ # upper bound 1 + m_c * ln(s_c), rounded up to an integer\n+ return Q(1 + math.ceil(m_c * math.log(s_c)) + 1)\n+\n+\n+def evaluate(a_b, a_c, beta, guard='pathwise', m_c=21952, s_c=45772350635112192, zeta=Q(1, 10**4)):\n+ tau, sigma = 1 - a_b, 1 - a_c\n+ chi = tau + (1 - beta) * max(sigma - tau, 0)\n+ leaf = sigma + beta * (1 - sigma)\n+ lam = max(tau, sigma, chi) + GL\n+ lamp = max(lam, leaf) + GL\n+ eps = Q(int(1 / (2 - lamp) * 10**16) - 1, 10**16) # reservations force eps < 1/(2-lambda')\n+ c1 = (Q(6, 5) - beta / 5 + zeta) if guard == 'pathwise' else crude_c1(m_c, s_c)\n+ x = max(Q(3), math.ceil(eps * c1) + 1) # Idea D: any fixed x with eps C1 < 1 + x\n+ y = eps\n+ delta = Q(1, 10**22) / max(1, x)\n+ poly = (1 + x) * delta\n+ top = min(eps * (1 - lamp), 1 - eps - poly, max(eps, 1 - eps) * (1 - tau))\n+ kappa = Q(int(top * 10**17) - 1, 10**17)\n+ cons = {\n+ 'lambda above tau, sigma, chi': lam - max(tau, sigma, chi),\n+ 'lambda_prime above lambda and leaf': lamp - max(lam, leaf),\n+ 'lambda_prime below one': 1 - lamp,\n+ 'beta in (0,1)': min(beta, 1 - beta),\n+ 'guard: eps C1 < 1 + x': 1 + x - eps * c1,\n+ 'precision: 2 eps + y < 1 + x': 1 + x - 2 * eps - y,\n+ 'sub-block coupling: y >= eps': Q(1) if y >= eps else Q(-1),\n+ 'reservations: (2eps-1)/eps < lambda_prime': lamp - (2 * eps - 1) / eps,\n+ 'record regime and primes: eps < 1': 1 - eps,\n+ 'delta in (0, 1/8)': min(delta, Q(1, 8) - delta),\n+ }\n+ margins = {\n+ 'prefix moves and top individual round': 1 - eps,\n+ 'simultaneous butterflies': eps * (1 - lamp),\n+ 'fine-bit exposures (A)': 1 - eps - poly,\n+ 'Gaussian maps (B)': 1 - eps - poly,\n+ 'chirps, twists, scalar products': 1 - eps - poly,\n+ 'packed polynomial products': eps,\n+ 'individually processed reserved axes': 1 - eps - poly,\n+ 'CRT axis reversal (E)': max(eps, 1 - eps) * (1 - tau),\n+ }\n+ bad = [k for k, v in cons.items() if v <= 0]\n+ g = min(margins.values())\n+ return dict(ok=not bad and g > kappa, bad=bad, kappa=kappa, eps=eps, x=x, c1=c1,\n+ binding=min(margins, key=margins.get), gap=g - kappa)\n+\n+\n+SCENARIOS = [\n+ ('PR #10 networks', Q(246, 10**9), Q(7, 10**7)),\n+ ('PR #10 complex, our bit producer', Q(252, 10**9), Q(7, 10**7)),\n+ ('batched two-stage bit, PR #10 complex', Q(22157, 5 * 10**9), Q(7, 10**7)),\n+ # headline: PR #7 complex network fully batched (PR #15), rebuilt by independent/complex-network/fullbatch_*.py\n+ ('batched two-stage bit, fully batched PR #7 complex', Q(22157, 5 * 10**9), Q(1048009, 25 * 10**10)),\n+]\n+\n+if __name__ == '__main__':\n+ for name, ab, ac in SCENARIOS:\n+ for guard in ('pathwise', 'crude'):\n+ r = evaluate(ab, ac, Q(1, 1000), guard)\n+ print('%-40s %-8s ok=%s kappa=%.6e (2^%.2f) C1=%s x=%s binding=%s %s' % (\n+ name, guard, r['ok'], float(r['kappa']), math.log2(float(r['kappa'])),\n+ r['c1'] if guard == 'pathwise' else int(r['c1']), r['x'], r['binding'], r['bad']))" + }, + { + "sha": "5f6b2c6910563bf534f43d308d57679a90f10033", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate_round4.py", + "status": "added", + "additions": 66, + "deletions": 0, + "changes": 66, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round4.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round4.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round4.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,66 @@\n+\"\"\"Round-four witness: our stack with PR #24's endpoint-gauge bit network (its published child-width\n+multiset, certified here by our own moment bisection) and PR #7's complex network fully batched with\n+complex source frames (h=28). Also reports the witness with our own two-stage bit interchange\n+(data edges batched, h=47).\n+\n+Usage: python3 scripts/certificate_round4.py COMPLEX_HIST_JSON\n+where the JSON comes from independent/complex-network/fullbatch_hist.py 28 OUT sf.\"\"\"\n+import sys, json, math, os\n+from fractions import Fraction as Q\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, HERE)\n+sys.path.insert(0, os.path.join(HERE, '..', 'independent', 'two-stage-bit'))\n+sys.path.insert(0, os.path.join(HERE, '..', 'independent', 'complex-network'))\n+from certificate_round3 import evaluate\n+import moment\n+from fullbatch_cert import cert\n+\n+BIT_H = 47\n+\n+def bit_saving():\n+ c = moment.histogram(BIT_H, moment.R_of(BIT_H), True)\n+ a, _ = moment.certify(c)\n+ return a, c\n+\n+def pr24_bit_saving():\n+ d = json.load(open(os.path.join(HERE, '..', 'certificates', 'external', 'pr24-bit-network.json')))\n+ c = d['counts']; hist = {int(w): n for w, n in d['child_width_multiplicities']}\n+ W, m, s = c['W'], c['m'], c['total_rank']\n+ assert sum(w * n for w, n in hist.items()) == s and W * m - s == c['deficit'] and max(hist) <= m - 1\n+ a = cert_exp(hist, W, m)\n+ return a, c\n+\n+def cert_exp(hist, W, m, grid=10**13):\n+ # largest a on the grid with sum_t c_t t (m/t)^a / (W m) < 1, using U_t > ln(m/t) and\n+ # e^x <= 1 + x + x^2/2 + x^3 for 0 <= x <= 1/2 (the tail sum_{k>=3} x^k/k! is at most x^3)\n+ from bc import ln_upper\n+ ws = [(Q(t * n, W * m), ln_upper(Q(m, t), rel=Q(1, 10**15))) for t, n in hist.items()]\n+ def mom(a):\n+ tot = Q(0)\n+ for w, U in ws:\n+ x = a * U; assert x <= Q(1, 2)\n+ tot += w * (1 + x + x * x / 2 + x ** 3)\n+ return tot\n+ lo, hi = 0, 10**9\n+ assert mom(Q(hi, grid)) > 1\n+ while hi - lo > 1:\n+ mid = (lo + hi) // 2\n+ if mom(Q(mid, grid)) < 1: lo = mid\n+ else: hi = mid\n+ return Q(lo, grid)\n+\n+def complex_saving(path):\n+ d = json.load(open(path)); hist = {int(k): v for k, v in d['hist'].items()}\n+ assert d['sum_ok'] and d['checker']['bad'] == 0 and max(hist) <= d['m'] - 1\n+ a, gap = cert(hist, d['W'], d['m'], d['s'])\n+ return a, d\n+\n+if __name__ == '__main__':\n+ ac, cc = complex_saving(sys.argv[1])\n+ print('a_c', ac, '(h=%d, R=%d, s=%d)' % (cc['h'], cc['R'], cc['s']))\n+ ab24, c24 = pr24_bit_saving()\n+ ab, cb = bit_saving()\n+ for name, a in (('PR #24 bit network (headline)', ab24), ('our two-stage bit, h=%d' % BIT_H, ab)):\n+ r = evaluate(a, ac, Q(1, 1000), 'crude', m_c=cc['m'], s_c=cc['s'])\n+ print('%s: a_b=%s ok=%s kappa=%s (%.6e, 2^%.3f) binding=%s %s' % (\n+ name, a, r['ok'], r['kappa'], r['kappa'], math.log2(r['kappa']), r['binding'], r['bad']))" + }, + { + "sha": "73403788933bd05b3d3d117a09a38ca519c85482", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate_round5.py", + "status": "added", + "additions": 74, + "deletions": 0, + "changes": 74, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round5.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round5.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round5.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,74 @@\n+\"\"\"Round-five witness: our stack with the two-stage bit interchange in the common flag basis\n+(notes/flag-basis.tex) and the global-matching side circuit (independent/two-stage-bit/gmside.py), and PR #7's\n+complex network fully batched with complex source frames (h=28).\n+\n+Usage: python3 scripts/certificate_round5.py COMPLEX_HIST_JSON\n+where the JSON comes from independent/complex-network/fullbatch_hist.py 28 OUT sf.\"\"\"\n+import sys, math, os\n+from fractions import Fraction as Q\n+from math import comb\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, HERE)\n+sys.path.insert(0, os.path.join(HERE, '..', 'independent', 'two-stage-bit'))\n+from certificate_round3 import evaluate\n+from certificate_round4 import complex_saving\n+import moment, gmside, side_chains\n+from collections import Counter\n+\n+BIT_H = 47\n+\n+def side_ranks(h):\n+ # factor ranks of every side-role edge (stage one; stage two has the same idempotents in reverse order)\n+ G = side_chains.build(h, side_chains.ORDERS['gm']); C = side_chains.compile_(G); rk = Counter()\n+ for s in range(C['roles']):\n+ d = side_chains.chain_dims(G, C, s)\n+ for a, b in zip(d, d[1:]): rk[b - a] += 1\n+ return C['roles'], rk\n+\n+def inner_children(r, h):\n+ # inner lemma: an edge pi (x) P_b with rank pi = r has the profile of a rank-r idempotent of size h\n+ return [1] * (h - r) + [2*r - h] if 2*r > h else [1] * r\n+\n+def flag_histogram(h, R, side=None):\n+ # children per role under the flag basis (Proposition \"Profiles\"):\n+ # selected aux edge, both stages: one block m-2h and one run h (corners merged)\n+ # rest of each side role: h singletons (not batched here)\n+ # centre roles: their three rank-h edges are one run each\n+ # data: entrance block m-4h+2, corner run h-2 and h+1 singletons; the two (h-1)-edges are a block h-2 plus a singleton\n+ # copy correction: one singleton per pair\n+ v, m, c0 = comb(h, 3), h*h, h; N = v*v; A = v*(R+c0); H = {}\n+ add = lambda w, c: H.__setitem__(w, H.get(w, 0) + c)\n+ for _ in range(2):\n+ add(m-2*h, A); add(h, A)\n+ if side is None: add(1, h*v*R)\n+ else:\n+ assert sum(r*n for r, n in side.items()) == h*R, 'side ranks sum to h per role'\n+ for r, n in side.items():\n+ for w in inner_children(r, h): add(w, v*n)\n+ add(h, 3*v*c0)\n+ add(m-4*h+2, 2*N); add(h-2, 2*N); add(1, (h+1)*2*N) # entrance corner: one run h-2 (rank-one term on a triangular corner)\n+ for _ in range(2):\n+ add(h-2, 2*N); add(1, 2*N)\n+ add(1, N)\n+ W = 2*N + 2*A; L = 2*v*h*c0; s = W*m - N + 2*L\n+ assert sum(w*n for w, n in H.items()) == s and W*m > s\n+ return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=H)\n+\n+def bit_saving(side=True):\n+ if side:\n+ R, rk = side_ranks(BIT_H)\n+ assert R == gmside.roles(BIT_H)[0]\n+ else:\n+ R, rk = gmside.roles(BIT_H)[0], None\n+ c = flag_histogram(BIT_H, R, rk)\n+ a, _ = moment.certify(c)\n+ return a, c\n+\n+if __name__ == '__main__':\n+ ac, cc = complex_saving(sys.argv[1])\n+ ab, cb = bit_saving()\n+ print('a_b', ab, '(h=%d, R=%d)' % (BIT_H, cb['R']))\n+ print('a_c', ac, '(h=%d, R=%d, s=%d)' % (cc['h'], cc['R'], cc['s']))\n+ r = evaluate(ab, ac, Q(1, 1000), 'crude', m_c=cc['m'], s_c=cc['s'])\n+ print('crude guard: ok=%s kappa=%s (%.6e, 2^%.3f) binding=%s %s' % (\n+ r['ok'], r['kappa'], r['kappa'], math.log2(r['kappa']), r['binding'], r['bad']))" + }, + { + "sha": "aeb3e6f6c4490a097e82763517005519ed9fba3d", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate_round6.py", + "status": "added", + "additions": 56, + "deletions": 0, + "changes": 56, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round6.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round6.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round6.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,56 @@\n+\"\"\"Round-six witness, bit side: the round-five two-stage interchange (flag basis, gm side circuit, side roles batched\n+one level down, data-entrance run) with copied centres (PR #36's copied retained-centre schedule, here on direct centre\n+wires). Each centre's second scatter reads from a temporary copy moved to D0 (rank h) while the original stays at D1,\n+so a centre has two children of width h per stage instead of three, and the rank budget is s = Wm - N + L.\n+The copy is a temporary, not a role: W is unchanged; the schedule needs one extra role tape.\n+\n+Usage: python3 scripts/certificate_round6.py\"\"\"\n+import sys, math, os\n+from fractions import Fraction as Q\n+from math import comb\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path.insert(0, HERE)\n+sys.path.insert(0, os.path.join(HERE, '..', 'independent', 'two-stage-bit'))\n+import certificate_round5 as c5\n+import moment\n+\n+BIT_H = 25\n+\n+def copied_histogram(h):\n+ R, rk = c5.side_ranks(h)\n+ v, m, c0 = comb(h, 3), h*h, h; N = v*v; A = v*(R+c0); H = {}\n+ add = lambda w, c: H.__setitem__(w, H.get(w, 0) + c) if c else None\n+ for _ in range(2):\n+ add(m-2*h, A); add(h, A)\n+ for r, n in rk.items():\n+ for w in c5.inner_children(r, h): add(w, v*n)\n+ add(h, 2*v*c0) # copied centres: two rank-h children per centre per stage\n+ add(m-4*h+2, 2*N); add(h-2, 2*N); add(1, (h+1)*2*N)\n+ for _ in range(2):\n+ add(h-2, 2*N); add(1, 2*N)\n+ add(1, N)\n+ W = 2*N + 2*A; L = 2*v*h*c0; s = W*m - N + L\n+ assert sum(w*n for w, n in H.items()) == s and W*m > s and max(H) <= m - 1\n+ return dict(h=h, m=m, v=v, N=N, W=W, L=L, s=s, R=R, hist=H)\n+\n+def bit_saving(h=BIT_H):\n+ c = copied_histogram(h)\n+ a, _ = moment.certify(c)\n+ return a, c\n+\n+RT_H = 23\n+\n+def retained_saving(h=RT_H):\n+ # retained point totals replace the direct centre wires: each total's copy pays U_c -> D0 (rank h-1) and the\n+ # original U_c -> F (rank 1); the totals are side roles built from existing nodes (independent/two-stage-bit/rtgm.py)\n+ import rtgm, cert_rt\n+ R, rk, _, _ = rtgm.side_ranks(h, 'search')\n+ c = cert_rt.rt_histogram(h, R, rk)\n+ a, _ = moment.certify(c)\n+ return a, c\n+\n+if __name__ == '__main__':\n+ a, c = retained_saving()\n+ print('a_b', a, float(a), '(retained totals, h=%d, R=%d, s=%d)' % (c['h'], c['R'], c['s']))\n+ a, c = bit_saving()\n+ print('a_b', a, float(a), '(h=%d, R=%d, s=%d, deficit=%d)' % (c['h'], c['R'], c['s'], c['W']*c['m'] - c['s']))" + }, + { + "sha": "32c0058d832b43cb95e288467e152f72ca6083ac", + "filename": "research/deferred-signed/swapnil-round7/scripts/certificate_round7.py", + "status": "added", + "additions": 75, + "deletions": 0, + "changes": 75, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round7.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round7.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcertificate_round7.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,75 @@\n+\"\"\"Round-seven witness, bit side: PR #62's producer (interval strips, core-aware pair assembly) on our two-stage\n+interchange with retained totals, lifted frames and late copies, and the stage-1 word reordered (deferred readouts,\n+V leaves); notes/deferred-readout.tex.\n+\n+The child-width histogram is rebuilt here from the frozen schedule (certificates/round7/): every slot's frame chain\n+from the nodes it holds, the deferred readout levels on every target from the garbage-coefficient supports of the\n+schedule, and the X_S chains from the V-gate order. Frame dimensions are taken from the data file;\n+independent/deferred-readout/check_frames.py re-derives each of them exactly, and check_word.py replays the word.\n+Two data-entrance corners are reported: the round-six corner (runs h-2, 1^(h+1)) and the staircase corner (runs h-2,\n+h-5, 1^6, independent/deferred-readout/check_stair.py).\n+\n+Usage: python3 scripts/certificate_round7.py\"\"\"\n+import os, sys\n+from fractions import Fraction as Q\n+HERE = os.path.dirname(os.path.abspath(__file__))\n+sys.path[:0] = [HERE, os.path.join(HERE, '..', 'independent', 'two-stage-bit'),\n+ os.path.join(HERE, '..', 'independent', 'deferred-readout')]\n+import moment\n+import deferred as dr\n+from certificate_round3 import evaluate\n+\n+A_C, M_C, S_C = Q(36926111, 5 * 10**11), 576, 119453132304 # round-six complex interchange, h = 24\n+\n+# Every round-seven bit witness: its frozen files and its claimed savings with the two entrance corners.\n+# The headline is the staircase variant of the last entry.\n+WITNESSES = [\n+ dict(name='PR #62 producer, lifted frames, late copies, deferred readouts, V leaves', h=23,\n+ witness='witness_23.json.gz', data='deferred_23.json.gz',\n+ plain=(Q(12599, 200000000), Q(6299103187973, 10**17)),\n+ staircase=(Q(31987, 500000000), Q(1599247689723, 25 * 10**15))),\n+]\n+HEADLINE = WITNESSES[-1]\n+CORNERS = (('plain', 'round-six entrance corner', dr.ROUND6_CORNER), ('staircase', 'staircase entrance corner', dr.STAIRCASE_CORNER))\n+\n+\n+def build(wit=HEADLINE):\n+ h = wit['h']; W, D = dr.load(h, wit['witness'], wit['data']); S = dr.Schedule(W, D)\n+ cov = S.adjoint(); ylev = S.ylevels(cov); rk = dr.chain_ranks(S); xd = S.xdata()\n+ assert all(sum(x) == h - 1 for x in xd)\n+ return S, rk, ylev, xd\n+\n+\n+def saving(S, rk, ylev, xd, corner):\n+ c = dr.histogram(S, rk, ylev, xd, corner)\n+ assert sum(w * n for w, n in c['hist'].items()) == c['s'] and max(c['hist']) < c['m'] and c['W'] * c['m'] > c['s']\n+ a, _ = moment.certify(c)\n+ return a, c\n+\n+\n+def kappa(a_b):\n+ return evaluate(a_b, A_C, Q(1, 1000), 'crude', m_c=M_C, s_c=S_C)\n+\n+\n+def certify(wit):\n+ \"\"\"{'plain' | 'staircase': (a_b, kappa result, histogram)} for one witness, checked against its claims.\"\"\"\n+ S, rk, ylev, xd = build(wit); out = {}\n+ for key, _, corner in CORNERS:\n+ a, c = saving(S, rk, ylev, xd, corner(S.h)); k = kappa(a)\n+ assert k['ok'] and (a, k['kappa']) == wit[key], (key, a, k['kappa'])\n+ out[key] = (a, k, c)\n+ return S, out\n+\n+\n+def main():\n+ for wit in WITNESSES:\n+ S, out = certify(wit)\n+ print('%s: h=%d R=%d, deferred slots %d, V-leaf slots %d' % (wit['name'], S.h, S.R, len(S.readout), len(S.vstart)))\n+ for key, label, _ in CORNERS:\n+ a, k, c = out[key]\n+ print(' %s: s = Wm - N + L = %d (rank sum exact), W = %d, a_b = %s (%.6e), kappa = %s (%.7e) ok=%s' % (\n+ label, c['s'], c['W'], a, float(a), k['kappa'], float(k['kappa']), k['ok']))\n+\n+\n+if __name__ == '__main__':\n+ main()" + }, + { + "sha": "13d2316ee5bf9a01514855267dee54ae583111a4", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_fine_field.py", + "status": "added", + "additions": 498, + "deletions": 0, + "changes": 498, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_fine_field.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_fine_field.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_fine_field.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,498 @@\n+#!/usr/bin/env python3\n+\"\"\"Tape-level simulation of Idea A (expose only the fine bits u of one axis).\n+\n+Every array lives on a Tape: a list of records with ONE head. Data are read\n+and written only at the head; each head step (read, write or seek by one cell)\n+adds one to that tape's move counter. Seeking by a distance D costs D, which is\n+what a machine pays when it counts D cells off a counter (upstream counter\n+lemma). The kernel's window buffer is a tape too, but its moves are reported\n+separately as \"local\": they are the line algorithm's own work, not transport.\n+\n+Pipeline for one axis, with line coordinate j = J*F + u, F = 2^f:\n+ natural (X, J, u, Y) --f digit moves--> (X, J, Y, u)\n+ forward pass (windowed map across <=3 slabs, periodic wrap of period s\n+ spliced at u = s mod F, per-line state on its own tape,\n+ per-(X,J,Y) auxiliary records, Y-validity bitmap)\n+ backward pass (slabs J descending, u descending, state carried right to\n+ left, auxiliary records read back)\n+ (X, J, Y, u) --f digit moves--> natural (X, J, u, Y)\n+and the result is compared with the same maps applied line by line.\n+\"\"\"\n+import random\n+import sys\n+\n+MOD = 1_000_003\n+\n+\n+class Tape:\n+ def __init__(self, name, cells=None):\n+ self.name = name\n+ self.c = list(cells) if cells else []\n+ self.h = 0\n+ self.moves = 0\n+\n+ def seek(self, pos):\n+ assert pos >= 0\n+ self.moves += abs(pos - self.h)\n+ self.h = pos\n+\n+ def read(self):\n+ v = self.c[self.h] if self.h < len(self.c) else 0\n+ self.h += 1\n+ self.moves += 1\n+ return v\n+\n+ def write(self, v):\n+ if self.h >= len(self.c):\n+ self.c.extend([0] * (self.h + 1 - len(self.c)))\n+ self.c[self.h] = v\n+ self.h += 1\n+ self.moves += 1\n+\n+\n+# ---------------------------------------------------------------- digit moves\n+def move_bit(src, P, M, S, forward, tapes):\n+ \"\"\"Move one binary address digit past a field of size M.\n+ forward: (P, b, M, S) -> (P, M, b, S); backward: the inverse.\n+ Split on b into two stream tapes, then merge in output order (upstream\n+ elementary-streams lemma, item 2). Returns a fresh output tape.\"\"\"\n+ s0, s1 = Tape(\"split0\"), Tape(\"split1\")\n+ out = Tape(\"moved\")\n+ src.seek(0)\n+ for p in range(P):\n+ if forward:\n+ for b in (0, 1):\n+ st = s1 if b else s0\n+ for _ in range(M * S):\n+ st.write(src.read())\n+ else:\n+ for m in range(M):\n+ for b in (0, 1):\n+ st = s1 if b else s0\n+ for _ in range(S):\n+ st.write(src.read())\n+ s0.seek(0)\n+ s1.seek(0)\n+ for p in range(P):\n+ if forward:\n+ for m in range(M):\n+ for st in (s0, s1):\n+ for _ in range(S):\n+ out.write(st.read())\n+ else:\n+ for st in (s0, s1):\n+ for _ in range(M * S):\n+ out.write(st.read())\n+ out.seek(0)\n+ tapes.extend([src, s0, s1])\n+ return out\n+\n+\n+def expose(tape, nX, nJ, f, nY, tapes):\n+ for i in range(f):\n+ tape = move_bit(tape, nX * nJ * 2 ** (f - 1 - i), nY, 2 ** i, True, tapes)\n+ return tape\n+\n+\n+def restore(tape, nX, nJ, f, nY, tapes):\n+ for i in reversed(range(f)):\n+ tape = move_bit(tape, nX * nJ * 2 ** (f - 1 - i), nY, 2 ** i, False, tapes)\n+ return tape\n+\n+\n+# ---------------------------------------------------------------- the stand-in\n+class LineOp:\n+ \"\"\"Windowed map with a periodic input (period `period`), a forward\n+ recurrence with a two-word state (running value, border accumulator),\n+ sparse \"wrap\" records kept for the backward sweep, then a backward\n+ recurrence seeded by the final forward state.\"\"\"\n+\n+ def __init__(self, n_in_box, period, n_out_box, n_out, center, W):\n+ self.n_in_box, self.period = n_in_box, period\n+ self.n_out_box, self.n_out = n_out_box, n_out\n+ self.center, self.W = center, W\n+\n+ def weight(self, k, m):\n+ return (1 + 3 * m * m + 5 * m + 7 * (k % 13)) % MOD\n+\n+ def is_wrap(self, k):\n+ # outputs where the input centre does not advance: density ~ 1 - s/t\n+ return self.center(k + 1) == self.center(k)\n+\n+ def ysum(self, k, xt):\n+ c = self.center(k)\n+ return sum(self.weight(k, m) * xt(c + m) for m in range(-self.W, self.W + 1)) % MOD\n+\n+\n+A_COEF, C_COEF = 31, 17\n+\n+\n+def reference(line, op):\n+ \"\"\"Natural-order, one line at a time.\"\"\"\n+ xt = lambda j: line[j % op.period]\n+ z = b = 0\n+ zs, ys = [], []\n+ for k in range(op.n_out):\n+ y = op.ysum(k, xt)\n+ z = (A_COEF * z + y) % MOD\n+ b = (b + y) % MOD\n+ zs.append(z)\n+ ys.append(y)\n+ g = z\n+ out = [0] * op.n_out_box\n+ for k in reversed(range(op.n_out)):\n+ g = (C_COEF * g + zs[k] + b + (7 * ys[k] if op.is_wrap(k) else 0)) % MOD\n+ out[k] = g\n+ return zs + [0] * (op.n_out_box - op.n_out), out\n+\n+\n+# ---------------------------------------------------------------- validity\n+def build_bitmap(boxes, bounds, tapes):\n+ \"\"\"Tensor product of per-axis indicator vectors, built by repeated copies.\n+ Cost <= 2 * prod(boxes) moves per tape.\"\"\"\n+ cur = Tape(\"bm0\", [1])\n+ for box, bnd in reversed(list(zip(boxes, bounds))):\n+ nxt = Tape(\"bm\")\n+ n = len(cur.c)\n+ for d in range(box):\n+ cur.seek(0)\n+ for _ in range(n):\n+ v = cur.read()\n+ nxt.write(v if d < bnd else 0)\n+ tapes.append(cur)\n+ cur = nxt\n+ cur.seek(0)\n+ return cur\n+\n+\n+# ---------------------------------------------------------------- slab passes\n+def forward_pass(IN, nX, xvalid, nY, VALID, F, op, h, tapes, K, SIG=2):\n+ \"\"\"IN holds the input in (X, J, Y, u) order with op.n_in_box per line.\"\"\"\n+ nJin, nJout = op.n_in_box // F, op.n_out_box // F\n+ G = nJin * nY * F # input records per X group\n+ OUT, AUX, FINAL = Tape(\"out\"), Tape(\"aux\"), Tape(\"final\")\n+ CP, ST, BUF = Tape(\"copy\"), Tape(\"state\"), Tape(\"buf\")\n+ E = [Tape(\"E0\"), Tape(\"E1\"), Tape(\"E2\")]\n+ lo = lambda k: op.center(k) - op.W\n+ hi = lambda k: op.center(k) + op.W\n+ Jp = [lo(J * F) // F for J in range(nJout)]\n+ # Setup per J (independent of X and Y): J' is non-decreasing and moves by <= 2.\n+ for J in range(1, nJout):\n+ assert 0 <= Jp[J] - Jp[J - 1] <= 2\n+ vlo = Jp[0]\n+ vhi = max(Jp[J] for J in range(nJout) if J * F < op.n_out) + 2\n+ for J in range(nJout):\n+ if J * F < op.n_out:\n+ assert hi(min(J * F + F, op.n_out) - 1) < (Jp[J] + 3) * F, \"window > 3 slabs\"\n+ assert -vlo <= h and (vhi + 1) * F - op.period <= h * F + F and op.period >= 2 * F\n+ op.n_e = vhi - vlo + 1\n+ local = 0\n+ for X in range(nX):\n+ base = X * G\n+ if not xvalid[X]:\n+ # whole group is zero: skip it, write zeros\n+ IN.seek(base + G)\n+ for _ in range(nJout * nY * F):\n+ OUT.write(0)\n+ for _ in range(nJout * nY * K):\n+ AUX.write(0)\n+ for _ in range(nY * SIG):\n+ FINAL.write(0)\n+ continue\n+ # copy the group so two heads can read two slabs at the same Y\n+ IN.seek(base)\n+ CP.seek(0)\n+ for _ in range(G):\n+ CP.write(IN.read())\n+ # build the extended (virtual, periodic) slabs vlo..vhi on E0,E1,E2 at once\n+ for t in E:\n+ t.seek(0)\n+ for v in range(vlo, vhi + 1):\n+ phys = [((v * F + u) % op.period) for u in range(F)]\n+ slabs = []\n+ for p in phys:\n+ if p // F not in slabs:\n+ slabs.append(p // F)\n+ assert len(slabs) <= 2, \"virtual slab draws from >2 physical slabs\"\n+ heads = {slabs[0]: (IN, base)}\n+ if len(slabs) == 2:\n+ heads[slabs[1]] = (CP, 0)\n+ for Y in range(nY):\n+ for sl, (tp, b0) in heads.items():\n+ tp.seek(b0 + (sl * nY + Y) * F)\n+ for p in phys:\n+ tp, b0 = heads[p // F]\n+ tp.seek(b0 + ((p // F) * nY + Y) * F + p % F)\n+ val = tp.read()\n+ assert p < op.period\n+ for t in E:\n+ t.write(val)\n+ for sl, (tp, b0) in heads.items():\n+ tp.seek(b0 + (sl * nY + Y + 1) * F) # finish the slab row\n+ slab_off = lambda v: (v - vlo) * nY * F\n+ # per-line state on its own tape, in Y order\n+ ST.seek(0)\n+ for _ in range(nY * SIG):\n+ ST.write(0)\n+ for J in range(nJout):\n+ kfirst = J * F\n+ if kfirst >= op.n_out:\n+ for _ in range(nY * F):\n+ OUT.write(0)\n+ for _ in range(nY * K):\n+ AUX.write(0)\n+ continue\n+ for i, t in enumerate(E):\n+ t.seek(slab_off(Jp[J] + i))\n+ ST.seek(0)\n+ VALID.seek(0)\n+ for Y in range(nY):\n+ ok = VALID.read()\n+ BUF.seek(0)\n+ for t in E: # gather 3 slab rows\n+ for _ in range(F):\n+ BUF.write(t.read())\n+ st = [ST.read() for _ in range(SIG)]\n+ outs, aux = [0] * F, []\n+ if ok:\n+ z, b = st\n+ w0 = Jp[J] * F\n+ for u in range(F):\n+ k = kfirst + u\n+ if k >= op.n_out:\n+ break\n+ c = op.center(k)\n+ acc = 0\n+ BUF.seek(c - op.W - w0)\n+ for m in range(-op.W, op.W + 1):\n+ acc += op.weight(k, m) * BUF.read()\n+ y = acc % MOD\n+ z = (A_COEF * z + y) % MOD\n+ b = (b + y) % MOD\n+ outs[u] = z\n+ if op.is_wrap(k):\n+ aux.append(y)\n+ ST.seek(ST.h - SIG)\n+ ST.write(z)\n+ ST.write(b)\n+ for v in outs:\n+ OUT.write(v)\n+ assert len(aux) <= K\n+ for i in range(K):\n+ AUX.write(aux[i] if i < len(aux) else 0)\n+ ST.seek(0)\n+ ST.seek(0)\n+ for _ in range(nY * SIG):\n+ FINAL.write(ST.read())\n+ local = BUF.moves\n+ BUF.moves = 0\n+ tapes.extend([IN, CP, ST, BUF, AUX] + E)\n+ OUT.seek(0); AUX.seek(0); FINAL.seek(0)\n+ return OUT, AUX, FINAL, local\n+\n+\n+def backward_pass(Z, AUX, FINAL, nX, xvalid, nY, VALID, F, op, tapes, K, SIG=2):\n+ nJ = op.n_out_box // F\n+ G = nJ * nY * F\n+ OUT2, ST, BUF = Tape(\"out2\"), Tape(\"bstate\"), Tape(\"bbuf\")\n+ OUT2.c = [0] * (nX * G) # blank tape of the output's length\n+ for X in range(nX):\n+ ST.seek(0)\n+ FINAL.seek(X * nY * SIG)\n+ for _ in range(nY * SIG):\n+ ST.write(FINAL.read())\n+ if not xvalid[X]:\n+ continue # output already blank (zero)\n+ top = (op.n_out - 1) // F\n+ for J in range(top, -1, -1):\n+ off = X * G + J * nY * F\n+ Z.seek(off)\n+ OUT2.seek(off)\n+ AUX.seek(((X * nJ + J) * nY) * K)\n+ ST.seek(0)\n+ VALID.seek(0)\n+ for Y in range(nY):\n+ ok = VALID.read()\n+ BUF.seek(0)\n+ for _ in range(F):\n+ BUF.write(Z.read())\n+ ax = [AUX.read() for _ in range(K)]\n+ g, b = ST.read(), ST.read()\n+ res = [0] * F\n+ if ok:\n+ ks = [J * F + u for u in range(F) if J * F + u < op.n_out]\n+ nw = sum(1 for k in ks if op.is_wrap(k))\n+ for u in reversed(range(len(ks))):\n+ k = ks[u]\n+ BUF.seek(u)\n+ zk = BUF.read()\n+ extra = 0\n+ if op.is_wrap(k):\n+ nw -= 1\n+ extra = 7 * ax[nw]\n+ g = (C_COEF * g + zk + b + extra) % MOD\n+ res[u] = g\n+ ST.seek(ST.h - SIG)\n+ ST.write(g)\n+ ST.write(b)\n+ for v in res:\n+ OUT2.write(v)\n+ local = BUF.moves\n+ BUF.moves = 0\n+ tapes.extend([Z, AUX, FINAL, ST, BUF])\n+ OUT2.seek(0)\n+ return OUT2, local\n+\n+\n+# ---------------------------------------------------------------- one case\n+def run_case(name, nXbox, nXval, ybox, yval, nbox, s, t, kind, f, W, seed):\n+ rnd = random.Random(seed)\n+ F = 2 ** f\n+ nY = 1\n+ for b in ybox:\n+ nY *= b\n+ yvalid = []\n+ for Y in range(nY):\n+ r, ok = Y, True\n+ for b, v in reversed(list(zip(ybox, yval))):\n+ ok &= (r % b) < v\n+ r //= b\n+ yvalid.append(1 if ok else 0)\n+ xvalid = [1 if X < nXval else 0 for X in range(nXbox)]\n+ if kind == \"expand\": # A: C^s -> C^t, input s-periodic (splice at s mod F)\n+ op = LineOp(nbox, s, nbox, t, lambda k: (s * k) // t, W)\n+ elif kind == \"compress\": # B0: C^t -> C^s, input t-periodic, writes s then zeros\n+ op = LineOp(nbox, t, nbox, s, lambda k: (t * k) // s, W)\n+ else: # N: s -> s, s-periodic\n+ op = LineOp(nbox, s, nbox, s, lambda k: k, W)\n+ nat = {}\n+ for X in range(nXbox):\n+ for Y in range(nY):\n+ ok = xvalid[X] and yvalid[Y]\n+ nat[X, Y] = [rnd.randrange(MOD) if ok and j < op.period else 0\n+ for j in range(nbox)]\n+ # natural layout (X, j, Y) == (X, J, u, Y)\n+ natural = [nat[X, Y][j] for X in range(nXbox) for j in range(nbox) for Y in range(nY)]\n+ tapes = []\n+ T0 = Tape(\"natural\", natural)\n+ nJ = nbox // F\n+ phys = expose(T0, nXbox, nJ, f, nY, tapes)\n+ m_expose = sum(tp.moves for tp in tapes) + phys.moves\n+ for tp in tapes:\n+ tp.moves = 0\n+ phys.moves = 0\n+ # check exposure against the definition of the (X, J, Y, u) order\n+ for X in range(nXbox):\n+ for J in range(nJ):\n+ for Y in range(nY):\n+ for u in range(F):\n+ assert phys.c[((X * nJ + J) * nY + Y) * F + u] == nat[X, Y][J * F + u]\n+ t2 = []\n+ VALID = build_bitmap(ybox, yval, t2)\n+ m_bitmap = sum(tp.moves for tp in t2) + VALID.moves\n+ VALID.moves = 0\n+ K = max(sum(1 for k in range(J * F, min(J * F + F, op.n_out)) if op.is_wrap(k))\n+ for J in range(nbox // F))\n+ h = 2\n+ tf = []\n+ Z, AUX, FINAL, loc_f = forward_pass(phys, nXbox, xvalid, nY, VALID, F, op, h, tf, K)\n+ m_fwd = sum(tp.moves for tp in tf) + Z.moves + VALID.moves\n+ for tp in tf:\n+ tp.moves = 0\n+ Z.moves = AUX.moves = FINAL.moves = VALID.moves = 0\n+ tb = []\n+ OUT2, loc_b = backward_pass(Z, AUX, FINAL, nXbox, xvalid, nY, VALID, F, op, tb, K)\n+ m_bwd = sum(tp.moves for tp in tb) + OUT2.moves + VALID.moves\n+ OUT2.moves = 0\n+ t3 = []\n+ back = restore(OUT2, nXbox, nJ, f, nY, t3)\n+ m_restore = sum(tp.moves for tp in t3) + back.moves\n+ # compare with natural-order reference (forward output and final output)\n+ okz = okg = True\n+ for X in range(nXbox):\n+ for Y in range(nY):\n+ zs, gs = reference(nat[X, Y], op)\n+ if not (xvalid[X] and yvalid[Y]):\n+ zs = gs = [0] * nbox\n+ for J in range(nJ):\n+ for u in range(F):\n+ k = J * F + u\n+ okz &= Z.c[((X * nJ + J) * nY + Y) * F + u] == zs[k]\n+ okg &= back.c[(X * nbox + k) * nY + Y] == gs[k]\n+ V = nXbox * nY * nbox\n+ # Proven per-pass bounds from the lemma (records moved, all transport tapes).\n+ B, n_s, SIG = nY * F, nbox // F, 2\n+ fwd_bound = (28 * V + 11 * nXbox * (op.n_e - n_s) * B\n+ + V * (4 * SIG + 2 * K + 2) / F + 4 * nXbox * nY * SIG)\n+ bwd_bound = 11 * V + V * (3 * K + 6 * SIG + 2) / F + 4 * nXbox * nY * SIG\n+ assert m_fwd <= fwd_bound, (name, m_fwd, fwd_bound)\n+ assert m_bwd <= bwd_bound, (name, m_bwd, bwd_bound)\n+ assert m_expose == 6 * f * V and m_restore == 6 * f * V\n+ rec = dict(name=name, kind=kind, s=s, t=t, F=F, nY=nY, nX=nXbox, V=V,\n+ ok=okz and okg, expose=m_expose / V / f, restore=m_restore / V / f,\n+ bitmap=m_bitmap / nY, fwd=m_fwd / V, bwd=m_bwd / V,\n+ local=(loc_f + loc_b) / V, K=K, splice=s % F)\n+ return rec\n+\n+\n+CASES = [\n+ # name, X box, X valid, Y boxes, Y valid, line box, s, t, kind, f, W\n+ (\"e13/16 f2\", 3, 2, (2, 3), (2, 2), 16, 13, 16, \"expand\", 2, 1),\n+ (\"e29/32 f3\", 2, 2, (4, 2), (3, 2), 32, 29, 32, \"expand\", 3, 2),\n+ (\"e53/64 f3\", 3, 2, (3,), (2,), 64, 53, 64, \"expand\", 3, 2),\n+ (\"e61/64 f4\", 2, 1, (2, 2), (2, 1), 64, 61, 64, \"expand\", 4, 3),\n+ (\"e107/128 f4 Y1\", 4, 3, (1,), (1,), 128, 107, 128, \"expand\", 4, 3),\n+ (\"c13/16 f2\", 3, 2, (2, 3), (2, 2), 16, 13, 16, \"compress\", 2, 1),\n+ (\"c29/32 f3\", 2, 2, (4, 2), (3, 2), 32, 29, 32, \"compress\", 3, 1),\n+ (\"c53/64 f3\", 3, 2, (3,), (2,), 64, 53, 64, \"compress\", 3, 2),\n+ (\"c103/128 f4\", 2, 2, (5,), (3,), 128, 103, 128, \"compress\", 4, 3),\n+ (\"n29 f3\", 2, 2, (4, 2), (3, 2), 32, 29, 32, \"N\", 3, 2),\n+ (\"n61 f4\", 3, 2, (3, 2), (2, 2), 64, 61, 64, \"N\", 4, 4),\n+ (\"n127 f4 big\", 2, 2, (8, 4), (7, 3), 128, 127, 128, \"N\", 4, 3),\n+]\n+\n+def scaling():\n+ \"\"\"fwd/V and bwd/V must stay bounded as |Y|, the X count and the line grow.\"\"\"\n+ print(\"\\nscaling (expand, all lines valid):\")\n+ print(f\"{'nX':>3} {'|Y|':>4} {'line':>5} {'F':>3} {'fwd/V':>6} {'bwd/V':>6}\")\n+ for nX, ny, nbox, s, f, W in [(1, 1, 256, 211, 4, 3), (1, 16, 256, 211, 4, 3),\n+ (1, 64, 256, 211, 4, 3), (4, 16, 256, 211, 4, 3),\n+ (2, 16, 512, 487, 5, 6), (2, 16, 1024, 937, 6, 12)]:\n+ r = run_case(\"scale\", nX, nX, (ny,), (ny,), nbox, s, nbox, \"expand\", f, W, seed=7)\n+ assert r[\"ok\"]\n+ print(f\"{nX:>3} {ny:>4} {nbox:>5} {2**f:>3} {r['fwd']:6.2f} {r['bwd']:6.2f}\")\n+\n+\n+\n+def centred_window_check():\n+ \"\"\"The notes' window J'-1, J', J'+1 with J' = floor(J s / t) misses inputs:\n+ count output slabs whose inputs reach slab J'+2 (expansion map).\"\"\"\n+ print(\"\\nold centred window J'-1..J'+1 (superseded) vs left-anchored J'..J'+2 (lemma); failures below are for the old window:\")\n+ for s, t, F, W in [(211, 256, 16, 3), (937, 1024, 64, 12), (1009, 1024, 64, 8)]:\n+ bad = 0\n+ for J in range(t // F):\n+ jc = (J * F * s // t) // F\n+ lo, hi = (s * J * F) // t - W, (s * (J * F + F - 1)) // t + W\n+ bad += hi >= (jc + 2) * F or lo < (jc - 1) * F\n+ print(f\" s={s} t={t} F={F} W={W}: {bad} of {t // F} slabs fail\")\n+\n+\n+if __name__ == \"__main__\":\n+ allok = True\n+ hdr = f\"{'case':16} {'ok':4} {'s%F':>4} {'|Y|':>4} {'K':>2} {'exp/Vf':>7} {'fwd/V':>6} {'bwd/V':>6} {'rst/Vf':>7} {'local/V':>8}\"\n+ print(hdr)\n+ worst = {\"fwd\": 0, \"bwd\": 0, \"expose\": 0, \"restore\": 0}\n+ for i, c in enumerate(CASES):\n+ r = run_case(*c, seed=i)\n+ allok &= r[\"ok\"]\n+ for k in worst:\n+ worst[k] = max(worst[k], r[k])\n+ print(f\"{r['name']:16} {'PASS' if r['ok'] else 'FAIL':4} {r['splice']:>4} {r['nY']:>4} {r['K']:>2} \"\n+ f\"{r['expose']:7.2f} {r['fwd']:6.2f} {r['bwd']:6.2f} {r['restore']:7.2f} {r['local']:8.2f}\")\n+ print(\"worst:\", {k: round(v, 2) for k, v in worst.items()})\n+ print(\"ALL PASS\" if allok else \"SOME FAIL\")\n+ if \"--scale\" in sys.argv:\n+ scaling()\n+ centred_window_check()\n+ sys.exit(0 if allok else 1)\n+" + }, + { + "sha": "b1e4281c733dc395155c4547ffc50a7b3a87fd2a", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_gs_path.py", + "status": "added", + "additions": 221, + "deletions": 0, + "changes": 221, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_gs_path.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_gs_path.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_gs_path.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,221 @@\n+\"\"\"Numerical check of the Gohberg--Semencul (GS) path for the recentred sub-block inverse.\n+\n+Each block applies M_c^{-1} = D_c T_c^{-1} D_c^{-1}, T_c = G_c T_lambda G_c^{-1}, with T_c^{-1} in\n+GS form x0^{-1} (L(x_c) U(yt_c) - L(Zy_c) U(Zxt_c)) and four triangular Toeplitz products done in\n+fixed point at P decimal digits (exact products, then rounding, as packed integer multiplication does).\n+Here x = T^{-1} e_0, y = T^{-1} e_{n-1}, yt = reversed y, Z = down shift.\n+\n+Modes (how the four vectors of T_c are produced):\n+ 0 two-frame fixed point (proposed): store x_+ = T_{+1/2}^{-1} e_0 and y = T_lambda^{-1} e_{n-1},\n+ both bounded, in fixed point at P digits; every per-block rescale factor is <= 1. Expect PASS.\n+ 1 claimed path, balanced: GS vectors of T_lambda at high precision, stored floating point\n+ (P significant digits), rescaled per block with the rho_c^{+-n} balance between the two\n+ factors of the second product, then converted to fixed point. Expect PASS.\n+ 2 claimed path, unbalanced: as 1 but each factor is conjugated by G_c on its own, so the second\n+ pair carries rho_c^{-n} and rho_c^{+n}: one factor needs ~9.06 alpha^2 n extra integer\n+ bits and the other underflows, dropping the second product.\n+ 3 negative control: GS vectors of T_lambda stored in fixed point at P digits. Expect FAIL.\n+ 4 negative control: mode 0 at P = Q + 2 log2(lambda) + 8 bits, i.e. without the chirp reserve\n+ R_D. Expect FAIL.\n+Mode 2 is reported only; mode 3 is asserted to fail only where its predicted loss exceeds 2^-Q.\n+Args: s t alpha^2 Q_bits [P_digits] (P defaults to the bound Q + R_D + 2 log2(lambda) + 8 bits).\n+Exit status is nonzero if any mode disagrees with its expectation.\n+\"\"\"\n+from decimal import Decimal as Dm, getcontext, Context, localcontext\n+from fractions import Fraction as F\n+import math, sys, random\n+\n+argv = [int(a) for a in sys.argv[1:]] or [241, 256, 17, 150]\n+s, t, a2, Qbits = argv[:4]\n+getcontext().prec = 160\n+BIG = Context(prec=3000) # fixed-point work context: wide enough that no integer part overflows\n+PI = Dm('3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278')\n+sig = F(t, s); th = sig - 1\n+q = lambda j: math.floor(F(t*j, s) + F(1, 2)); beta = lambda j: F(t*j, s) - q(j)\n+dec = lambda f: Dm(f.numerator) / Dm(f.denominator)\n+E = lambda x: (-PI*a2*dec(x)).exp()\n+\n+def solve(A, bv, pivot=True):\n+ n = len(A); M = [row[:] + [bv[i]] for i, row in enumerate(A)]\n+ for c in range(n):\n+ if pivot:\n+ p = max(range(c, n), key=lambda r: abs(M[r][c])); M[c], M[p] = M[p], M[c]\n+ for r in range(n):\n+ if r != c and M[r][c] != 0:\n+ f = M[r][c] / M[c][c]\n+ for k in range(c, n+1): M[r][k] -= f*M[c][k]\n+ return [M[i][n] / M[i][i] for i in range(n)]\n+\n+# --- the operator N, its wraps and its blocks (same construction as check_reuse_inverse.py) ---\n+N = [[Dm(0)]*s for _ in range(s)]\n+for l in range(s):\n+ for j in range(l - 2*s, l + 2*s):\n+ X = (sig*j - q(l))**2 - beta(j)**2\n+ if X < 60:\n+ N[l][j % s] += E(X)\n+wraps = [j for j in range(s) if q(j+1) - q(j) == 2]\n+w = 1 + math.isqrt(int(Qbits / (4.53 * a2)) + 1)\n+blocks = []\n+for i, w0 in enumerate(wraps):\n+ st = w0 + 1; en = wraps[(i+1) % len(wraps)] + (s if i+1 == len(wraps) else 0)\n+ seg = list(range(st, en + 1))\n+ nb = max(1, len(seg) // (2*w))\n+ cuts = [round(k * len(seg) / nb) for k in range(nb + 1)]\n+ blocks += [seg[cuts[k]:cuts[k+1]] for k in range(nb)]\n+lengths = sorted({len(g) for g in blocks})\n+assert min(lengths) >= 2*w, (lengths, w)\n+lam = max(lengths)\n+RD = 4.5324 * a2 * float(th) * (lam - 1)**2 # chirp D_c span in bits inside one block\n+Pdig = argv[4] if len(argv) > 4 else math.ceil((Qbits + RD + 2*math.log2(lam) + 8) / math.log2(10))\n+PREC = {'d': Pdig} # current working precision, switched per mode\n+fix = lambda v: BIG.quantize(v, Dm(10) ** -PREC['d']) # fixed point: absolute precision 10^-P\n+flt = lambda v: Context(prec=PREC['d']).plus(v) # floating point: P significant digits\n+\n+def toeplitz(L, b): # T_c for beta = b: symbol exp(-pi a2 (sigma h^2 + 2 b h))\n+ return [[E(sig*(c-a)**2 + 2*b*(c-a)) for c in range(L)] for a in range(L)]\n+\n+def gs_vectors(A):\n+ n = len(A)\n+ x = solve(A, [Dm(int(i == 0)) for i in range(n)])\n+ y = solve(A, [Dm(int(i == n-1)) for i in range(n)])\n+ return x, y\n+\n+# --- setup, once per block length ---\n+base = {}\n+for L in lengths:\n+ with localcontext() as ctx: # absolute precision P + 9.06 a2 L bits\n+ ctx.prec = Pdig + int(9.06 * a2 * L / 3.32) + 30\n+ x, y = gs_vectors(toeplitz(L, F(-1, 2)))\n+ T = toeplitz(L, F(-1, 2))\n+ # GS reconstruction check against a dense inverse at this precision\n+ yt = y[::-1]; Zy = [Dm(0)] + y[:-1]; Zxt = [Dm(0)] + x[::-1][:-1]\n+ Ti = [solve(T, [Dm(int(i == j)) for i in range(L)]) for j in range(L)]\n+ rec = max(abs(sum(x[a-k]*yt[b-k] - Zy[a-k]*Zxt[b-k] for k in range(min(a, b)+1)) / x[0]\n+ - Ti[b][a]) for a in range(L) for b in range(L))\n+ assert rec < Dm(10) ** -(Pdig + 5), rec\n+ with localcontext() as ctx: # proposed: only P (+ guard) digits\n+ ctx.prec = Pdig + 20\n+ xp, _ = gs_vectors(toeplitz(L, F(1, 2))) # frame beta = +1/2: x_+ = rho_+^{-i} x_i\n+ _, ym = gs_vectors(toeplitz(L, F(-1, 2))) # frame beta = -1/2: T_lambda itself\n+ base[L] = dict(x=x, y=y, xp=[fix(v) for v in xp], ym=[fix(v) for v in ym],\n+ xf=[flt(v) for v in x], yf=[flt(v) for v in y],\n+ xq=[fix(v) for v in x], yq=[fix(v) for v in y])\n+\n+def powers(r, n, store): # r^0..r^{n-1} by repeated multiplication, stored as given\n+ out = [Dm(1)]\n+ for _ in range(n - 1): out.append(store(BIG.multiply(out[-1], r)))\n+ return out\n+\n+def block_vectors(L, bc, mode):\n+ \"\"\"Return the four GS vectors of T_c (x_c, yt_c, Zy_c, Zxt_c) in fixed point.\"\"\"\n+ B = base[L]; n = L\n+ rho = (-PI*a2*dec(2*bc + 1)).exp() # <= 1\n+ if mode in (0, 4):\n+ rr = fix((-PI*a2*dec(1 - 2*bc)).exp()) # rho_+/rho_c <= 1\n+ pr, pc = powers(rr, n + 1, fix), powers(fix(rho), n + 1, fix)\n+ X, Y = [fix(v) for v in B['xp']], [fix(v) for v in B['ym']]\n+ xc = [fix(pr[i]*X[i]) for i in range(n)]\n+ ytc = [fix(pc[k]*Y[n-1-k]) for k in range(n)]\n+ Zyc = [Dm(0)] + [fix(pc[n-k]*Y[k-1]) for k in range(1, n)]\n+ Zxtc = [Dm(0)] + [fix(pr[n-k]*X[n-k]) for k in range(1, n)]\n+ return xc, ytc, Zyc, Zxtc\n+ X, Y = (B['xq'], B['yq']) if mode == 3 else (B['xf'], B['yf'])\n+ st = fix if mode == 3 else flt\n+ up = powers(flt(rho), n + 1, flt); dn = powers(flt(1/rho), n + 1, flt) # rho^{+-i}, floating\n+ xc = [fix(dn[i]*X[i]) for i in range(n)]\n+ ytc = [fix(up[k]*Y[n-1-k]) for k in range(n)]\n+ if mode == 2: # each factor conjugated by G_c separately\n+ Zyc = [Dm(0)] + [fix(dn[k]*Y[k-1]) for k in range(1, n)]\n+ Zxtc = [Dm(0)] + [fix(up[k]*X[n-k]) for k in range(1, n)]\n+ else: # balanced: rho^{n-k} and rho^{-(n-k)}\n+ Zyc = [Dm(0)] + [fix(up[n-k]*Y[k-1]) for k in range(1, n)]\n+ Zxtc = [Dm(0)] + [fix(dn[n-k]*X[n-k]) for k in range(1, n)]\n+ return xc, ytc, Zyc, Zxtc\n+\n+lowmul = lambda v, z: [fix(sum(v[a-k]*z[k] for k in range(a+1))) for a in range(len(z))]\n+upmul = lambda v, z: [fix(sum(v[b-a]*z[b] for b in range(a, len(z)))) for a in range(len(z))]\n+\n+def apply_gs(vecs, z):\n+ xc, ytc, Zyc, Zxtc = vecs\n+ p1 = lowmul(xc, upmul(ytc, z)); p2 = lowmul(Zyc, upmul(Zxtc, z))\n+ return [fix((p1[i] - p2[i]) / xc[0]) if xc[0] != 0 else Dm(0) for i in range(len(z))]\n+\n+# --- bound checks on the exact rescaled factors (Lemma: entry envelope of T_c^{-1}) ---\n+worst_env = 0.0; worst_p = 0.0\n+for g in blocks[:40]:\n+ L = len(g); bc = beta(g[0]); n = L; B = base[L]\n+ rho = (-PI*a2*dec(2*bc + 1)).exp()\n+ kp = 2*(-PI*a2*dec(sig + 2*bc)).exp(); km = 2*(-PI*a2*dec(sig - 2*bc)).exp()\n+ env = lambda h: min(Dm('1.12'), Dm('2.0001') * (kp**h if h > 0 else km**(-h)) if h else Dm('1.12'))\n+ x, y = B['x'], B['y']\n+ xc = [x[i] * rho**(-i) for i in range(n)]; ytc = [y[n-1-k] * rho**k for k in range(n)]\n+ Zyc = [Dm(0)] + [y[k-1] * rho**(n-k) for k in range(1, n)]\n+ Zxtc = [Dm(0)] + [x[n-k] * rho**(k-n) for k in range(1, n)]\n+ for i in range(n):\n+ worst_env = max(worst_env, float(abs(xc[i]) / env(-i)), float(abs(ytc[i]) / env(i)))\n+ if i: worst_env = max(worst_env, float(abs(Zyc[i]) / env(n-i)), float(abs(Zxtc[i]) / env(-(n-i))))\n+ for a in range(n):\n+ for b in range(n):\n+ m = min(a, b)\n+ s1 = sum(abs(xc[a-k]*ytc[b-k]) for k in range(m+1))\n+ s2 = sum(abs(Zyc[a-k]*Zxtc[b-k]) for k in range(m+1))\n+ worst_p = max(worst_p, float(s1 / (Dm('1.13')*env(b-a))), float(s2 / (Dm(4)*kp*km*env(b-a))))\n+print(f'envelope check: max |factor entry| / envelope = {worst_env:.3f}, '\n+ f'max partial-product term sum / bound = {worst_p:.3f}', 'OK' if worst_env <= 1 and worst_p <= 1 else 'VIOLATED')\n+ok = worst_env <= 1 and worst_p <= 1\n+\n+# --- full solve per mode ---\n+random.seed(2)\n+u = [Dm(random.uniform(-1, 1)) for _ in range(s)]\n+xdir = solve(N, u)\n+bid = {}\n+for k, g in enumerate(blocks):\n+ for j in g: bid[j % s] = k\n+thr = Dm(2)**(-Qbits - int(math.log2(s)) - 4)\n+Delta = [[N[a][b] if bid[a] != bid[b] and N[a][b] > thr else Dm(0) for b in range(s)] for a in range(s)]\n+cols = sorted({b for a in range(s) for b in range(s) if Delta[a][b] != 0})\n+target = Dm(2)**-Qbits\n+# Fixed-point storage of T_lambda's vectors loses min(10^-P, |x_i|) on x_i (y is O(1), so it keeps\n+# relative precision). The rescale rho_c^{-i} and the chirp ratio D_a/D_b, largest for\n+# (a, b) = (L-1, L-1-i), amplify that loss. Predict whether it exceeds the target here.\n+def fp_loss_bits(g):\n+ L = len(g); x = base[L]['x']; lr = math.pi * a2 * float(2*beta(g[0]) + 1)\n+ return max(math.log2(10) * min(-Pdig, float(abs(x[i]).log10()))\n+ + math.log2(math.e) * (lr * i + math.pi * a2 * float(th) * ((L-1)**2 - (L-1-i)**2))\n+ for i in range(1, L))\n+amp = max(fp_loss_bits(g) for g in blocks)\n+fp_fails = amp > -Qbits\n+Plow = math.ceil((Qbits + 2*math.log2(lam) + 8) / math.log2(10)) # drops the chirp reserve R_D\n+print(f's,t=({s},{t}) theta={float(th):.4f} alpha2*theta={a2*float(th):.2f} w={w} lengths={lengths} '\n+ f'R_D={RD:.0f} bits Q={Qbits} P={Pdig} digits ({Pdig*math.log2(10):.0f} bits)')\n+for mode, pd, expect in ((0, Pdig, True), (1, Pdig, True), (2, Pdig, None),\n+ (3, Pdig, False if fp_fails else None), (4, Plow, False)):\n+ PREC['d'] = pd; cache = {}\n+ def Minv(vec):\n+ out = [Dm(0)]*s\n+ for k, g in enumerate(blocks):\n+ L = len(g)\n+ if k not in cache: cache[k] = block_vectors(L, beta(g[0]), mode)\n+ z = [fix(vec[g[i] % s] * (-PI*a2*dec(th*i*i)).exp()) for i in range(L)]\n+ yv = apply_gs(cache[k], z)\n+ for i in range(L): out[g[i] % s] = yv[i] * (PI*a2*dec(th*i*i)).exp()\n+ return out\n+ y0 = Minv(u)\n+ MU = [Minv([Delta[r][c] for r in range(s)]) for c in cols]\n+ C = [[(Dm(1) if i == j else Dm(0)) + MU[j][cols[i]] for j in range(len(cols))] for i in range(len(cols))]\n+ try:\n+ z = solve(C, [y0[c] for c in cols], pivot=False)\n+ xs = [y0[r] - sum(MU[j][r]*z[j] for j in range(len(cols))) for r in range(s)]\n+ err = max(abs(xs[i] - xdir[i]) for i in range(s))\n+ except Exception:\n+ err = Dm(1)\n+ passed = err < target\n+ if expect is not None: ok &= passed == expect\n+ extra = ''\n+ if mode == 2: # integer headroom the unbalanced factor L(rho^-k Zy) needs in fixed point\n+ extra = f' unbalanced factor max log2|entry|={max(float(abs(v).ln()/Dm(2).ln()) for vs in cache.values() for v in vs[2] if v):.0f}'\n+ if mode == 3: extra = f' predicted loss=2^{amp:.0f}'\n+ if mode == 4: extra = f' (P={pd} digits, no chirp reserve)'\n+ exp = 'report only' if expect is None else ('expected PASS' if expect else 'expected FAIL')\n+ print(f' mode {mode}: err={float(err):.3e} {\"PASS\" if passed else \"FAIL\"} ({exp}){extra}')\n+if not ok: raise SystemExit(1)" + }, + { + "sha": "b4c481350ad8890d479fdcf954f79a04c15cd548", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_identities.py", + "status": "added", + "additions": 57, + "deletions": 0, + "changes": 57, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_identities.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_identities.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_identities.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,57 @@\n+\"\"\"Exact checks of the Gaussian correction structure used by the segmented inverse.\n+\n+For s < t with sigma = t/s, q_j = floor(t j/s + 1/2) and beta_j = t j/s - q_j, the\n+exponent of N's entry (l, j) is X = (sigma j - q_l)^2 - beta_j^2. We check, in exact\n+rational arithmetic:\n+ 1. X = n (n + 2 beta_j) with n = q_j - q_l;\n+ 2. inside a wrap-free segment, X = (1+theta) h^2 - h + theta (v^2 - u^2), with\n+ h = j - l, u = l - l*, v = j - l*, and l* = l - (beta_l + 1/2)/theta;\n+ 3. every pair in different segments (n != j - l) has X >= 2;\n+ 4. for any centre c in the same segment as l and j, with u = l - c and v = j - c,\n+ X = sigma h^2 + 2 beta_c h + theta (v^2 - u^2).\n+\"\"\"\n+from fractions import Fraction as F\n+import json, math, sys\n+\n+\n+def check(s, t, periods=3, band=30):\n+ sig = F(t, s); th = sig - 1\n+ q = lambda j: math.floor(F(t * j, s) + F(1, 2))\n+ beta = lambda j: F(t * j, s) - q(j)\n+ counts = dict(closed_form=0, segment=0, cross=0)\n+ cross_min = None\n+ for l in range(periods * s):\n+ lstar = l - (beta(l) + F(1, 2)) / th\n+ for j in range(l - band, l + band + 1):\n+ if j == l:\n+ continue\n+ X = (sig * j - q(l)) ** 2 - beta(j) ** 2\n+ n = q(j) - q(l)\n+ if X != n * (n + 2 * beta(j)):\n+ raise AssertionError(f'closed form fails at s={s} t={t} l={l} j={j}')\n+ counts['closed_form'] += 1\n+ h, u, v = j - l, l - lstar, j - lstar\n+ if n == h:\n+ if X != (1 + th) * h * h - h + th * (v * v - u * u):\n+ raise AssertionError(f'segment form fails at s={s} t={t} l={l} j={j}')\n+ counts['segment'] += 1\n+ for c in (l - 3, l - 1, l + 2):\n+ if q(c) - c == q(l) - l and q(c) - c == q(j) - j:\n+ uc, vc = l - c, j - c\n+ if X != sig * h * h + 2 * beta(c) * h + th * (vc * vc - uc * uc):\n+ raise AssertionError(f'recentred form fails at s={s} t={t} l={l} j={j} c={c}')\n+ counts['recentred'] = counts.get('recentred', 0) + 1\n+ else:\n+ if X < 2:\n+ raise AssertionError(f'cross-wrap bound fails at s={s} t={t} l={l} j={j}')\n+ cross_min = X if cross_min is None else min(cross_min, X)\n+ counts['cross'] += 1\n+ return dict(s=s, t=t, theta=str(th), checks=counts, min_cross_exponent=str(cross_min))\n+\n+\n+CASES = [(113, 128), (241, 256), (1009, 1024), (1019, 1024), (4093, 4096)]\n+\n+if __name__ == '__main__':\n+ out = [check(s, t) for s, t in CASES]\n+ json.dump(out, open('certificates/identities.json', 'w'), indent=1)\n+ print('PASS exact identities for', ', '.join(f'(s,t)=({c[\"s\"]},{c[\"t\"]})' for c in out))" + }, + { + "sha": "447418acb431af6110b10f62f9581378cf24f1bf", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_reuse_inverse.py", + "status": "added", + "additions": 103, + "deletions": 0, + "changes": 103, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_reuse_inverse.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_reuse_inverse.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_reuse_inverse.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,103 @@\n+\"\"\"Numerical check of the recentred sub-block inverse through the reuse path.\n+\n+One inverse of the base Toeplitz matrix T_lambda (symbol exp(-pi a2 (sigma h^2 - h))) is\n+computed per block length at high precision, then stored with P significant digits (floating\n+point). Every block applies T_c^{-1} = G_c T_lambda^{-1} G_c^{-1}, with\n+G_c = diag(rho_c^{-i}) and rho_c = exp(-pi a2 (2 beta_c + 1)). Segments are split into\n+near-equal blocks of length at least 2w. Cuts and wraps are coupled by Woodbury, and the\n+capacitance system is solved by elimination without pivoting. The result is compared with a\n+direct solve of N.\n+Args: s t alpha^2 Q_bits P_digits [1 = fixed-point storage, expected to fail].\n+\"\"\"\n+from decimal import Decimal as Dm, getcontext, Context\n+from fractions import Fraction as F\n+import math, sys, random\n+\n+argv = [int(a) for a in sys.argv[1:]] or [241, 256, 17, 150, 60]\n+s, t, a2, Qbits, Pdig = argv[:5]\n+FIXED_POINT = len(argv) > 5 and argv[5] == 1 # negative control: absolute precision storage\n+getcontext().prec = 140\n+PI = Dm('3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612847564823378678316527120190914564856692346034861045432664821339360726024914127372458700660631558817488152092096282925409171536436789259036001133053054882046652138414695194151160943305727036575959195309218611738193261179310511854807446237996274956735188575272489122793818301194912983367336244065664308602139494639522473719070217986094370277053921717629317675238467481846766940513200056812714526356082778577134275778960917363717872146844090122495343014654958537105079227968925892354201995611212902196086403441815981362977477130996051870721134999999837297804995105973173281609631859502445945534690830264252230825334468503526193118817101000313783875288658753320838142061717766914730359825349042875546873115956286388235378759375195778185778053217122680661300192787661119590921642019893809525720106548586327')\n+sig = F(t, s); th = sig - 1\n+q = lambda j: math.floor(F(t*j, s) + F(1, 2)); beta = lambda j: F(t*j, s) - q(j)\n+dec = lambda f: Dm(f.numerator) / Dm(f.denominator)\n+E = lambda x: (-PI*a2*dec(x)).exp()\n+\n+def solve(A, bv, pivot=True):\n+ n = len(A); M = [row[:] + [bv[i]] for i, row in enumerate(A)]\n+ for c in range(n):\n+ if pivot:\n+ p = max(range(c, n), key=lambda r: abs(M[r][c])); M[c], M[p] = M[p], M[c]\n+ for r in range(n):\n+ if r != c and M[r][c] != 0:\n+ f = M[r][c] / M[c][c]\n+ for k in range(c, n+1): M[r][k] -= f*M[c][k]\n+ return [M[i][n] / M[i][i] for i in range(n)]\n+\n+def inverse(A):\n+ n = len(A)\n+ cols = [solve(A, [Dm(1) if i == j else Dm(0) for i in range(n)]) for j in range(n)]\n+ return [[cols[j][i] for j in range(n)] for i in range(n)]\n+\n+N = [[Dm(0)]*s for _ in range(s)]\n+for l in range(s):\n+ for j in range(l - 2*s, l + 2*s):\n+ X = (sig*j - q(l))**2 - beta(j)**2\n+ if X < 60:\n+ N[l][j % s] += E(X)\n+wraps = [j for j in range(s) if q(j+1) - q(j) == 2]\n+w = 1 + math.isqrt(int(Qbits / (4.53 * a2)) + 1)\n+blocks = []\n+for i, w0 in enumerate(wraps):\n+ st = w0 + 1; en = wraps[(i+1) % len(wraps)] + (s if i+1 == len(wraps) else 0)\n+ seg = list(range(st, en + 1))\n+ nb = max(1, len(seg) // (2*w))\n+ cuts = [round(k * len(seg) / nb) for k in range(nb + 1)]\n+ blocks += [seg[cuts[k]:cuts[k+1]] for k in range(nb)]\n+lengths = sorted({len(g) for g in blocks})\n+assert min(lengths) >= 2*w, (lengths, w)\n+base = {}\n+for L in lengths:\n+ getcontext().prec = Pdig + int(9.06 * a2 * L / 3.32) + 20 # absolute precision P + 9.06 a2 L bits\n+ T = [[E(sig*(b-a)**2 - (b-a)) for b in range(L)] for a in range(L)]\n+ Ti = inverse(T)\n+ getcontext().prec = 140\n+ ctx = Context(prec=Pdig)\n+ if FIXED_POINT:\n+ unit = Dm(10) ** -Pdig\n+ base[L] = [[(v / unit).to_integral_value() * unit for v in row] for row in Ti]\n+ else:\n+ base[L] = [[ctx.plus(v) for v in row] for row in Ti] # floating point, P significant digits\n+random.seed(2)\n+u = [Dm(random.uniform(-1, 1)) for _ in range(s)]\n+x = solve(N, u)\n+bid = {}\n+for k, g in enumerate(blocks):\n+ for j in g: bid[j % s] = k\n+\n+def Minv(vec):\n+ out = [Dm(0)]*s\n+ for g in blocks:\n+ c = g[0]; bc = beta(c); L = len(g)\n+ rho = (-PI*a2*dec(2*bc + 1)).exp()\n+ Ti = base[L]\n+ rhs = [vec[g[i] % s] * (-PI*a2*dec(th*i*i)).exp() for i in range(L)]\n+ y = [sum(rho**(b - a) * Ti[a][b] * rhs[b] for b in range(L)) for a in range(L)] # G T^-1 G^-1\n+ for i in range(L): out[g[i] % s] = y[i] * (PI*a2*dec(th*i*i)).exp()\n+ return out\n+\n+thr = Dm(2)**(-Qbits - int(math.log2(s)) - 4)\n+Delta = [[N[a][b] if bid[a] != bid[b] and N[a][b] > thr else Dm(0) for b in range(s)] for a in range(s)]\n+cols = sorted({b for a in range(s) for b in range(s) if Delta[a][b] != 0})\n+y = Minv(u)\n+MU = [Minv([Delta[r][c] for r in range(s)]) for c in cols]\n+C = [[(Dm(1) if i == j else Dm(0)) + MU[j][cols[i]] for j in range(len(cols))] for i in range(len(cols))]\n+offdiag = max(abs(C[i][j]) for i in range(len(cols)) for j in range(len(cols)) if i != j)\n+z = solve(C, [y[c] for c in cols], pivot=False)\n+xs = [y[r] - sum(MU[j][r]*z[j] for j in range(len(cols))) for r in range(s)]\n+err = max(abs(xs[i] - x[i]) for i in range(s))\n+target = Dm(2)**-Qbits\n+print(f'theta={float(th):.4f} alpha2*theta={a2*float(th):.2f} w={w} block lengths={lengths} blocks={len(blocks)} '\n+ f'max|C-I| offdiag={float(offdiag):.2e} err={float(err):.3e} target={float(target):.3e}',\n+ 'PASS' if err < target else 'FAIL')\n+if err >= target: raise SystemExit(1)" + }, + { + "sha": "089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_segmented_inverse.py", + "status": "added", + "additions": 89, + "deletions": 0, + "changes": 89, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_segmented_inverse.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_segmented_inverse.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_segmented_inverse.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,89 @@\n+\"\"\"Numerical check of the segmented inverse (Idea B') against a direct solve.\n+\n+Builds the s x s Gaussian correction N with cyclic indices at 260 decimal digits, checks\n+that each segment block equals D T D^{-1}, then applies N^{-1} by block Gohberg-Semencul\n+style segment solves plus a Woodbury correction on the cross-wrap columns, and compares\n+with Gaussian elimination on N. Arguments: s t alpha^2 Q_bits P1_digits P2_digits.\n+\"\"\"\n+from decimal import Decimal as Dm, getcontext\n+from fractions import Fraction as F\n+import math, sys, random\n+args=[int(a) for a in sys.argv[1:]] or [60, 67, 9, 200, 120, 100]\n+s,t,a2,Qbits,P1,P2=args\n+getcontext().prec=260\n+PI=Dm('3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196')\n+sig=F(t,s); th=sig-1\n+q=lambda j: math.floor(F(t*j,s)+F(1,2)); beta=lambda j:F(t*j,s)-q(j)\n+dec=lambda f: Dm(f.numerator)/Dm(f.denominator)\n+E=lambda x:(-PI*a2*dec(x)).exp()\n+N=[[Dm(0)]*s for _ in range(s)]\n+for l in range(s):\n+ for j in range(l-3*s,l+3*s):\n+ X=(sig*j-q(l))**2-beta(j)**2\n+ N[l][j%s]+=E(X)\n+# segments on Z/sZ: start at index after a wrap\n+wraps=[j for j in range(s) if q(j+1)-q(j)==2]\n+segs=[]\n+for i,w0 in enumerate(wraps):\n+ st=w0+1; en=wraps[(i+1)%len(wraps)]+ (s if i+1==len(wraps) else 0)\n+ segs.append(list(range(st,en+1)))\n+print('theta',float(th),'nwraps',len(wraps),'seglens',sorted(set(len(g) for g in segs)))\n+# check M_k = D T D^{-1} vs principal block of N (cyclic indices)\n+maxerr=Dm(0)\n+for g in segs:\n+ l0=g[0]; ls=l0-(beta(l0)+F(1,2))/th\n+ for a in g:\n+ for b in g:\n+ h=b-a; u=a-ls; v=b-ls\n+ val=E(sig*h*h-h)* (PI*a2*dec(th*u*u)).exp()*(-PI*a2*dec(th*v*v)).exp()\n+ maxerr=max(maxerr,abs(val-N[a%s][b%s]))\n+print('max |M_k - N block| =',float(maxerr))\n+def solve(A,bv):\n+ n=len(A); M=[row[:]+[bv[i]] for i,row in enumerate(A)]\n+ for c in range(n):\n+ p=max(range(c,n),key=lambda r:abs(M[r][c])); M[c],M[p]=M[p],M[c]\n+ for r in range(n):\n+ if r!=c and M[r][c]!=0:\n+ f=M[r][c]/M[c][c]\n+ for k in range(c,n+1): M[r][k]-=f*M[c][k]\n+ return [M[i][n]/M[i][i] for i in range(n)]\n+random.seed(1)\n+u=[Dm(random.uniform(-1,1)) for _ in range(s)]\n+x=solve(N,u)\n+# segmented: M^{-1} via Toeplitz solve with D scaling at reduced precision P digits\n+lam=Dm(2)**(-Qbits-int(math.log2(s))-4)\n+w=1+math.sqrt(Qbits/(4.53*a2))\n+print('w formula',w)\n+def Minv(vec,Pdig):\n+ out=[Dm(0)]*s\n+ for g in segs:\n+ l0=g[0]; ls=l0-(beta(l0)+F(1,2))/th; L=len(g)\n+ getcontext().prec=Pdig\n+ T=[[+E(sig*(b-a)**2-(b-a)) for b in range(L)] for a in range(L)]\n+ rhs=[+(vec[g[i]%s]*(-PI*a2*dec(th*(i+l0-ls)**2)).exp()) for i in range(L)]\n+ y=solve(T,rhs)\n+ getcontext().prec=260\n+ for i in range(L): out[g[i]%s]=y[i]*(PI*a2*dec(th*(i+l0-ls)**2)).exp()\n+ return out\n+segid={}\n+for k,g in enumerate(segs):\n+ for j in g: segid[j%s]=k\n+Delta=[[N[a][b] if segid[a]!=segid[b] and N[a][b]>lam else Dm(0) for b in range(s)] for a in range(s)]\n+cols=sorted({b for a in range(s) for b in range(s) if Delta[a][b]!=0})\n+# max column offset from nearest wrap\n+print('Delta cols',len(cols),'per wrap',len(cols)/len(wraps))\n+fails=0\n+for Pdig in [P1,P2]:\n+ y=Minv(u,Pdig)\n+ # Woodbury capacitance solve\n+ MU=[Minv([Delta[r][c] for r in range(s)],Pdig) for c in cols]\n+ C=[[ (Dm(1) if i==j else Dm(0)) + MU[j][cols[i]] for j in range(len(cols))] for i in range(len(cols))]\n+ z=solve(C,[y[c] for c in cols])\n+ xs=[y[r]-sum(MU[j][r]*z[j] for j in range(len(cols))) for r in range(s)]\n+ err=max(abs(xs[i]-x[i]) for i in range(s))\n+ ok=err0}))\n+\n+if fails: raise SystemExit('segmented inverse check failed')" + }, + { + "sha": "a9876c9fc01ca077dcaf13b095019357560ffd6c", + "filename": "research/deferred-signed/swapnil-round7/scripts/check_subblock_inverse.py", + "status": "added", + "additions": 73, + "deletions": 0, + "changes": 73, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_subblock_inverse.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_subblock_inverse.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Fscripts%2Fcheck_subblock_inverse.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,73 @@\n+\"\"\"Numerical check of the recentred sub-block inverse against a direct solve. Args: s t alpha^2 Q_bits block_len P_digits.\"\"\"\n+# Sub-blocked segmented inverse: cut segments into blocks of length lam, recentre the chirp\n+# per block (block Toeplitz T_c = G T G^{-1}), couple all cuts and wraps by Woodbury.\n+from decimal import Decimal as Dm, getcontext\n+from fractions import Fraction as F\n+import math, sys, random\n+s, t, a2, Qbits, lam, Pdig = [int(a) for a in sys.argv[1:]] or [60, 67, 9, 200, 3, 120]\n+getcontext().prec = 260\n+PI = Dm('3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196')\n+sig = F(t, s); th = sig - 1\n+q = lambda j: math.floor(F(t*j, s) + F(1, 2)); beta = lambda j: F(t*j, s) - q(j)\n+dec = lambda f: Dm(f.numerator) / Dm(f.denominator)\n+E = lambda x: (-PI*a2*dec(x)).exp()\n+N = [[Dm(0)]*s for _ in range(s)]\n+for l in range(s):\n+ for j in range(l-3*s, l+3*s):\n+ N[l][j % s] += E((sig*j - q(l))**2 - beta(j)**2)\n+wraps = [j for j in range(s) if q(j+1) - q(j) == 2]\n+segs = []\n+for i, w0 in enumerate(wraps):\n+ st = w0 + 1; en = wraps[(i+1) % len(wraps)] + (s if i+1 == len(wraps) else 0)\n+ segs.append(list(range(st, en+1)))\n+blocks = [g[k:k+lam] for g in segs for k in range(0, len(g), lam)]\n+def solve(A, bv):\n+ n = len(A); M = [row[:] + [bv[i]] for i, row in enumerate(A)]\n+ for c in range(n):\n+ p = max(range(c, n), key=lambda r: abs(M[r][c])); M[c], M[p] = M[p], M[c]\n+ for r in range(n):\n+ if r != c and M[r][c] != 0:\n+ f = M[r][c] / M[c][c]\n+ for k in range(c, n+1): M[r][k] -= f*M[c][k]\n+ return [M[i][n] / M[i][i] for i in range(n)]\n+# check block = D_c T_c D_c^{-1} with T_c symbol exp(-pi a2 (sigma h^2 + 2 beta_c h)), centre c = first index\n+maxerr = Dm(0)\n+for g in blocks:\n+ c = g[0]; bc = beta(c)\n+ for a in g:\n+ for b in g:\n+ h = b - a; u = a - c; v = b - c\n+ Tc = E(sig*h*h + 2*bc*h)\n+ # exact: X = (sigma h + beta_a)^2 - beta_b^2 with beta linear in-segment\n+ X = (sig*h + beta(a))**2 - beta(b)**2\n+ Dfac = (PI*a2*dec(th*u*u)).exp() * (-PI*a2*dec(th*v*v)).exp()\n+ maxerr = max(maxerr, abs(Tc*Dfac - E(X)))\n+print('blocks', len(blocks), 'max |block - D_c T_c D_c^-1| = %.2e' % float(maxerr))\n+random.seed(1)\n+u = [Dm(random.uniform(-1, 1)) for _ in range(s)]\n+x = solve(N, u)\n+bid = {}\n+for k, g in enumerate(blocks):\n+ for j in g: bid[j % s] = k\n+thr = Dm(2)**(-Qbits - int(math.log2(s)) - 4)\n+def Minv(vec):\n+ out = [Dm(0)]*s\n+ for g in blocks:\n+ c = g[0]; bc = beta(c); L = len(g)\n+ getcontext().prec = Pdig\n+ T = [[+E(sig*(b-a)**2 + 2*bc*(b-a)) for b in range(L)] for a in range(L)]\n+ rhs = [+(vec[g[i] % s] * (-PI*a2*dec(th*i*i)).exp()) for i in range(L)]\n+ y = solve(T, rhs)\n+ getcontext().prec = 260\n+ for i in range(L): out[g[i] % s] = y[i] * (PI*a2*dec(th*i*i)).exp()\n+ return out\n+Delta = [[N[a][b] if bid[a] != bid[b] and N[a][b] > thr else Dm(0) for b in range(s)] for a in range(s)]\n+cols = sorted({b for a in range(s) for b in range(s) if Delta[a][b] != 0})\n+y = Minv(u)\n+MU = [Minv([Delta[r][c] for r in range(s)]) for c in cols]\n+C = [[(Dm(1) if i == j else Dm(0)) + MU[j][cols[i]] for j in range(len(cols))] for i in range(len(cols))]\n+z = solve(C, [y[c] for c in cols])\n+xs = [y[r] - sum(MU[j][r]*z[j] for j in range(len(cols))) for r in range(s)]\n+err = max(abs(xs[i] - x[i]) for i in range(s))\n+print('cuts+wraps', len(blocks), 'coupled cols', len(cols), 'err vs direct %.3e target %.3e' % (float(err), float(Dm(2)**-Qbits)),\n+ 'PASS' if err < Dm(2)**-Qbits else 'FAIL')" + }, + { + "sha": "33116082d2d11bbcfa0144c54dda5c6b8fb42e1c", + "filename": "research/deferred-signed/swapnil-round7/tests/test_round3.py", + "status": "added", + "additions": 30, + "deletions": 0, + "changes": 30, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round3.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round3.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round3.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,30 @@\n+import importlib.util, pathlib, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+spec = importlib.util.spec_from_file_location('certificate_round3', ROOT / 'scripts' / 'certificate_round3.py')\n+r3 = importlib.util.module_from_spec(spec); spec.loader.exec_module(r3)\n+\n+A_B = Q(22157, 5 * 10**9)\n+A_C = Q(1048009, 25 * 10**10) # fully batched PR #7 complex network, independent/complex-network\n+KAPPA = Q(13086957581, 3125 * 10**12)\n+\n+\n+class Round3(unittest.TestCase):\n+ def test_headline_both_guards(self):\n+ for guard in ('pathwise', 'crude'):\n+ r = r3.evaluate(A_B, A_C, Q(1, 1000), guard)\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], KAPPA)\n+ self.assertEqual(r['binding'], 'simultaneous butterflies')\n+ self.assertGreater(r['kappa'], Q(1, 2**18))\n+\n+ def test_complex_side_binds(self):\n+ # raising a_c must raise kappa; raising a_b must not\n+ k = r3.evaluate(A_B, A_C, Q(1, 1000), 'crude')['kappa']\n+ self.assertGreater(r3.evaluate(A_B, A_C * 2, Q(1, 1000), 'crude')['kappa'], k)\n+ self.assertEqual(r3.evaluate(A_B * 2, A_C, Q(1, 1000), 'crude')['kappa'], k)\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "68bb03e902271d87c59a102e0a83205d87cc870e", + "filename": "research/deferred-signed/swapnil-round7/tests/test_round4.py", + "status": "added", + "additions": 44, + "deletions": 0, + "changes": 44, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round4.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round4.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round4.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,44 @@\n+import importlib.util, pathlib, sys, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'independent' / 'two-stage-bit'))\n+import moment\n+spec = importlib.util.spec_from_file_location('certificate_round3', ROOT / 'scripts' / 'certificate_round3.py')\n+r3 = importlib.util.module_from_spec(spec); spec.loader.exec_module(r3)\n+\n+A_C = Q(4079603, 25 * 10**10) # fully batched PR #7 complex network with source frames, h=28\n+\n+\n+class Round4(unittest.TestCase):\n+ def test_bit_histogram_and_saving(self):\n+ c = moment.histogram(47, moment.R_of(47), True)\n+ self.assertEqual(sum(w * n for w, n in c['hist'].items()), c['s'])\n+ self.assertEqual(c['W'] * c['m'] - c['s'], c['v'] * (c['v'] - 4 * 47 * 47))\n+ a, _ = moment.certify(c)\n+ self.assertEqual(a, Q(10033, 10**9))\n+\n+ def test_data_batching_needed(self):\n+ c = moment.histogram(47, moment.R_of(47), False)\n+ a, _ = moment.certify(c)\n+ self.assertLess(a, Q(10033, 10**9))\n+\n+ def test_pr24_headline(self):\n+ sys.path.insert(0, str(ROOT / 'scripts'))\n+ import certificate_round4 as c4\n+ a, c = c4.pr24_bit_saving()\n+ self.assertEqual(a, Q(4788949, 4 * 10**11))\n+ r = r3.evaluate(a, A_C, Q(1, 1000), 'crude')\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], Q(59861145819, 5 * 10**15))\n+ self.assertGreater(r['kappa'], Q(119720853, 10**13))\n+\n+ def test_kappa(self):\n+ r = r3.evaluate(Q(10033, 10**9), A_C, Q(1, 1000), 'crude')\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['binding'], 'simultaneous butterflies')\n+ self.assertGreater(r['kappa'], Q(1, 2**17))\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "f88e4647631a1b525faac9151fa76f0534edfd15", + "filename": "research/deferred-signed/swapnil-round7/tests/test_round5.py", + "status": "added", + "additions": 46, + "deletions": 0, + "changes": 46, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round5.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round5.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round5.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,46 @@\n+import importlib.util, pathlib, sys, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+sys.path.insert(0, str(ROOT / 'independent' / 'two-stage-bit'))\n+import certificate_round5 as c5\n+import certificate_round3 as r3\n+\n+A_C = Q(4079603, 25 * 10**10)\n+\n+\n+class Round5(unittest.TestCase):\n+ def test_flag_histogram_and_saving(self):\n+ a, c = c5.bit_saving(side=False)\n+ self.assertEqual(c['R'], 403248)\n+ self.assertEqual(sum(w * n for w, n in c['hist'].items()), c['s'])\n+ self.assertEqual(a, Q(3369, 250000000)) # flag basis and data runs, side roles as singletons\n+\n+ def test_side_lemma_saving(self):\n+ a, c = c5.bit_saving(side=True)\n+ self.assertEqual(sum(w * n for w, n in c['hist'].items()), c['s'])\n+ self.assertEqual(a, Q(15479, 10**9))\n+ r = r3.evaluate(a, A_C, Q(1, 1000), 'crude')\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], Q(309575208081, 2 * 10**16))\n+ self.assertGreater(r['kappa'], Q(1, 2**16))\n+\n+ def test_flag_beats_singleton_corners(self):\n+ # same histogram with the h corner transpositions charged as singletons is strictly worse\n+ import moment\n+ c = c5.flag_histogram(47, 403248)\n+ h, A = 47, None\n+ a_flag, _ = moment.certify(c)\n+ base = moment.histogram(47, 403248, True)\n+ a_base, _ = moment.certify(base)\n+ self.assertGreater(a_flag, a_base)\n+\n+ def test_kappa(self):\n+ r = r3.evaluate(Q(13341, 10**9), A_C, Q(1, 1000), 'crude')\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], Q(333520550497, 25 * 10**15))\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "5af8799c2c1df73d277b3ca38dabc1b9d8b64b05", + "filename": "research/deferred-signed/swapnil-round7/tests/test_round6.py", + "status": "added", + "additions": 32, + "deletions": 0, + "changes": 32, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round6.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round6.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round6.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,32 @@\n+import pathlib, sys, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+import certificate_round6 as c6\n+import certificate_round3 as r3\n+\n+A_C = Q(36926111, 5 * 10**11) # two-stage complex interchange, h = 24\n+M_C, S_C = 576, 119453132304\n+\n+\n+class Round6(unittest.TestCase):\n+ def test_copied_bit_saving(self):\n+ a, c = c6.bit_saving()\n+ self.assertEqual((c['R'], c['W'] * c['m'] - c['s']), (52788, 2415000))\n+ self.assertEqual(a, Q(34919, 10**9))\n+\n+ def test_retained_totals_saving(self):\n+ a, c = c6.retained_saving()\n+ self.assertEqual((c['R'], c['s']), (40077, 78410006675))\n+ self.assertEqual(a, Q(36667, 10**9))\n+\n+ def test_kappa(self):\n+ r = r3.evaluate(Q(36667, 10**9), A_C, Q(1, 1000), 'crude', m_c=M_C, s_c=S_C)\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], Q(3666565558019, 10**17))\n+ self.assertGreater(r['kappa'], Q(1, 2**15))\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "ad6d0de81e1c3cdc38f860b28619be93f597f475", + "filename": "research/deferred-signed/swapnil-round7/tests/test_round7.py", + "status": "added", + "additions": 54, + "deletions": 0, + "changes": 54, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round7.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round7.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_round7.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,54 @@\n+import pathlib, sys, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+sys.path.insert(0, str(ROOT / 'independent' / 'deferred-readout'))\n+import certificate_round7 as c7\n+import deferred as dr\n+\n+\n+class Round7(unittest.TestCase):\n+ @classmethod\n+ def setUpClass(cls):\n+ cls.S, cls.rk, cls.ylev, cls.xd = c7.build(c7.WITNESSES[0])\n+\n+ def test_schedule_shape(self):\n+ S = self.S\n+ self.assertEqual((S.h, S.R, len(S.readout), len(S.vstart)), (23, 28866, 11565, 11374))\n+ self.assertEqual(S.readout, sorted(S.readout, key=lambda s: (S.f[s], s))) # readouts by dim sigma\n+ dv = {s: len(B) for s, B in S.vstart.items()}\n+ self.assertEqual(S.late_v, sorted(S.late_v, key=lambda s: (dv[s], s))) # deferred V gates by dim s_i\n+ self.assertTrue(all(sum(x) == S.h - 1 for x in self.xd))\n+\n+ def test_chain_ranks_are_corner_ranks(self):\n+ S = self.S\n+ self.assertEqual(sum(r * c for r, c in self.rk.items()), sum(S.h - S.f[s] for s in range(S.R)))\n+\n+ def test_savings(self):\n+ for key, _, corner in c7.CORNERS:\n+ a, c = c7.saving(self.S, self.rk, self.ylev, self.xd, corner(self.S.h))\n+ self.assertEqual(sum(w * n for w, n in c['hist'].items()), c['s'])\n+ self.assertEqual(c['s'], c['W'] * c['m'] - c['N'] + c['L'])\n+ self.assertEqual(a, c7.WITNESSES[0][key][0])\n+\n+ def test_kappa(self):\n+ for key in ('plain', 'staircase'):\n+ a, k = c7.WITNESSES[0][key]\n+ r = c7.kappa(a)\n+ self.assertTrue(r['ok'], r['bad'])\n+ self.assertEqual(r['kappa'], k)\n+ self.assertGreater(r['kappa'], Q(1, 2**14))\n+\n+ def test_wrong_readout_level_breaks_rank_sum(self):\n+ # a deferred slot whose recorded sigma is one dimension smaller no longer re-partitions the budget\n+ S = self.S; s = S.readout[0]; S.f[s] -= 1\n+ try:\n+ c = dr.histogram(S, self.rk, self.ylev, self.xd)\n+ self.assertNotEqual(sum(w * n for w, n in c['hist'].items()), c['s'])\n+ finally:\n+ S.f[s] += 1\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "a4412d43150ccb76e8cef7947a8e6f7cf3165ea5", + "filename": "research/deferred-signed/swapnil-round7/tests/test_witness.py", + "status": "added", + "additions": 64, + "deletions": 0, + "changes": 64, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_witness.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_witness.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fswapnil-round7%2Ftests%2Ftest_witness.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,64 @@\n+import importlib.util, pathlib, sys, unittest\n+from fractions import Fraction as Q\n+\n+ROOT = pathlib.Path(__file__).resolve().parents[1]\n+\n+\n+def load(name):\n+ spec = importlib.util.spec_from_file_location(name, ROOT / 'scripts' / f'{name}.py')\n+ mod = importlib.util.module_from_spec(spec); spec.loader.exec_module(mod)\n+ return mod\n+\n+\n+cert = load('certificate')\n+ident = load('check_identities')\n+\n+\n+class Witness(unittest.TestCase):\n+ def test_witness_passes(self):\n+ out = cert.evaluate()\n+ self.assertEqual(out['kappa'], '7499/1000000000000')\n+ self.assertEqual(out['binding'], 'simultaneous butterflies')\n+\n+ def rejects(self, reason, **kw):\n+ with self.assertRaises(cert.Failure) as ctx:\n+ cert.evaluate(**kw)\n+ self.assertIn(reason, str(ctx.exception))\n+\n+ def test_kappa_above_margin_rejected(self):\n+ self.rejects('kappa', kappa=Q(7500, 10**12))\n+\n+ def test_small_eps_rejected(self):\n+ self.rejects('kappa', eps=Q(9, 10), y=Q(9, 10))\n+\n+ def test_coupling_needs_y_at_least_eps(self):\n+ self.rejects('sub-block coupling', y=Q(9, 10))\n+\n+ def test_kappa_cannot_reach_a_b(self):\n+ self.rejects('kappa', kappa=Q(3, 4 * 10**8))\n+\n+ def test_precision_rejects_small_x(self):\n+ self.rejects('precision', x=Q(19, 10))\n+\n+ def test_guard_rejects_old_exponent_without_large_digits(self):\n+ self.rejects('guard', x=Q(3, 2), y=Q(0), eps=Q(9999, 10**4), beta=Q(0))\n+\n+ def test_leaf_rejects_large_beta(self):\n+ self.rejects('leaf', beta=Q(9, 10))\n+\n+\n+class Identities(unittest.TestCase):\n+ def test_recentred_form_checked(self):\n+ out = ident.check(113, 128)\n+ self.assertGreater(out['checks']['recentred'], 0)\n+\n+ def test_small_cases_exact(self):\n+ for s, t in ((113, 128), (241, 256)):\n+ out = ident.check(s, t)\n+ self.assertGreater(out['checks']['segment'], 0)\n+ self.assertGreater(out['checks']['cross'], 0)\n+ self.assertGreaterEqual(Q(out['min_cross_exponent']), 2)\n+\n+\n+if __name__ == '__main__':\n+ unittest.main()" + }, + { + "sha": "0d53f10d142b7ce4c567b0b0169b1ca9103713ee", + "filename": "research/deferred-signed/validation-prior/complex-prior-replay.json", + "status": "added", + "additions": 141, + "deletions": 0, + "changes": 141, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fcomplex-prior-replay.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fcomplex-prior-replay.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fcomplex-prior-replay.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,141 @@\n+{\n+ \"source_repository\": \"Swapnil-jain/integer-mult-kappa\",\n+ \"commit\": \"f2176bc1124821bf17eb63725bd366d7bdc020a3\",\n+ \"author\": \"Swapnil Jain\",\n+ \"license\": \"Apache-2.0\",\n+ \"source_sha256\": {\n+ \"notes/copied-centres.tex\": \"f3bd455aaed42be7e8abfc41e8422baf03ab95ac24084345961e68c2513b6191\",\n+ \"notes/segmented-inverse.tex\": \"bd0d6dc07533f4362ae8deeea451ba218afcd7e9438e9b521571b75bf4f0f291\",\n+ \"notes/flag-basis.tex\": \"a8a5e9aa722397417ebac01934367f8ac50b1e27d2c21584cec6a8e9eb7d214a\",\n+ \"independent/complex-twostage/run.py\": \"6df735b8a69cf5226e04bf70db0a750dcdbbf3e9eddbabd293620849d6eff7b6\",\n+ \"independent/complex-twostage/hist.py\": \"eedc3a641859e023fa8408200071d886d798ac8add238a282baebbe9b14124f1\",\n+ \"independent/complex-twostage/producer.py\": \"4c6a37eeda2f31af7adb7964e75eed37dc1bec08c41e622935ff1d99ac0d3f36\",\n+ \"independent/complex-twostage/cert.py\": \"3c3c5b13d970dc7d5647ff3969ff232c6d0b2182d959703e4b2b1ba79a268f21\",\n+ \"independent/complex-twostage/frames.py\": \"f1a04569997828560f4197f4c654ce752173ec2df3d9e69233c9ed4031d02abb\",\n+ \"independent/two-stage-bit/side_chains.py\": \"53ee410e115faa7581a367de1bb5b461c8912783161ea2414db46b79a2a48ddb\",\n+ \"README.md\": \"039320fd59b42cfe3db337656f3d278091517f4ce3d6fc99772eb2a9836cbbd2\",\n+ \"NOTICE\": \"edcc500cd20c52ec00dd7ef6c959e045a5f1778fcae1887c1924edc846a88e4a\",\n+ \"LICENSE\": \"c95bae1d1ce0235ecccd3560b772ec1efb97f348a79f0fbe0a634f0c2ccefe2c\"\n+ },\n+ \"h\": 24,\n+ \"signed_scalar_coefficients_checked\": 4096576,\n+ \"packed_digit_base\": 256,\n+ \"coefficient_bound\": 52,\n+ \"actual_addition_depth\": 15,\n+ \"external_frame_replay\": \"140064 edges, zero bad; label dimensions agreed with histogram\",\n+ \"complex_saving\": \"36926111/500000000000\",\n+ \"old_complex_saving\": \"717/10000000\",\n+ \"relative_saving_improvement\": \"1076111/35850000\",\n+ \"independent_moment\": {\n+ \"saving\": \"36926111/500000000000\",\n+ \"lower\": \"22132223958552052421749212019659453415968223393341965597297120898305542124258674915530121086370281210966654162719329/22132224000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\n+ \"upper\": \"35020062393312951405297670772295013530070560579723749403240804328529075451914236909963718202389048919930249379220757604315590948053301906326005744491853547514963448644861848906017825856098201581613480345622162073798056879734337922290211640166751573176041382599196075448767355400128540334917010238338112161562952928228167204971761574811969540920997032968960281978269842441964057731256511403340885641403773320094316307959111383429669024710055757701048062537488469404001715297870780258084370791915743273716053559778383072548865170865383087515440020597652946350430305899429798682459786578845936117756997623711619/35020062458896495270930209722769672309369092671026031757123898030538541557891818501636226793988827291520006694707886919810078372499670105107629130723721212239551874355263779814716264045999594520408248294463821437742835715286428298787622263581706711678815047704077527199685875393631514260996844769626112713776625262594013673018589775390752443036668742737647246368187617747162519751521347220796847156120773325522178818149841799898980204922920647631151931554211246653827045464941391847412189766425641049302104638178089797764348609120718125537641489941194084894197275339592452027852176179200000000000000000000000\",\n+ \"strict_gap\": \"65583543865632538950474658779298532091302282353883093702009466105977581591672508591599778371589757315487129315494487424446368198781623386231867664724588425710401930908698438189901392938794767948841659363944778835552090376497410623414955138502773665104881451750918519993502973926079834531288000552213672334365846468046828200578782902115671709768686964389917775305198462020264835817455961514717000005427862510190730416469311180212864889930103869016722777249825330167070611589327818974509897775586051078399706725215483438255335038022201469343541138543766969440162653345392389600354063882243002376288381/35020062458896495270930209722769672309369092671026031757123898030538541557891818501636226793988827291520006694707886919810078372499670105107629130723721212239551874355263779814716264045999594520408248294463821437742835715286428298787622263581706711678815047704077527199685875393631514260996844769626112713776625262594013673018589775390752443036668742737647246368187617747162519751521347220796847156120773325522178818149841799898980204922920647631151931554211246653827045464941391847412189766425641049302104638178089797764348609120718125537641489941194084894197275339592452027852176179200000000000000000000000\",\n+ \"logarithms\": {\n+ \"1\": {\n+ \"lower\": \"6356107660695891239293881/1000000000000000000000000\",\n+ \"upper\": \"794513457587/125000000000\"\n+ },\n+ \"2\": {\n+ \"lower\": \"5662960480135945929876649/1000000000000000000000000\",\n+ \"upper\": \"707870060017/125000000000\"\n+ },\n+ \"3\": {\n+ \"lower\": \"1314373843006945386974659/250000000000000000000000\",\n+ \"upper\": \"1314373843007/250000000000\"\n+ },\n+ \"4\": {\n+ \"lower\": \"4969813299576000620459417/1000000000000000000000000\",\n+ \"upper\": \"4969813299577/1000000000000\"\n+ },\n+ \"5\": {\n+ \"lower\": \"2373334874130895432346561/500000000000000000000000\",\n+ \"upper\": \"2373334874131/500000000000\"\n+ },\n+ \"6\": {\n+ \"lower\": \"1141087047866959059620351/250000000000000000000000\",\n+ \"upper\": \"1141087047867/250000000000\"\n+ },\n+ \"7\": {\n+ \"lower\": \"4410197511640577934188529/1000000000000000000000000\",\n+ \"upper\": \"4410197511641/1000000000000\"\n+ },\n+ \"8\": {\n+ \"lower\": \"855333223803211062208437/200000000000000000000000\",\n+ \"upper\": \"4276666119017/1000000000000\"\n+ },\n+ \"9\": {\n+ \"lower\": \"4158883083359671856503391/1000000000000000000000000\",\n+ \"upper\": \"25993019271/6250000000\"\n+ },\n+ \"10\": {\n+ \"lower\": \"405352256770184555527589/100000000000000000000000\",\n+ \"upper\": \"2026761283851/500000000000\"\n+ },\n+ \"11\": {\n+ \"lower\": \"1979106193948760347615969/500000000000000000000000\",\n+ \"upper\": \"1979106193949/500000000000\"\n+ },\n+ \"12\": {\n+ \"lower\": \"967800252726972732266043/250000000000000000000000\",\n+ \"upper\": \"967800252727/250000000000\"\n+ },\n+ \"13\": {\n+ \"lower\": \"1895579151617177251620197/500000000000000000000000\",\n+ \"upper\": \"758231660647/200000000000\"\n+ },\n+ \"14\": {\n+ \"lower\": \"3717050331080632624771297/1000000000000000000000000\",\n+ \"upper\": \"3717050331081/1000000000000\"\n+ },\n+ \"15\": {\n+ \"lower\": \"3648057459593681173297877/1000000000000000000000000\",\n+ \"upper\": \"1824028729797/500000000000\"\n+ },\n+ \"16\": {\n+ \"lower\": \"3583518938456110001624953/1000000000000000000000000\",\n+ \"upper\": \"3583518938457/1000000000000\"\n+ },\n+ \"17\": {\n+ \"lower\": \"3522894316639675159044347/1000000000000000000000000\",\n+ \"upper\": \"22018089479/6250000000\"\n+ },\n+ \"18\": {\n+ \"lower\": \"3465735902799726547086159/1000000000000000000000000\",\n+ \"upper\": \"8664339757/2500000000\"\n+ },\n+ \"19\": {\n+ \"lower\": \"682333736305890155856971/200000000000000000000000\",\n+ \"upper\": \"341166868153/100000000000\"\n+ },\n+ \"20\": {\n+ \"lower\": \"1680187693570950122929329/500000000000000000000000\",\n+ \"upper\": \"1680187693571/500000000000\"\n+ },\n+ \"22\": {\n+ \"lower\": \"1632532603668787692907353/500000000000000000000000\",\n+ \"upper\": \"1632532603669/500000000000\"\n+ },\n+ \"23\": {\n+ \"lower\": \"3220613444766741548487129/1000000000000000000000000\",\n+ \"upper\": \"3220613444767/1000000000000\"\n+ },\n+ \"24\": {\n+ \"lower\": \"158902691517397280982347/50000000000000000000000\",\n+ \"upper\": \"794513457587/250000000000\"\n+ },\n+ \"529\": {\n+ \"lower\": \"85119228837591857680377/1000000000000000000000000\",\n+ \"upper\": \"42559614419/500000000000\"\n+ },\n+ \"552\": {\n+ \"lower\": \"10639903604698982210047/250000000000000000000000\",\n+ \"upper\": \"42559614419/1000000000000\"\n+ }\n+ }\n+ },\n+ \"rank_sum\": 119453132304,\n+ \"maxchild\": 552,\n+ \"remaining\": \"Full changed complex dirty/phase/precision/tape interfaces and integration assembly not replayed. This is a research candidate, not an updated multiplication bound.\",\n+ \"new_multiplication_bound\": false\n+}" + }, + { + "sha": "7a84af93ed875da010ad7c8dc89c0e78d9e0873c", + "filename": "research/deferred-signed/validation-prior/round6_complex_interface_controls.py", + "status": "added", + "additions": 98, + "deletions": 0, + "changes": 98, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_interface_controls.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_interface_controls.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_interface_controls.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,98 @@\n+#!/usr/bin/env python3\n+\"\"\"Exact Gaussian-dyadic schedule and endpoint controls; not a final theorem.\n+Zhihao Chen / Codex. Pinned producer: Swapnil Jain, Apache-2.0.\n+\"\"\"\n+import sys,json,time,signal\n+from pathlib import Path\n+HERE=Path(__file__).resolve().parent\n+sys.path.insert(0,str(HERE/'swapnil-round7/independent/complex-twostage'))\n+from producer import NStar3,compile_roles\n+\n+def word(h):\n+ c=NStar3(h);k=compile_roles(c);v=len(c.triples);R=k['size'];off=2*v\n+ # Each event is dst += (numerator/denominator)*src.\n+ L=[];V=[];J=[];C=[]\n+ for n,ins,outs in k['gates']:\n+ if len(ins)==2:L.append((off+ins[0],off+ins[1],1,1))\n+ L.extend((off+o,off+outs[0],1,1) for o in outs[1:])\n+ V=[(off+s,c.tid[t],1,1) for t,s in k['src'].items()]\n+ J=[(v+c.tid[t],off+k['pout'][i],cf,2) for i,(t,n,cf) in enumerate(c.pieces)]\n+ ret=k['rout'];star=off+ret[('*',)]\n+ for j,T in enumerate(c.triples):\n+ if h-1 not in T:\n+ C.append((v+j,star,2,2));C.extend((v+j,off+ret[('E',i)],-1,2) for i in T)\n+ else:\n+ C.append((v+j,star,5-h,2));C.extend((v+j,off+ret[('E',i)],1,2) for i in range(h-1) if i not in T)\n+ inv=lambda a:[(t,s,-n,d) for t,s,n,d in reversed(a)]\n+ ops=L+inv(C)+inv(J)+inv(L)+V+L+C+J+inv(L)+inv(V)\n+ bank=lambda s:s+v if s>i&1 and q>>j&1)\n+ def parity(a):return a.bit_count()&1\n+ def tq(z):return sum(q<<(i*h) for i in range(h) if parity((z>>(i*h))&q))\n+ def pi(z):\n+ col=0\n+ for j in range(h):\n+ if parity(sum(((z>>(i*h+j))&1)<>i&1)\n+ bad_no_inverse=bad_no_wrapper=0\n+ # Fourth roots represented exactly as Gaussian integer pairs.\n+ units=((1,0),(0,1),(-1,0),(0,-1))\n+ def mul(a,b):return (a[0]*b[0]-a[1]*b[1],a[0]*b[1]+a[1]*b[0])\n+ add=lambda a,b:(a[0]+b[0],a[1]+b[1])\n+ neg=lambda a:(-a[0],-a[1])\n+ for z in range(1<=v and t<2*v and d==2);del omitted[idx]\n+ assert not replay(v,k['size'],omitted)[0]\n+ rows.append(dict(h=h,roles=k['size'],formal_basis=2*v+k['size'],events=len(ops),forward=True,inverse_opposite=True,coefficient_bound=max(ba,bb),negative_controls=2))\n+ out=dict(rows=rows,phase=phases(),elapsed=time.monotonic()-st,limit_seconds=120,\n+ scope='Complete exact dyadic small scalar words and all-address tensor phase controls. General commutator/phase argument in report. No h24 physical trace, precision/tape or final assembly certification.',new_multiplication_bound=False)\n+ (HERE/'round6-complex-interface-controls.json').write_text(json.dumps(out,indent=2)+'\\n');print(json.dumps(out,indent=2));signal.alarm(0)\n+if __name__=='__main__':main()" + }, + { + "sha": "269d26c42193642091ac51f1760c345fef6b7601", + "filename": "research/deferred-signed/validation-prior/round6_complex_literal_ledger.py", + "status": "added", + "additions": 129, + "deletions": 0, + "changes": 129, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_literal_ledger.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_literal_ledger.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fround6_complex_literal_ledger.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,129 @@\n+#!/usr/bin/env python3\n+\"\"\"Actual h24 signed events, copied centers, reflected frames and paid ranks.\n+Zhihao Chen / Codex audit of Swapnil Jain's Apache-2.0 pinned round6 producer.\n+Frame labels are binary subspaces; complex phases use the separately proved\n+q_U and inverse-rank-one endpoint identities, not XOR cancellation.\n+\"\"\"\n+import sys,json,time,signal,gzip,hashlib\n+from pathlib import Path\n+from collections import Counter\n+from array import array\n+HERE=Path(__file__).resolve().parent\n+sys.path.insert(0,str(HERE/'swapnil-round7/independent/complex-twostage'))\n+from producer import NStar3,compile_roles\n+from frames import Checker,echelon,perp_in,ok_res\n+\n+def main():\n+ st=time.monotonic()\n+ def stop(*_):raise TimeoutError('180s event ledger limit')\n+ signal.signal(signal.SIGALRM,stop);signal.alarm(180)\n+ h=24;c=NStar3(h);k=compile_roles(c);ch=Checker(c)\n+ v=len(c.triples);R=k['size'];size=2*v+R;off=2*v;m=h*h\n+ bases=[];ids={};dims=[]\n+ def key(b):\n+ b=tuple(sorted(echelon(b).values()))\n+ if b not in ids:ids[b]=len(bases);bases.append(b);dims.append(len(b))\n+ return ids[b]\n+ zero=key([]);F=key([1<0\n+ events.extend((0,reg,old,f,r));H['aux' if reg>=off else 'data'][r]+=1;cur[reg]=f\n+ def add(t,s,n=1,d=1):\n+ assert cur[t]==cur[s];events.extend((1,t,s,n,d))\n+ def mix(mode,inverse=False):\n+ for n,ins,outs in reversed(k['gates']) if inverse else k['gates']:\n+ f=zero if mode=='low' else F if mode=='high' else nk[n]\n+ for q in sorted(set(ins+outs)):move(off+q,f)\n+ if inverse:\n+ for q in reversed(outs[1:]):add(off+q,off+outs[0],-1)\n+ if len(ins)==2:add(off+ins[0],off+ins[1],-1)\n+ else:\n+ if len(ins)==2:add(off+ins[0],off+ins[1])\n+ for q in outs[1:]:add(off+q,off+outs[0])\n+ def inject(sign,high):\n+ for i,(T,n,cf) in enumerate(c.pieces):\n+ t=c.tid[T];s=off+k['pout'][i];f=hyper[t] if high else zero\n+ move(s,f);move(v+t,f);add(v+t,s,sign*cf,2)\n+ terms={name:[] for name in k['rout']}\n+ for j,T in enumerate(c.triples):\n+ if h-1 not in T:\n+ terms[('*',)].append((v+j,2));selected=T;sg=-1\n+ else:\n+ terms[('*',)].append((v+j,5-h));selected=[i for i in range(h-1) if i not in T];sg=1\n+ for i in selected:terms[('E',i)].append((v+j,sg))\n+ def center(sign,copied=False):\n+ for name,sl in k['rout'].items():\n+ reg=off+sl\n+ for t,n in terms[name]:assert cur[t]==zero\n+ if copied:\n+ # Fresh copy retains its source frame and is moved to zero;\n+ # original arbitrary-dirty role remains at its live frame.\n+ f=cur[reg];assert ok_res(list(bases[f]));r=dims[f]\n+ copies.append(dict(source=reg,frame=f,target_frame=zero,terms=terms[name]))\n+ events.extend((2,reg,f,len(copies)-1,r));H['center'][r]+=1\n+ else:\n+ move(reg,zero)\n+ for t,n in terms[name]:add(t,reg,sign*n,2)\n+ def source(sign,high):\n+ for T,sl in k['src'].items():\n+ t=c.tid[T];f=F if high else line[t]\n+ move(off+sl,f);move(t,f);add(off+sl,t,sign)\n+ mix('low');center(-1);inject(-1,False);mix('low',True)\n+ source(1,False);mix('label');center(1,True);inject(1,True)\n+ mix('high',True);source(-1,True)\n+ for s in range(R):move(off+s,F)\n+ assert cur[:v]==[F]*v and cur[v:off]==hyper and cur[off:]==[F]*R\n+ assert sum(r*n for r,n in H['aux'].items())==R*h\n+ assert sum(r*n for r,n in H['data'].items())==2*v*(h-1)\n+ assert sum(r*n for r,n in H['center'].items())==(h-1)**2+h\n+ # Explicit time-reversed signed word with complement labels and bank swap.\n+ bank=lambda s:s+v if s=s+E\n+ bit=json.loads((HERE/'round7-literal-ledger/result.json').read_text());bh={int(t):n for t,n in bit['histogram'].items()}\n+ bm=529;bW=108516254;br=max(bh)\n+ db,dc=halving(bm,br),halving(m,r);co=bW.bit_length()*db+W.bit_length()*dc\n+ degree=1000*((co*51)//25000+1)\n+ bridge=dict(bit=dict(m=bm,W=bW,maxchild=br,halving_degree=db),complex=dict(m=m,W=W,s=s,maxchild=r,halving_degree=dc),\n+ semantic=dict(E=E,literal_charge=charge,strict_literal_gap=E-charge,B=B,C0=C0,C1=1),rows=dict(coefficient=co,degree=degree,degree_gap=Q(degree)-Q(co*51,25)))\n+ ab=Q(31987,500000000);ac=Q(36926111,500000000000);eta=Q(1,10**8)\n+ q=ab*(1-2*eta);cc=q*(1+eta);eps=(1-eta)/(1+cc+q)\n+ upper=eps*q;kap=Q((upper*10**12).__floor__(),10**12)\n+ cert=assembly(ab,ac,bridge,kap,eta=eta,beta=Q(1,10));assert kap>Q(1,16384)\n+ rejected=False\n+ try:assembly(ab,ac,bridge,kap+Q(1,10**12),eta=eta,beta=Q(1,10))\n+ except AssertionError:rejected=True\n+ assert rejected\n+ out=dict(candidate_kappa=kap,dyadic_gap=kap-Q(1,16384),literal_word_events=word,scalar_group_bound=G,\n+ scalar_coefficient_max=Q(19,2),bridge=bridge,assembly=cert,next_grid_rejected=rejected,\n+ strict_constraint_count=len(cert['strict_constraints']),margin_count=len(cert['margins']),\n+ source_assembly_sha256=hashlib.sha256((HERE/'integration/scripts/structured_bulk_assembly.py').read_bytes()).hexdigest(),\n+ status='Arithmetic candidate only. New complex literal/phase checks, full h24 physical accounting, finite bridge applicability and inherited analytic/tape conditions require integration proof before a multiplication claim.',new_multiplication_bound=False)\n+ (HERE/'round7-balanced-assembly-candidate.json').write_text(json.dumps(js(out),indent=2)+'\\n')\n+ print(json.dumps(js({k:out[k] for k in ['candidate_kappa','dyadic_gap','literal_word_events','scalar_group_bound','strict_constraint_count','margin_count','next_grid_rejected','new_multiplication_bound']}),indent=2))\n+if __name__=='__main__':main()" + }, + { + "sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "filename": "research/deferred-signed/validation-prior/round7_literal_frame_ledger.py", + "status": "added", + "additions": 166, + "deletions": 0, + "changes": 166, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround7_literal_frame_ledger.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fround7_literal_frame_ledger.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fround7_literal_frame_ledger.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,166 @@\n+#!/usr/bin/env python3\n+\"\"\"Explicit forward and reflected frame/event ledger of pinned round-seven.\n+Zhihao Chen / Codex audit. Exact nesting of the supplied chains is inherited\n+from the separately run frame/lifted checkers, not inferred from ranks here.\n+Copied-center moves are temporary macros, not erased arbitrary scratch.\n+\"\"\"\n+import sys,json,signal,time,hashlib,gzip\n+from pathlib import Path\n+from collections import defaultdict,Counter\n+from array import array\n+HERE=Path(__file__).resolve().parent;ROOT=HERE/'swapnil-round7'\n+sys.path.insert(0,str(ROOT/'independent/deferred-readout'))\n+import deferred as dr\n+\n+def main():\n+ started=time.monotonic()\n+ def stop(*_):raise TimeoutError('180 second literal ledger limit')\n+ signal.signal(signal.SIGALRM,stop);signal.alarm(180)\n+ W,D=dr.load(23);S=dr.Schedule(W,D);v,R,h=S.v,S.R,S.h;size=2*v+R\n+ co=S.adjoint();sel=S.sel;ops=S.ops;prev={};pred=defaultdict(list);last={}\n+ for i,op in enumerate(ops):\n+ for s in S.touch(op):\n+ if s in prev:pred[i].append(prev[s])\n+ prev[s]=i;last[s]=i\n+ ph=set();stack=[last[s] for s in S.ret]\n+ while stack:\n+ i=stack.pop()\n+ if i in ph:continue\n+ ph.add(i);stack.extend(pred[i])\n+ assert not any(set(S.touch(ops[i]))&sel for i in ph)\n+ keys=[];ids={};dims=[]\n+ def norm(k):\n+ if k[0]=='out':return ('out',0,tuple(k[2]))\n+ return k\n+ def key(k):\n+ k=norm(k)\n+ if k not in ids:\n+ ids[k]=len(keys);keys.append(k);dims.append(S.dim(k))\n+ return ids[k]\n+ z,F=key(('0',)),key(('F',))\n+ paths=[None]*size\n+ for n,ss in S.xs:paths[n-1]=[key(('n',n))]+[key(('v',s)) for s in ss]+[F]\n+ y=[[] for _ in range(v)]\n+ for s in S.readout:\n+ for t,c in co[s].items():\n+ if c&1:y[t].append(key(('sigma',s)))\n+ for t,T in enumerate(S.trip):paths[v+t]=[z]+y[t]+[key(('out',0,T))]\n+ for s in range(R):paths[2*v+s]=[key(k) for k in S.chain_keys(s)]\n+ assert all(p and all(dims[b]>=dims[a] for a,b in zip(p,p[1:])) for p in paths)\n+ pos=[0]*size;current=[p[0] for p in paths];initial=current[:]\n+ # Fixed-width event records: kind, register/destination, source-or-old,\n+ # new-or-common, rank. kind=0 move,1 xor,2 temporary copied-center macro.\n+ events=array('i');rank_hist={k:Counter() for k in ('aux','data','center')}\n+ bits=[1<=0\n+ emit(0,s,a,b,r);rank_hist['aux' if s>=2*v else 'data'][r]+=1\n+ pos[s]+=1;current[s]=b\n+ def xor(t,s):\n+ assert current[t]==current[s],('gate frames',t,s,keys[current[t]],keys[current[s]])\n+ emit(1,t,s,current[t]);bits[t]^=bits[s]\n+ def readout(s):\n+ aux=2*v+s;f=key(('sigma',s)) if s in sel else z\n+ assert current[aux]==f\n+ for t,c in sorted(co[s].items()):\n+ if c&1:move(v+t,f);xor(v+t,aux)\n+ def source(s,active):\n+ frame=key(('v',s)) if active else F\n+ move(2*v+s,frame);move(S.srcop[s]-1,frame);xor(2*v+s,S.srcop[s]-1)\n+ reordered_fans=[]\n+ def operation(i,active):\n+ op=ops[i]\n+ if op[0]=='add':\n+ _,p,o,n=op;frame=key(('n',n)) if active else F\n+ move(2*v+p,frame);move(2*v+o,frame);xor(2*v+p,2*v+o)\n+ elif op[0]=='fan':\n+ # Scalar fan targets commute. The archive groups copies whose\n+ # physical start frames differ; execute them in frame-chain order.\n+ targets=sorted(op[2],key=lambda s:S.dim(S.start_key(s))) if active else op[2]\n+ if active and tuple(targets)!=tuple(op[2]):reordered_fans.append(i)\n+ for s in targets:\n+ frame=key(S.start_key(s)) if active else F\n+ move(2*v+op[1],frame);move(2*v+s,frame);xor(2*v+s,2*v+op[1])\n+ for s in range(R):\n+ if s not in sel:readout(s)\n+ early=sorted(set(S.srcop)-sel,key=lambda s:(S.srcop[s],len(S.vstart[s]),s))\n+ for s in early:source(s,True)\n+ first=[i for i in range(len(ops)) if i in ph and ops[i][0]!='src']\n+ rest=[i for i in range(len(ops)) if i not in ph and ops[i][0]!='src']\n+ centers={}\n+ for i in first:operation(i,True)\n+ for s,c in S.ret.items():\n+ a=2*v+s;f=key(('ret',c));move(a,f)\n+ targets=[v+t for t,T in enumerate(S.trip) if c in T]\n+ assert all(current[t]==z for t in targets)\n+ centers[a]=targets;emit(2,a,f,z,h-1);rank_hist['center'][h-1]+=1\n+ for t in targets:bits[t]^=bits[a]\n+ for s in S.readout:readout(s)\n+ for s in S.late_v:source(s,True)\n+ for i in rest:operation(i,True)\n+ for s,(c,T) in S.out.items():\n+ t=S.tid[T];f=key(('out',0,T));move(2*v+s,f);move(v+t,f);xor(v+t,2*v+s)\n+ for i in reversed(first+rest):operation(i,False)\n+ for s in S.srcop:source(s,False)\n+ for s in range(R):move(2*v+s,F)\n+ assert all(bits[i]==((1<=h-3) for i in range(h)]))\n+ K=s.kronecker_product;m=h*h;J=s.eye(m);U=K(P,Q);B=K(I-P,I);T=K(I,Q)\n+ C=K(I-P,I-Q)\n+ X1=T;Y1=K(I-P,Q);X2=B+U;Y2=B\n+ assert X2-X1==Y2-Y1==C and C*C==C and C.rank()==(h-1)**2\n+ assert D(X2)*D(X1)==D(C) and D(Y2)*D(Y1)==D(C)\n+ assert D(U)*D(J)==D(J-U)\n+ for f in range(h+1):\n+ sigma=proj(I[:,:f]);A=K(sigma,Q)\n+ exit1=J-T+A;end1=J-A\n+ live2=J-K(P,sigma);end2=J-B;exit2=B+K(P,sigma)\n+ assert exit1*exit1==exit1 and exit2*exit2==exit2\n+ assert exit1.rank()==exit2.rank()==m-h+f\n+ assert D(end1)*D(T)==D(exit1)\n+ assert D(end2)*D(live2)==D(exit2)\n+ assert D(end1)*D(A)==D(J) and D(end2)*D(B)==D(J)\n+ if f:\n+ assert D(end1)*D(T)!=D(J-T);bad_controls+=1\n+ rows.append(dict(h=h,sigma_rank=f,exterior_rank=m-h+f,all_identities=True))\n+ out=dict(rows=rows,negative_omitted_sigma_rejected=bad_controls,\n+ data_connectors_per_pair=2,connector_rank_formula='(h-1)^2',correction_rank=1,\n+ elapsed=time.monotonic()-st,limit_seconds=120,\n+ scope='Exact rational finite controls of general tensor identities; not a full all-size compiler, complex phase/precision or final multiplication theorem.',new_multiplication_bound=False)\n+ (HERE/'round7-tensor-endpoint-controls.json').write_text(json.dumps(out,indent=2)+'\\n')\n+ signal.alarm(0);print(json.dumps(out,indent=2))\n+if __name__=='__main__':main()" + }, + { + "sha": "3fc62f301d4f50d680cfbfe9417c4f2ed7e02b26", + "filename": "research/deferred-signed/validation-prior/swapnil-round7-full-basis.json", + "status": "added", + "additions": 18, + "deletions": 0, + "changes": 18, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-full-basis.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-full-basis.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-full-basis.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,18 @@\n+{\n+ \"h\": 23,\n+ \"roles\": 28866,\n+ \"formal_basis\": 32408,\n+ \"events\": 862162,\n+ \"complete_F2_source_target_dirty\": true,\n+ \"complete_logical_transpose\": true,\n+ \"physical_stage_two_checked\": false,\n+ \"elapsed\": 1.5430952910101041,\n+ \"limit_seconds\": 180,\n+ \"sources\": {\n+ \"independent/deferred-readout/deferred.py\": \"e92ac1db9fce8608cf5302336f05750fa327eda99f7170ed32e7323220ffc164\",\n+ \"certificates/round7/witness_23.json.gz\": \"b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588\",\n+ \"certificates/round7/deferred_23.json.gz\": \"8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c\"\n+ },\n+ \"scope\": \"Exact complete scalar F2 linear-map and transpose audit of one pinned h23 stage-one schedule. No physical frames, two-stage composition, tape, precision or multiplication-bound claim.\",\n+ \"new_multiplication_bound\": false\n+}" + }, + { + "sha": "ac62a25d8caf1b992a85f0ea3c61f2686a864ecf", + "filename": "research/deferred-signed/validation-prior/swapnil-round7-moment-audit.json", + "status": "added", + "additions": 455, + "deletions": 0, + "changes": 455, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-moment-audit.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-moment-audit.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-moment-audit.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,455 @@\n+{\n+ \"rows\": [\n+ {\n+ \"name\": \"plain\",\n+ \"bit_saving\": \"12599/200000000\",\n+ \"reported_assembly_kappa\": \"6299103187973/100000000000000000\",\n+ \"gap_above_14\": \"195587562973/100000000000000000\",\n+ \"independent_moment\": {\n+ \"saving\": \"12599/200000000\",\n+ \"lower\": \"518623134244155681419305049142880733917326814719118560702743566427026037558782952858157928610976579348641/518623136000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\n+ \"upper\": \"1298723344073735141567580695378815677636928074195703134424554703057646713926432781909404912647238772468053863004397050691322701357418862829784834994931252779231886817750889924353329650827999798176301982334446314468844174372582367488930704238738113678553431770447444061853243360312189402213306668344978034522718872137406608531902178470828122550228941449379009631752908296422310679006678908099536913476283353493066930021222946155905812441463200219810944218602785328656146426284063210446255587382740788388465169867054168443902004050593378954483542159450510940725827889781027926557107577110161714247472505237715035166417780542119680070791644409968024988536270135425366716104871369350860019394926895884856363463365963520255483/1298723348470677371081106871464614950212416571273111007659908168479653361844087388166410254984412799274869778129562395932983304560498839958189749332416300902333307382893376056801989349988348873012533890063491622380104791470754882188186653383837832247115837868956676391570030254776774574593138369743374393102446541847704303291995970280166552750584743198359286729726271049191384447917197858313269479881358427937797402119538319230543011416873082866921210323532536098979495959580335596559681470960147698615410896334081284261971409880688264879454668085912234930248435422146808826714692958971816005430405610135341134783101437139084162211321518672159983328129083823630746069649989350698849916256886336941927200000000000000000000\",\n+ \"strict_gap\": \"4396942229513526176085799272575488497077407873235353465422006647917654606257005342337174026806815915125165345241660603203079977128404914337485048123101420565142486132448659699160349074836231907729045307911260617098172514699255949145099718568562406098509232329716786894464585172379831701398396358579727669710297694760093791809338430200355801748980277097973362752769073768910518950213732566405075074444730472098315373074637198975409882647110266104929750770323349533296272386113425883577406910226945726467027115818069405830094885924971125926461723989522607532365780900157585381861654291182933104897626099616683656596964482140529874262191958339592813688205379353545117981347989896861959441057070836536634036479744517/1298723348470677371081106871464614950212416571273111007659908168479653361844087388166410254984412799274869778129562395932983304560498839958189749332416300902333307382893376056801989349988348873012533890063491622380104791470754882188186653383837832247115837868956676391570030254776774574593138369743374393102446541847704303291995970280166552750584743198359286729726271049191384447917197858313269479881358427937797402119538319230543011416873082866921210323532536098979495959580335596559681470960147698615410896334081284261971409880688264879454668085912234930248435422146808826714692958971816005430405610135341134783101437139084162211321518672159983328129083823630746069649989350698849916256886336941927200000000000000000000\",\n+ \"logarithms\": {\n+ \"1\": {\n+ \"lower\": \"6270988431858299381613503/1000000000000000000000000\",\n+ \"upper\": \"6270988431859/1000000000000\"\n+ },\n+ \"3\": {\n+ \"lower\": \"5172376143190189690218259/1000000000000000000000000\",\n+ \"upper\": \"5172376143191/1000000000000\"\n+ },\n+ \"5\": {\n+ \"lower\": \"932310103884839801402549/200000000000000000000000\",\n+ \"upper\": \"186462020777/40000000000\"\n+ },\n+ \"7\": {\n+ \"lower\": \"4325078282802986076508151/1000000000000000000000000\",\n+ \"upper\": \"4325078282803/1000000000000\"\n+ },\n+ \"9\": {\n+ \"lower\": \"2036881927261039999411507/500000000000000000000000\",\n+ \"upper\": \"4073763854523/1000000000000\"\n+ },\n+ \"11\": {\n+ \"lower\": \"3873093159059928837551561/1000000000000000000000000\",\n+ \"upper\": \"193654657953/50000000000\"\n+ },\n+ \"13\": {\n+ \"lower\": \"3706039074396762645560017/1000000000000000000000000\",\n+ \"upper\": \"3706039074397/1000000000000\"\n+ },\n+ \"15\": {\n+ \"lower\": \"1425175292302435726247/400000000000000000000\",\n+ \"upper\": \"3562938230757/1000000000000\"\n+ },\n+ \"17\": {\n+ \"lower\": \"343777508780208330136397/100000000000000000000000\",\n+ \"upper\": \"3437775087803/1000000000000\"\n+ },\n+ \"19\": {\n+ \"lower\": \"3326549452691858921604477/1000000000000000000000000\",\n+ \"upper\": \"831637363173/250000000000\"\n+ },\n+ \"21\": {\n+ \"lower\": \"1613232997067438192556453/500000000000000000000000\",\n+ \"upper\": \"645293198827/200000000000\"\n+ },\n+ \"23\": {\n+ \"lower\": \"97984194247785927837711/31250000000000000000000\",\n+ \"upper\": \"313549421593/100000000000\"\n+ },\n+ \"439\": {\n+ \"lower\": \"186489018783128031620293/1000000000000000000000000\",\n+ \"upper\": \"5827781837/31250000000\"\n+ },\n+ \"483\": {\n+ \"lower\": \"45485889102863347153077/500000000000000000000000\",\n+ \"upper\": \"45485889103/500000000000\"\n+ },\n+ \"485\": {\n+ \"lower\": \"10854942615102023112003/125000000000000000000000\",\n+ \"upper\": \"86839540921/1000000000000\"\n+ },\n+ \"487\": {\n+ \"lower\": \"41362154387854795441797/500000000000000000000000\",\n+ \"upper\": \"10340538597/125000000000\"\n+ },\n+ \"489\": {\n+ \"lower\": \"4914121398964209759583/62500000000000000000000\",\n+ \"upper\": \"4914121399/62500000000\"\n+ },\n+ \"491\": {\n+ \"lower\": \"14908860812755760575863/200000000000000000000000\",\n+ \"upper\": \"1164754751/15625000000\"\n+ },\n+ \"493\": {\n+ \"lower\": \"70479257815609274180699/1000000000000000000000000\",\n+ \"upper\": \"8809907227/125000000000\"\n+ },\n+ \"495\": {\n+ \"lower\": \"8303833661201135020039/125000000000000000000000\",\n+ \"upper\": \"6643066929/100000000000\"\n+ },\n+ \"497\": {\n+ \"lower\": \"31199202880835327589349/500000000000000000000000\",\n+ \"upper\": \"31199202881/500000000000\"\n+ },\n+ \"499\": {\n+ \"lower\": \"29191168053390358164207/500000000000000000000000\",\n+ \"upper\": \"58382336107/1000000000000\"\n+ },\n+ \"501\": {\n+ \"lower\": \"54382330773434582958509/1000000000000000000000000\",\n+ \"upper\": \"27191165387/500000000000\"\n+ },\n+ \"503\": {\n+ \"lower\": \"6299782719820021899343/125000000000000000000000\",\n+ \"upper\": \"50398261759/1000000000000\"\n+ },\n+ \"505\": {\n+ \"lower\": \"11607500645734889032137/250000000000000000000000\",\n+ \"upper\": \"46430002583/1000000000000\"\n+ },\n+ \"507\": {\n+ \"lower\": \"8495485653423243622257/200000000000000000000000\",\n+ \"upper\": \"10619357067/250000000000\"\n+ },\n+ \"509\": {\n+ \"lower\": \"38540415307776638778641/1000000000000000000000000\",\n+ \"upper\": \"9635103827/250000000000\"\n+ },\n+ \"511\": {\n+ \"lower\": \"8654710413648736854011/250000000000000000000000\",\n+ \"upper\": \"6923768331/200000000000\"\n+ },\n+ \"513\": {\n+ \"lower\": \"15356293343764923709371/500000000000000000000000\",\n+ \"upper\": \"479884167/15625000000\"\n+ },\n+ \"515\": {\n+ \"lower\": \"1676345699660202265259/62500000000000000000000\",\n+ \"upper\": \"5364306239/200000000000\"\n+ },\n+ \"517\": {\n+ \"lower\": \"22945557349870250730611/1000000000000000000000000\",\n+ \"upper\": \"458911147/20000000000\"\n+ },\n+ \"519\": {\n+ \"lower\": \"477113717310268582119/25000000000000000000000\",\n+ \"upper\": \"19084548693/1000000000000\"\n+ },\n+ \"521\": {\n+ \"lower\": \"15238390104932463524609/1000000000000000000000000\",\n+ \"upper\": \"3047678021/200000000000\"\n+ },\n+ \"523\": {\n+ \"lower\": \"5703483896688240401681/500000000000000000000000\",\n+ \"upper\": \"5703483897/500000000000\"\n+ },\n+ \"525\": {\n+ \"lower\": \"7590169266675635911389/1000000000000000000000000\",\n+ \"upper\": \"7590169267/1000000000000\"\n+ },\n+ \"527\": {\n+ \"lower\": \"1893941658468527717403/500000000000000000000000\",\n+ \"upper\": \"3787883317/1000000000000\"\n+ }\n+ }\n+ },\n+ \"histogram\": {\n+ \"483\": 61280142,\n+ \"23\": 61280142,\n+ \"525\": 5653032,\n+ \"1\": 1803209177,\n+ \"527\": 6233920,\n+ \"489\": 293986,\n+ \"17\": 8476006,\n+ \"521\": 13711082,\n+ \"523\": 4629394,\n+ \"491\": 580888,\n+ \"15\": 7948248,\n+ \"485\": 545468,\n+ \"21\": 6906900,\n+ \"487\": 173558,\n+ \"19\": 1639946,\n+ \"493\": 14168,\n+ \"13\": 2164162,\n+ \"499\": 1129898,\n+ \"7\": 3580962,\n+ \"495\": 322322,\n+ \"11\": 5093396,\n+ \"505\": 99176,\n+ \"503\": 410872,\n+ \"3\": 1356586,\n+ \"501\": 127512,\n+ \"5\": 354200,\n+ \"507\": 1186570,\n+ \"509\": 340032,\n+ \"497\": 17710,\n+ \"9\": 1526602,\n+ \"513\": 106260,\n+ \"517\": 626934,\n+ \"515\": 1583274,\n+ \"511\": 322322,\n+ \"519\": 2854852,\n+ \"439\": 6272882\n+ },\n+ \"width\": 108516254,\n+ \"recursive_rank\": 57403754177,\n+ \"upstream_assembly\": {\n+ \"ok\": true,\n+ \"bad\": [],\n+ \"kappa\": \"6299103187973/100000000000000000\",\n+ \"eps\": \"9999370089681201/10000000000000000\",\n+ \"x\": 14695,\n+ \"c1\": \"14694\",\n+ \"binding\": \"simultaneous butterflies\",\n+ \"gap\": \"836914885318799/50000000000000000000000000000000\"\n+ }\n+ },\n+ {\n+ \"name\": \"staircase\",\n+ \"bit_saving\": \"31987/500000000\",\n+ \"reported_assembly_kappa\": \"1599247689723/25000000000000000\",\n+ \"gap_above_14\": \"73368783473/25000000000000000\",\n+ \"independent_moment\": {\n+ \"saving\": \"31987/500000000\",\n+ \"lower\": \"8103486473266429008865046399176305579856577752771922628059416410544269782794745410240869354410215515785673/8103486500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\n+ \"upper\": \"653851067397047618458688872775565504088779767030854818744660989822255649471866722171353014314417300653520580457433218354067096622498577647705992749441283263644000936650574033821700238472646972044931706007368516004675779417337433532308837300484396998174314614980382284494886766936000038248370089040028564247617537618095942215235605469208506924970394245239909731027731793639913183597208399725955562511564359781203900744081455057712432012488074623501661889057808781043032941990506900474949550986401293353386449579747830167840811108406949819665012151420117228770499869252586629664835813446317357337934974201227640677801596385898033694210696329857210333525073572190527767690437607125679796992822941850199054082015631004557012337460159814147439774764169161867/653851069554115891287661886558769107610629891436345459257241957721689519536278995024172823299600072974272129463039152886271523560071232342209319874608258956024626496550160696647073787202625577990361692717966416404080388314298434026021328062402293426940165019328537442519362198727530331301157278867831448583421588473959463330010990027109891758519089770348644237138029247351313206384982593621536279507829475091817536110955574719142598798052732763740293837504407551523719704048523225502280822069461609258637598930448620216059149671602680037607690576049988386417379404389312566277593737578512946571950737891714615647566682871467135534872171227949522428156844516224290693238092199887129755386385658628414100746903412275300915098248700225680000000000000000000\",\n+ \"strict_gap\": \"2157068272828973013783203603521850124405490640512580967899433870064412272852819808985182772320751549005605934532204426937572654694503327125166975692380625559899586662825373548729978605945429986710597900399404608896961000493712490761917896428765850404348155158024475431791530293052787189827802884335804050855863521114775384557901384833548695525108734506110297453711400022787774193895580716996265115310613635366874119661430166785564658140238631948446598770480686762058016325027331271083060315905251149350700790048218338563195730217942678424629871157646879535136725936612757924132195589234015763690486974969765086485569101840661474898092312094631770944033762925547654592761449958393562716778215046664887781270743902760788540411532560225235830838133/653851069554115891287661886558769107610629891436345459257241957721689519536278995024172823299600072974272129463039152886271523560071232342209319874608258956024626496550160696647073787202625577990361692717966416404080388314298434026021328062402293426940165019328537442519362198727530331301157278867831448583421588473959463330010990027109891758519089770348644237138029247351313206384982593621536279507829475091817536110955574719142598798052732763740293837504407551523719704048523225502280822069461609258637598930448620216059149671602680037607690576049988386417379404389312566277593737578512946571950737891714615647566682871467135534872171227949522428156844516224290693238092199887129755386385658628414100746903412275300915098248700225680000000000000000000\",\n+ \"logarithms\": {\n+ \"1\": {\n+ \"lower\": \"6270988431858299381613503/1000000000000000000000000\",\n+ \"upper\": \"6270988431859/1000000000000\"\n+ },\n+ \"3\": {\n+ \"lower\": \"5172376143190189690218259/1000000000000000000000000\",\n+ \"upper\": \"5172376143191/1000000000000\"\n+ },\n+ \"5\": {\n+ \"lower\": \"932310103884839801402549/200000000000000000000000\",\n+ \"upper\": \"186462020777/40000000000\"\n+ },\n+ \"7\": {\n+ \"lower\": \"4325078282802986076508151/1000000000000000000000000\",\n+ \"upper\": \"4325078282803/1000000000000\"\n+ },\n+ \"9\": {\n+ \"lower\": \"2036881927261039999411507/500000000000000000000000\",\n+ \"upper\": \"4073763854523/1000000000000\"\n+ },\n+ \"11\": {\n+ \"lower\": \"3873093159059928837551561/1000000000000000000000000\",\n+ \"upper\": \"193654657953/50000000000\"\n+ },\n+ \"13\": {\n+ \"lower\": \"3706039074396762645560017/1000000000000000000000000\",\n+ \"upper\": \"3706039074397/1000000000000\"\n+ },\n+ \"15\": {\n+ \"lower\": \"1425175292302435726247/400000000000000000000\",\n+ \"upper\": \"3562938230757/1000000000000\"\n+ },\n+ \"17\": {\n+ \"lower\": \"343777508780208330136397/100000000000000000000000\",\n+ \"upper\": \"3437775087803/1000000000000\"\n+ },\n+ \"18\": {\n+ \"lower\": \"1690308336981067344702891/500000000000000000000000\",\n+ \"upper\": \"3380616673963/1000000000000\"\n+ },\n+ \"19\": {\n+ \"lower\": \"3326549452691858921604477/1000000000000000000000000\",\n+ \"upper\": \"831637363173/250000000000\"\n+ },\n+ \"21\": {\n+ \"lower\": \"1613232997067438192556453/500000000000000000000000\",\n+ \"upper\": \"645293198827/200000000000\"\n+ },\n+ \"23\": {\n+ \"lower\": \"97984194247785927837711/31250000000000000000000\",\n+ \"upper\": \"313549421593/100000000000\"\n+ },\n+ \"439\": {\n+ \"lower\": \"186489018783128031620293/1000000000000000000000000\",\n+ \"upper\": \"5827781837/31250000000\"\n+ },\n+ \"483\": {\n+ \"lower\": \"45485889102863347153077/500000000000000000000000\",\n+ \"upper\": \"45485889103/500000000000\"\n+ },\n+ \"485\": {\n+ \"lower\": \"10854942615102023112003/125000000000000000000000\",\n+ \"upper\": \"86839540921/1000000000000\"\n+ },\n+ \"487\": {\n+ \"lower\": \"41362154387854795441797/500000000000000000000000\",\n+ \"upper\": \"10340538597/125000000000\"\n+ },\n+ \"489\": {\n+ \"lower\": \"4914121398964209759583/62500000000000000000000\",\n+ \"upper\": \"4914121399/62500000000\"\n+ },\n+ \"491\": {\n+ \"lower\": \"14908860812755760575863/200000000000000000000000\",\n+ \"upper\": \"1164754751/15625000000\"\n+ },\n+ \"493\": {\n+ \"lower\": \"70479257815609274180699/1000000000000000000000000\",\n+ \"upper\": \"8809907227/125000000000\"\n+ },\n+ \"495\": {\n+ \"lower\": \"8303833661201135020039/125000000000000000000000\",\n+ \"upper\": \"6643066929/100000000000\"\n+ },\n+ \"497\": {\n+ \"lower\": \"31199202880835327589349/500000000000000000000000\",\n+ \"upper\": \"31199202881/500000000000\"\n+ },\n+ \"499\": {\n+ \"lower\": \"29191168053390358164207/500000000000000000000000\",\n+ \"upper\": \"58382336107/1000000000000\"\n+ },\n+ \"501\": {\n+ \"lower\": \"54382330773434582958509/1000000000000000000000000\",\n+ \"upper\": \"27191165387/500000000000\"\n+ },\n+ \"503\": {\n+ \"lower\": \"6299782719820021899343/125000000000000000000000\",\n+ \"upper\": \"50398261759/1000000000000\"\n+ },\n+ \"505\": {\n+ \"lower\": \"11607500645734889032137/250000000000000000000000\",\n+ \"upper\": \"46430002583/1000000000000\"\n+ },\n+ \"507\": {\n+ \"lower\": \"8495485653423243622257/200000000000000000000000\",\n+ \"upper\": \"10619357067/250000000000\"\n+ },\n+ \"509\": {\n+ \"lower\": \"38540415307776638778641/1000000000000000000000000\",\n+ \"upper\": \"9635103827/250000000000\"\n+ },\n+ \"511\": {\n+ \"lower\": \"8654710413648736854011/250000000000000000000000\",\n+ \"upper\": \"6923768331/200000000000\"\n+ },\n+ \"513\": {\n+ \"lower\": \"15356293343764923709371/500000000000000000000000\",\n+ \"upper\": \"479884167/15625000000\"\n+ },\n+ \"515\": {\n+ \"lower\": \"1676345699660202265259/62500000000000000000000\",\n+ \"upper\": \"5364306239/200000000000\"\n+ },\n+ \"517\": {\n+ \"lower\": \"22945557349870250730611/1000000000000000000000000\",\n+ \"upper\": \"458911147/20000000000\"\n+ },\n+ \"519\": {\n+ \"lower\": \"477113717310268582119/25000000000000000000000\",\n+ \"upper\": \"19084548693/1000000000000\"\n+ },\n+ \"521\": {\n+ \"lower\": \"15238390104932463524609/1000000000000000000000000\",\n+ \"upper\": \"3047678021/200000000000\"\n+ },\n+ \"523\": {\n+ \"lower\": \"5703483896688240401681/500000000000000000000000\",\n+ \"upper\": \"5703483897/500000000000\"\n+ },\n+ \"525\": {\n+ \"lower\": \"7590169266675635911389/1000000000000000000000000\",\n+ \"upper\": \"7590169267/1000000000000\"\n+ },\n+ \"527\": {\n+ \"lower\": \"1893941658468527717403/500000000000000000000000\",\n+ \"upper\": \"3787883317/1000000000000\"\n+ }\n+ }\n+ },\n+ \"histogram\": {\n+ \"483\": 61280142,\n+ \"23\": 61280142,\n+ \"525\": 5653032,\n+ \"1\": 1690297301,\n+ \"527\": 6233920,\n+ \"489\": 293986,\n+ \"17\": 8476006,\n+ \"521\": 13711082,\n+ \"523\": 4629394,\n+ \"491\": 580888,\n+ \"15\": 7948248,\n+ \"485\": 545468,\n+ \"21\": 6906900,\n+ \"487\": 173558,\n+ \"19\": 1639946,\n+ \"493\": 14168,\n+ \"13\": 2164162,\n+ \"499\": 1129898,\n+ \"7\": 3580962,\n+ \"495\": 322322,\n+ \"11\": 5093396,\n+ \"505\": 99176,\n+ \"503\": 410872,\n+ \"3\": 1356586,\n+ \"501\": 127512,\n+ \"5\": 354200,\n+ \"507\": 1186570,\n+ \"509\": 340032,\n+ \"497\": 17710,\n+ \"9\": 1526602,\n+ \"513\": 106260,\n+ \"517\": 626934,\n+ \"515\": 1583274,\n+ \"511\": 322322,\n+ \"519\": 2854852,\n+ \"439\": 6272882,\n+ \"18\": 6272882\n+ },\n+ \"width\": 108516254,\n+ \"recursive_rank\": 57403754177,\n+ \"upstream_assembly\": {\n+ \"ok\": true,\n+ \"bad\": [],\n+ \"kappa\": \"1599247689723/25000000000000000\",\n+ \"eps\": \"9999360300924109/10000000000000000\",\n+ \"x\": 14695,\n+ \"c1\": \"14694\",\n+ \"binding\": \"simultaneous butterflies\",\n+ \"gap\": \"595385529075891/50000000000000000000000000000000\"\n+ }\n+ }\n+ ],\n+ \"complex_sources_unchanged_except_trailing_LF\": {\n+ \"independent/complex-twostage/run.py\": {\n+ \"old_sha256\": \"6df735b8a69cf5226e04bf70db0a750dcdbbf3e9eddbabd293620849d6eff7b6\",\n+ \"new_sha256\": \"fff6190b4f197689aad55077be882e8c95e0b699d366eadee5882cf8ff08be44\",\n+ \"only_trailing_LF_difference\": true\n+ },\n+ \"independent/complex-twostage/hist.py\": {\n+ \"old_sha256\": \"eedc3a641859e023fa8408200071d886d798ac8add238a282baebbe9b14124f1\",\n+ \"new_sha256\": \"e20d077acfc95e2f8239fcdcc03146cc15607996e2734eb2d00b68ed7d43ec64\",\n+ \"only_trailing_LF_difference\": true\n+ },\n+ \"independent/complex-twostage/producer.py\": {\n+ \"old_sha256\": \"4c6a37eeda2f31af7adb7964e75eed37dc1bec08c41e622935ff1d99ac0d3f36\",\n+ \"new_sha256\": \"e1715616ac8cafa8f63b7c0a2e7deacdba7daea94662e0a84626d5374fd27b5c\",\n+ \"only_trailing_LF_difference\": true\n+ },\n+ \"independent/complex-twostage/cert.py\": {\n+ \"old_sha256\": \"3c3c5b13d970dc7d5647ff3969ff232c6d0b2182d959703e4b2b1ba79a268f21\",\n+ \"new_sha256\": \"f9352729213b8441d076708b738d158093caa34d050fa2d838b61e07eb3a298b\",\n+ \"only_trailing_LF_difference\": true\n+ },\n+ \"independent/complex-twostage/frames.py\": {\n+ \"old_sha256\": \"f1a04569997828560f4197f4c654ce752173ec2df3d9e69233c9ed4031d02abb\",\n+ \"new_sha256\": \"8629850bd465250cdf298b47b86504f2ac507d5fa044f8c0d2a20b451d19aa0f\",\n+ \"only_trailing_LF_difference\": true\n+ }\n+ },\n+ \"complex_histogram_field_equal\": true,\n+ \"scope\": \"Independent bit moment enclosures; foreign assembly values reproduced by foreign evaluator, not independent verification of full assembly obligations. Reuse unchanged complex scalar/frame/moment checks only within their recorded scope. Full complex dirty/phase/precision/tape and stage-two physical composition remain open.\",\n+ \"new_multiplication_bound\": false\n+}" + }, + { + "sha": "869231d71d1f1298ed521fa643d9989bfdb2633b", + "filename": "research/deferred-signed/validation-prior/swapnil-round7-validation-job.json", + "status": "added", + "additions": 41, + "deletions": 0, + "changes": 41, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-validation-job.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-validation-job.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fvalidation-prior%2Fswapnil-round7-validation-job.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,41 @@\n+{\n+ \"pid\": 30700,\n+ \"started_at\": \"2026-10-08T21:07:24.820537+00:00\",\n+ \"head\": \"741e7aa078392553815df7926ee17ac5e25a8c38\",\n+ \"state\": \"completed_upstream_finite_checks\",\n+ \"stages\": [\n+ {\n+ \"name\": \"frames\",\n+ \"returncode\": 0,\n+ \"elapsed\": 219.62570874998346,\n+ \"limit_seconds\": 1800,\n+ \"log\": \"/Users/chenzhihao/Documents/Codex/2026-10-08/https-github-com-crocswap-integer-mult/work/target14/swapnil-round7/frames-replay.log\"\n+ },\n+ {\n+ \"name\": \"lifted\",\n+ \"returncode\": 0,\n+ \"elapsed\": 351.644068542053,\n+ \"limit_seconds\": 1800,\n+ \"log\": \"/Users/chenzhihao/Documents/Codex/2026-10-08/https-github-com-crocswap-integer-mult/work/target14/swapnil-round7/lifted-replay.log\"\n+ },\n+ {\n+ \"name\": \"stair\",\n+ \"returncode\": 0,\n+ \"elapsed\": 1.9291679169982672,\n+ \"limit_seconds\": 180,\n+ \"log\": \"/Users/chenzhihao/Documents/Codex/2026-10-08/https-github-com-crocswap-integer-mult/work/target14/swapnil-round7/stair-replay.log\"\n+ },\n+ {\n+ \"name\": \"stair_control\",\n+ \"returncode\": 0,\n+ \"elapsed\": 1.5355807919986546,\n+ \"limit_seconds\": 180,\n+ \"log\": \"/Users/chenzhihao/Documents/Codex/2026-10-08/https-github-com-crocswap-integer-mult/work/target14/swapnil-round7/stair_control-replay.log\",\n+ \"expected_rejection_seen\": true\n+ }\n+ ],\n+ \"physical_stage_two_checked\": false,\n+ \"new_multiplication_bound\": false,\n+ \"active_stage\": null,\n+ \"stage_started_at\": \"2026-10-08T21:16:58.031546+00:00\"\n+}" + }, + { + "sha": "b3536e65e5ecb3222acf1c0e92d7ed330eed20cb", + "filename": "research/deferred-signed/verify.py", + "status": "added", + "additions": 99, + "deletions": 0, + "changes": 99, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fverify.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fdeferred-signed%2Fverify.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fdeferred-signed%2Fverify.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,99 @@\n+#!/usr/bin/env python3\n+\"\"\"Verify immutable inputs, exact moments and bridge; optionally replay ledgers.\n+Zhihao Chen / Codex. Moment enclosure adapted from the retained PR36/39 checker.\n+\"\"\"\n+import argparse,hashlib,json,subprocess,sys,tempfile,shutil,time\n+from pathlib import Path\n+from fractions import Fraction as Q\n+HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1]\n+\n+def read(p):return json.loads(Path(p).read_text())\n+def ceil(x):return -(-x.numerator//x.denominator)\n+def logs(x):\n+ x=Q(x);power=0\n+ while x>2:x/=2;power+=1\n+ def term(y):\n+ z=(y-1)/(y+1);lo=2*sum((z**(2*j+1)/Q(2*j+1) for j in range(24)),Q())\n+ return lo,lo+2*z**49/(49*(1-z*z))\n+ lo,hi=term(x);l2,h2=term(Q(2));lo+=power*l2;hi+=power*h2\n+ return Q((lo*10**24).__floor__(),10**24),Q(ceil(hi*10**12),10**12)\n+def moment(m,W,H,a):\n+ lower=Q();upper=Q()\n+ for t,n in H.items():\n+ assert 00\n+ lo,hi=logs(Q(m,t));u,w=a*lo,a*hi;assert 0<=u<=w<1\n+ weight=Q(n*t,m*W)\n+ lower+=weight*(1+u+u*u/2+u*u*u/6)\n+ upper+=weight*(1+w+w*w/(2*(1-w/3)))\n+ return lower,upper\n+def stable(x):\n+ if isinstance(x,dict):return {k:stable(v) for k,v in x.items() if k not in ('elapsed',)}\n+ if isinstance(x,list):return [stable(v) for v in x]\n+ return x\n+def verify_pins():\n+ pins=read(HERE/'SOURCE.json')\n+ for rel,sha in pins['files'].items():\n+ assert hashlib.sha256((ROOT/rel).read_bytes()).hexdigest()==sha,('source drift',rel)\n+ foreign=read(HERE/'swapnil-round7/IMPORT.json')\n+ for rel,sha in foreign['files'].items():\n+ assert hashlib.sha256((HERE/'swapnil-round7'/rel).read_bytes()).hexdigest()==sha,('foreign drift',rel)\n+ # Portability edits are limited to resolving a preserved equal histogram\n+ # and the inherited assembly module from this repository root.\n+ for name in ('round7_literal_frame_ledger.py','round7_tensor_endpoint_controls.py','round6_complex_interface_controls.py','round6_complex_literal_ledger.py','round7_balanced_assembly_candidate.py'):\n+ old=(HERE/'validation-prior'/name).read_text()\n+ if name=='round6_complex_literal_ledger.py':\n+ old=old.replace(\"old=json.loads((HERE/'swapnil-round6/independent/complex-twostage/hist_24.json').read_text())\", \"old=json.loads((HERE/'swapnil-round7/lean/round6-histograms.json').read_text())['cx']; old['hist']=dict(old['hist'])\")\n+ if name=='round7_balanced_assembly_candidate.py':\n+ old=old.replace(\"HERE/'integration/scripts'\", \"HERE.parents[1]/'scripts'\").replace(\"HERE/'integration/scripts/structured_bulk_assembly.py'\", \"HERE.parents[1]/'scripts/structured_bulk_assembly.py'\")\n+ assert old==(HERE/name).read_text(),('unreviewed port edit',name)\n+ return len(pins['files'])\n+\n+def main():\n+ assert __debug__,'verification requires assertions'\n+ ap=argparse.ArgumentParser();ap.add_argument('--replay',action='store_true');ap.add_argument('--replay-own',action='store_true');args=ap.parse_args()\n+ count=verify_pins();bit=read(HERE/'round7-literal-ledger/result.json');cx=read(HERE/'round6-complex-literal-ledger/result.json')\n+ assert all(bit[k] for k in ('complete_forward_F2','complete_reflected_F2','reflected_frame_continuity','histogram_matches_external'))\n+ assert all(cx[k] for k in ('actual_forward_equal_frames','reflected_continuity','actual_geometry_passed','histogram_matches_pinned'))\n+ H={int(t):n for t,n in bit['histogram'].items()};C={int(t):n for t,n in cx['full_histogram'].items()}\n+ assert sum(t*n for t,n in H.items())==57403754177\n+ assert sum(t*n for t,n in C.items())==119453132304\n+ expected=read(HERE/'swapnil-round7/lean/round6-histograms.json')['cx']\n+ assert C==dict(expected['hist'])\n+ ab,ac=Q(31987,500000000),Q(36926111,500000000000)\n+ mb=moment(529,108516254,H,ab);mc=moment(576,207387136,C,ac)\n+ assert mb[1]<1 and mc[1]<1\n+ cert=read(HERE/'round7-balanced-assembly-candidate.json')\n+ assert cert['source_assembly_sha256']==hashlib.sha256((ROOT/'scripts/structured_bulk_assembly.py').read_bytes()).hexdigest()\n+ assert Q(cert['candidate_kappa'])==Q(63965813,10**12)>Q(1,16384)\n+ assert len(cert['assembly']['strict_constraints'])==47 and len(cert['assembly']['margins'])==7\n+ assert all(Q(x)>0 for x in cert['assembly']['strict_constraints'].values())\n+ assert all(Q(x)>Q(cert['candidate_kappa']) for x in cert['assembly']['margins'].values())\n+ job=read(HERE/'validation-prior/swapnil-round7-validation-job.json')\n+ assert job['state']=='completed_upstream_finite_checks'\n+ assert all(x['returncode']==0 for x in job['stages']) and job['stages'][-1]['expected_rejection_seen']\n+ # All regenerated outputs live in a disposable tree; never rewrite a\n+ # source pin or erase the original measured receipt.\n+ with tempfile.TemporaryDirectory(prefix='deferred-signed-') as tmp:\n+ root=Path(tmp);pkg=root/'research/deferred-signed';shutil.copytree(HERE,pkg)\n+ (root/'scripts').mkdir();shutil.copy2(ROOT/'scripts/structured_bulk_assembly.py',root/'scripts/structured_bulk_assembly.py')\n+ jobs=[('check_complex_identity.py',None,120),('round7_balanced_assembly_candidate.py','round7-balanced-assembly-candidate.json',120)]\n+ if args.replay or args.replay_own:\n+ jobs=[('round7_literal_frame_ledger.py','round7-literal-ledger/result.json',180),\n+ ('round7_tensor_endpoint_controls.py','round7-tensor-endpoint-controls.json',120),\n+ ('round6_complex_interface_controls.py','round6-complex-interface-controls.json',120),\n+ ('round6_complex_literal_ledger.py','round6-complex-literal-ledger/result.json',180)]+jobs\n+ for script,out,limit in jobs:\n+ r=subprocess.run([sys.executable,script],cwd=pkg,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True,timeout=limit)\n+ assert r.returncode==0,(script,r.stdout[-4000:])\n+ if out is not None:assert stable(read(pkg/out))==stable(read(HERE/out)),('regeneration drift',out)\n+ print('PASS',script,flush=True)\n+ if args.replay:\n+ src=pkg/'swapnil-round7';dd='independent/deferred-readout/'\n+ for argv,limit in [([dd+'check_word.py','23'],180),([dd+'check_frames.py','23'],1800),([dd+'check_lifted.py','23'],1800),([dd+'check_stair.py','23'],180),([dd+'check_stair.py','23','--control'],180)]:\n+ r=subprocess.run([sys.executable]+argv,cwd=src,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True,timeout=limit)\n+ assert r.returncode==0,(argv,r.stdout[-4000:])\n+ if '--control' in argv:assert 'certified=False' in r.stdout\n+ print('PASS native',argv,flush=True)\n+ print('PASS',count,'pins; both independent moments; 47 constraints; 7 margins; kappa=63965813/10^12 > 2^-14')\n+ print('Conditional on retained analytic/fixed-tape interfaces; not formal verification of the full theorem.')\n+if __name__=='__main__':main()" + }, + { + "sha": "ff8cf2ab100ca13d099347c8375b20ffe4e13594", + "filename": "research/joint-dual/SOURCE.json", + "status": "modified", + "additions": 3, + "deletions": 3, + "changes": 6, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fjoint-dual%2FSOURCE.json", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/research%2Fjoint-dual%2FSOURCE.json", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research%2Fjoint-dual%2FSOURCE.json?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -3,9 +3,9 @@\n \"base_pr57_commit\": \"cd350f76c9bc01489ec83568bded532cb69be938\",\n \"base_pr58_commit\": \"bc2f7ed4c20dc18898305ab17165c0c995cbb804\",\n \"files\": {\n- \"Makefile\": \"97620e0205736d9c0fce736e8ac6ab67f8ed0e490c381f6cac152cc6a003dca7\",\n- \"NOTICE\": \"1c53970fb4face631a1b331ec66d33111eccd280a129f9b64c2da6df96861c3f\",\n- \"README.md\": \"fd92de31aece76b1f5ff897e6e0dbc38dd3bf67c140579bbcb03a1a11a792668\",\n+ \"Makefile\": \"a89772184646c7b05ab0dd4c8b128defbfd6e15aea46ac8b0655c1f313001109\",\n+ \"NOTICE\": \"a0030510cd3b5334fb113eae759aadd2c25951bd353dfb69ad9cb780ae5adf30\",\n+ \"README.md\": \"e64fba8077840a0341890e7f740f9aa7699df8fc1e56804f6a11aaeb8baa53a6\",\n \"certificates/joint-dual-compiler.json\": \"516c4d85158553dabd0a98216a064b2a7397957a9d5dd0df1d6e5aec53a4e805\",\n \"certificates/joint-dual-profiles-23.json\": \"159fa8fee175fc1d24f63e72d3c2f1dc9f4fcd78b938c5e7d2f735fd0fd37209\",\n \"certificates/joint-dual-profiles-25.json\": \"8d190ce42d097e828c5756918c52f2963df576cf4c6600b0fc7f2b7fdb6ad223\"," + }, + { + "sha": "b8db662f7182fe59602784b5e05600c613ce99bb", + "filename": "scripts/deferred_product/complex_frames.py", + "status": "added", + "additions": 388, + "deletions": 0, + "changes": 388, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product%2Fcomplex_frames.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product%2Fcomplex_frames.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product%2Fcomplex_frames.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,388 @@\n+#!/usr/bin/env python3\n+\"\"\"Independent gate-frame check of a signed two-stage complex word (round6 layout), from the definitions.\n+\n+Not derived from #97's round6_complex_literal_ledger.py or from frames.Checker: own F2 algebra, own labels, own\n+schedule. Sources: research/deferred-signed/PROOF.md (complex section), frames.py's docstring for the label\n+definition and the whole-residual condition, notes on copied centers.\n+\n+Frames are F2-subspaces of F2^h with the dot product. A move U -> V of one role is legal iff U <= V and the residual\n+V cap U^perp is nondegenerate and nonalternating (has an odd-weight vector); its paid rank is dim V - dim U.\n+Forward stage-one schedule (one invocation), from PROOF.md \"first subtracts AMz from y, restores z, injects Vx, adds\n+AM(z+Vx), and then restores z by M^-1 and -V\", with copied centers:\n+ A M at 0 B readouts at 0: retained centers and pieces into targets (targets at 0)\n+ C M^-1 at 0 D V: source slot and X_t at \n+ E M at labels F copied centers: copy at its frame -> 0, scatter into targets at 0\n+ G pieces at t^perp H M^-1 at F I -V at F J every role -> F\n+Stage two = reversed word, complemented frames, banks exchanged; checked for continuity.\n+Usage: cx_gate_check.py WORD.json [CLAIMED_RESULT.json] [--mutation NAME]\n+\"\"\"\n+import sys, json\n+from collections import Counter\n+from fractions import Fraction as Q\n+\n+# ---------------------------------------------------------------- F2 algebra (bitmask vectors over h points)\n+def reduce_vec(basis, x):\n+ for p, b in basis:\n+ if x >> p & 1:\n+ x ^= b\n+ return x\n+\n+def make_basis(vectors):\n+ basis = [] # list of (pivot bit, vector), pivots distinct\n+ for x in vectors:\n+ x = reduce_vec(basis, x)\n+ if x:\n+ p = x.bit_length() - 1\n+ basis = [(q, b ^ x if b >> p & 1 else b) for q, b in basis]\n+ basis.append((p, x))\n+ return tuple(sorted(basis))\n+\n+def vecs(B):\n+ return [b for p, b in B]\n+\n+def contains(V, U):\n+ return all(reduce_vec(V, u) == 0 for u in vecs(U))\n+\n+def dot(a, b):\n+ return bin(a & b).count('1') & 1\n+\n+def perp_within(V, U):\n+ \"\"\"basis of V cap U^perp.\"\"\"\n+ vs = vecs(V); us = vecs(U)\n+ rows = [(sum(dot(v, u) << j for j, u in enumerate(us)), 1 << i) for i, v in enumerate(vs)]\n+ kernel = []\n+ for col in range(len(us)):\n+ bit = 1 << col\n+ k = next((i for i, (a, _) in enumerate(rows) if a & bit), None)\n+ if k is None:\n+ continue\n+ a0, c0 = rows.pop(k)\n+ rows = [(a ^ a0, c ^ c0) if a & bit else (a, c) for a, c in rows]\n+ for a, c in rows:\n+ x = 0\n+ for i, v in enumerate(vs):\n+ if c >> i & 1:\n+ x ^= v\n+ kernel.append(x)\n+ return make_basis(kernel)\n+\n+def nondegenerate(B):\n+ vs = vecs(B)\n+ gram = [sum(dot(a, b) << j for j, b in enumerate(vs)) for a in vs]\n+ return len(make_basis(gram)) == len(vs)\n+\n+ALLOW_ALTERNATING = '--allow-alternating' in sys.argv # notes/endpoint-gauge-complex.tex normal form\n+ALTERNATING = Counter()\n+\n+def residual_ok(R):\n+ \"\"\"Whole-residual child: nondegenerate; nonalternating unless --allow-alternating (round6's stricter rule).\"\"\"\n+ if not R:\n+ return True\n+ if not nondegenerate(R):\n+ return False\n+ if any(bin(x).count('1') & 1 for x in vecs(R)):\n+ return True\n+ ALTERNATING[len(R)] += 1\n+ return ALLOW_ALTERNATING\n+\n+\n+def _name(k):\n+ \"\"\"retained-output name from a JSON key: '[\"E\", 3]', \"('E', 3)\", 'E,3' or '*'.\"\"\"\n+ import ast\n+ if isinstance(k, (list, tuple)):\n+ return tuple(k)\n+ for parse in (json.loads, ast.literal_eval):\n+ try:\n+ x = parse(k)\n+ return tuple(x) if isinstance(x, (list, tuple)) else (x,)\n+ except Exception:\n+ pass\n+ parts = k.split(',')\n+ return tuple(int(p) if p.strip().lstrip('-').isdigit() else p.strip() for p in parts)\n+\n+\n+class Word:\n+ def __init__(s, d):\n+ from itertools import combinations\n+ s.h = h = d['h']\n+ if 'roles' in d: # port97 layout (foamy): node-indexed args, roles{}\n+ s.triples = [tuple(t) for t in combinations(range(h), 3)]\n+ args = d['args']\n+ sup = [0] * len(args)\n+ for i in range(len(s.triples)):\n+ assert args[i + 1] is None\n+ sup[i + 1] = 1 << i\n+ for n in range(len(s.triples) + 1, len(args)):\n+ if args[n] is None:\n+ continue\n+ a, b = args[n]\n+ assert 0 < a < n and 0 < b < n and not sup[a] & sup[b], ('cancellation or order', n)\n+ sup[n] = sup[a] | sup[b]\n+ s.nodes = {int(n): dict(sup=sup[n], args=args[n]) for n in d['active']}\n+ ro = dict(d['roles'])\n+ if isinstance(ro['src'], list):\n+ ro['src'] = {','.join(map(str, S)): sl for S, sl in ro['src']}\n+ if isinstance(ro['rout'], list):\n+ ro['rout'] = {json.dumps([nm] if isinstance(nm, str) else list(nm)): sl for nm, sl in ro['rout']}\n+ else:\n+ s.triples = [tuple(t) for t in d['triples']]\n+ s.nodes = {int(n): x for n, x in d['nodes'].items()}\n+ ro = d\n+ s.tid = {t: i for i, t in enumerate(s.triples)}\n+ s.v = len(s.triples)\n+ s.pieces = [(tuple(S), n, coef) for S, n, coef in d['pieces']]\n+ s.retained = [(_name([e[0]] if isinstance(e[0], str) else e[0]), e[1]) for e in d['retained']]\n+ s.R = ro['size']\n+ s.gates = [(n, tuple(ins), tuple(outs)) for n, ins, outs in ro['gates']]\n+ s.src = {tuple(map(int, str(k).strip('()[] ').split(','))): v for k, v in ro['src'].items()}\n+ s.pout = {int(i): sl for i, sl in ro['pout'].items()} if isinstance(ro['pout'], dict) else dict(enumerate(ro['pout']))\n+ s.rout = {_name(k): sl for k, sl in ro['rout'].items()}\n+ for n in s.nodes: # leaves: node i+1 is triple i\n+ if not s.nodes[n]['args']:\n+ assert s.nodes[n]['sup'] == 1 << (n - 1), ('leaf numbering', n)\n+ s.ZERO = make_basis([])\n+ s.FULL = make_basis([1 << i for i in range(h)])\n+ s.tvec = [sum(1 << p for p in t) for t in s.triples]\n+ s.line = [make_basis([x]) for x in s.tvec]\n+ s.hyper = [perp_within(s.FULL, L) for L in s.line]\n+ s._label = {}\n+\n+ def label(s, n):\n+ \"\"\"leaf ; several triples sharing a common pair -> span of indicators; else covered coordinates.\"\"\"\n+ if n not in s._label:\n+ sup = s.nodes[n]['sup']\n+ idx = [i for i in range(s.v) if sup >> i & 1]\n+ if len(idx) == 1:\n+ B = make_basis([s.tvec[idx[0]]])\n+ else:\n+ common = set(s.triples[idx[0]]).intersection(*[s.triples[i] for i in idx[1:]])\n+ if len(common) >= 2:\n+ B = make_basis([s.tvec[i] for i in idx])\n+ else:\n+ cover = 0\n+ for i in idx:\n+ cover |= s.tvec[i]\n+ B = make_basis([1 << p for p in range(s.h) if cover >> p & 1])\n+ s._label[n] = B\n+ return s._label[n]\n+\n+\n+def center_terms(w):\n+ \"\"\"targets and coefficients of the retained readouts (PROOF.md: twice the centre scatter at S is\n+ 2T - sum_{i in S} E_i if h-1 not in S, and (5-h)T + sum_{i, Y and aux at 0\n+ if mutation == 'merged-entrance':\n+ for q in sample:\n+ cur[off + q] = None # source frame shifted below 0 (symbolic)\n+ initial = list(cur)\n+ events = [] # ('move', reg, old, new) | ('add', a, b) | ('copy', reg, f, terms)\n+ bad = []\n+ cache = {}\n+\n+ def move(reg, f, where):\n+ old = cur[reg]\n+ if old == f:\n+ return\n+ if old is None:\n+ bad.append((where, reg, 'shifted source must pass the background gate at 0'))\n+ cur[reg] = f\n+ return\n+ key = (old, f)\n+ if key not in cache:\n+ cache[key] = contains(f, old) and residual_ok(perp_within(f, old))\n+ if not cache[key]:\n+ bad.append((where, reg, len(old), len(f)))\n+ events.append(('move', reg, old, f))\n+ cur[reg] = f\n+\n+ def add(a, b, where):\n+ if cur[a] != cur[b]:\n+ bad.append((where, 'unequal frames', a, b))\n+ events.append(('add', a, b))\n+\n+ def mix(mode, inverse, where):\n+ for n, ins, outs in (reversed(w.gates) if inverse else w.gates):\n+ f = w.ZERO if mode == 'low' else w.FULL if mode == 'high' else w.label(n)\n+ for q in sorted(set(ins + outs)):\n+ move(off + q, f, where)\n+ if inverse:\n+ for q in reversed(outs[1:]):\n+ add(off + q, off + outs[0], where)\n+ if len(ins) == 2:\n+ add(off + ins[0], off + ins[1], where)\n+ else:\n+ if len(ins) == 2:\n+ add(off + ins[0], off + ins[1], where)\n+ for q in outs[1:]:\n+ add(off + q, off + outs[0], where)\n+\n+ terms = center_terms(w)\n+\n+ def centers(copied, where):\n+ for name, sl in sorted(w.rout.items()):\n+ reg = off + sl\n+ if copied:\n+ f = cur[reg]\n+ if not residual_ok(f):\n+ bad.append((where, reg, 'copy transform residual'))\n+ for t, _ in terms[name]:\n+ if cur[t] != w.ZERO:\n+ bad.append((where, 'target not at 0 for copied centre', t))\n+ events.append(('copy', reg, f, tuple(t for t, _ in terms[name])))\n+ else:\n+ move(reg, w.ZERO, where)\n+ for t, _ in terms[name]:\n+ add(t, reg, where)\n+\n+ def pieces(high, where):\n+ for i, (S, n, cf) in enumerate(w.pieces):\n+ t = w.tid[S]\n+ f = w.hyper[t] if high else w.ZERO\n+ move(off + w.pout[i], f, where); move(v + t, f, where); add(v + t, off + w.pout[i], where)\n+\n+ def sources(high, where):\n+ for T, sl in sorted(w.src.items()):\n+ t = w.tid[T]\n+ f = w.FULL if high else w.line[t]\n+ move(off + sl, f, where); move(t, f, where); add(off + sl, t, where)\n+\n+ mix('low', False, 'A')\n+ centers(False, 'B'); pieces(False, 'B')\n+ mix('low', True, 'C')\n+ sources(False, 'D')\n+ mix('label', False, 'E')\n+ if mutation == 'centres-after-pieces':\n+ pieces(True, 'G'); centers(True, 'F')\n+ else:\n+ centers(True, 'F'); pieces(True, 'G')\n+ mix('high', True, 'H')\n+ sources(True, 'I')\n+ for s in range(R):\n+ move(off + s, w.FULL, 'J')\n+ final = list(cur)\n+ ok_final = final[:v] == [w.FULL] * v and final[v:off] == w.hyper and final[off:] == [w.FULL] * R\n+ return events, initial, final, bad, ok_final\n+\n+\n+def reflect(w, events, initial, final):\n+ \"\"\"Stage two: reversed events, complemented frames, banks exchanged; continuity of every role.\"\"\"\n+ v = w.v; off = 2 * v\n+ bank = lambda s: s + v if s < v else s - v if s < off else s\n+ rev = {}\n+ for s, f in enumerate(final):\n+ rev[bank(s)] = ('comp', f)\n+ breaks = 0\n+ for e in reversed(events):\n+ if e[0] == 'move':\n+ _, reg, old, new = e\n+ r = bank(reg)\n+ if rev[r] != ('comp', new):\n+ breaks += 1\n+ rev[r] = ('comp', old)\n+ elif e[0] == 'add':\n+ if rev[bank(e[1])] != rev[bank(e[2])]:\n+ breaks += 1\n+ else:\n+ _, reg, f, targets = e\n+ if rev[bank(reg)] != ('comp', f) or any(rev[bank(t)] != ('comp', w.ZERO) for t in targets):\n+ breaks += 1\n+ end = all(rev[bank(s)] == ('comp', initial[s]) for s in range(len(initial)) if initial[s] is not None)\n+ return breaks, end\n+\n+\n+def paid_histogram(w, events):\n+ v = w.v; off = 2 * v; h = w.h; m = h * h; N = v * v\n+ hist = Counter()\n+ cls = Counter()\n+ for e in events:\n+ if e[0] == 'move':\n+ r = len(e[3]) - len(e[2])\n+ hist[r] += 1\n+ cls['aux' if e[1] >= off else 'data'] += r\n+ elif e[0] == 'copy':\n+ hist[len(e[2])] += 1\n+ cls['center'] += len(e[2])\n+ paid = Counter({r: 2 * v * n for r, n in hist.items()})\n+ paid[m - h] += 2 * v * w.R\n+ paid[(h - 1) ** 2] += 2 * N\n+ paid[1] += N\n+ return paid, cls\n+\n+\n+def moment_report(paid, m, W):\n+ \"\"\"Float sanity check (fsum) of sum_t t n_t/(mW) (m/t)^a at a few savings; the exact certificate is elsewhere.\"\"\"\n+ from math import fsum, exp, log\n+ def mom(a):\n+ return fsum(t * n * exp(a * log(m / t)) for t, n in paid.items()) / (m * W)\n+ out = {}\n+ for a in (Q(258969, 2500000000), Q(258970, 2500000000), Q(36926111, 500000000000),\n+ Q(1037353, 10**10), Q(1037354, 10**10)):\n+ out[str(a)] = '%.15f' % mom(float(a))\n+ return out\n+\n+\n+def main():\n+ w = Word(json.load(open(sys.argv[1])))\n+ claimed = None\n+ args = [a for a in sys.argv[2:] if a != '--allow-alternating']\n+ mutation = None\n+ if '--mutation' in args:\n+ mutation = args[args.index('--mutation') + 1]\n+ args = [a for a in args if a not in ('--mutation', mutation)]\n+ if args:\n+ cj = json.load(open(args[0]))\n+ claimed = {int(k): v for k, v in (cj['full_histogram'] if 'full_histogram' in cj else cj['rows']).items()}\n+ sample = range(0, w.R, 101) if mutation == 'merged-entrance' else ()\n+ if mutation == 'degenerate-label':\n+ n0 = next(n for n, x in sorted(w.nodes.items()) if x['args'])\n+ w._label[n0] = make_basis([0b11, 0b1100]) # alternating 2-plane: residual must fail\n+ if mutation == 'link-swap':\n+ g = [i for i, (n, ins, outs) in enumerate(w.gates) if len(ins) == 2]\n+ a, b = g[len(g) // 3], g[2 * len(g) // 3]\n+ (na, ia, oa), (nb, ib, ob) = w.gates[a], w.gates[b]\n+ w.gates[a], w.gates[b] = (nb, ia, oa), (na, ib, ob) # a donor's slot meets a non-nested consumer frame\n+ events, initial, final, bad, ok_final = forward(w, mutation, sample)\n+ breaks, end = reflect(w, events, initial, final)\n+ paid, cls = paid_histogram(w, events)\n+ rank = sum(r * n for r, n in paid.items())\n+ v, h = w.v, w.h\n+ res = dict(h=h, roles=w.R, events=len(events), moves=sum(1 for e in events if e[0] == 'move'),\n+ violations=len(bad), first=[str(x) for x in bad[:3]], final_states_ok=ok_final,\n+ stage_two_breaks=breaks, stage_two_endpoints_ok=end,\n+ aux_rank=cls['aux'], aux_expected=w.R * h, data_rank=cls['data'], data_expected=2 * v * (h - 1),\n+ center_rank=cls['center'],\n+ center_expected=(h - 1) ** 2 + h if ('*',) in w.rout else len(w.rout) * (h - 1),\n+ recursive_rank=rank, maxchild=max(paid),\n+ histogram_matches_claim=(dict(paid) == claimed) if claimed is not None else None,\n+ histogram_diff=({r: (paid.get(r, 0), claimed.get(r, 0)) for r in set(paid) | set(claimed)\n+ if paid.get(r, 0) != claimed.get(r, 0)} if claimed is not None else None),\n+ W=2 * v * v + 2 * v * w.R,\n+ moment_at=moment_report(paid, h * h, 2 * v * v + 2 * v * w.R),\n+ alternating_residuals_by_rank=dict(ALTERNATING), allow_alternating=ALLOW_ALTERNATING,\n+ mutation=mutation)\n+ print(json.dumps(res, indent=1))\n+\n+\n+if __name__ == '__main__':\n+ main()" + }, + { + "sha": "673fbbba70fd80b490d7990bf3c4c682e34e385d", + "filename": "scripts/deferred_product/replayed.py", + "status": "added", + "additions": 179, + "deletions": 0, + "changes": 179, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product%2Freplayed.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product%2Freplayed.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product%2Freplayed.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,179 @@\n+\"\"\"Replayed h=24 complex producer with all centers disjoint (rational divisor 21).\n+\n+Copyright 2026 eumemic, Apache-2.0. AI-assisted (Claude). The DAG was found by an\n+automated search over producers of the retained paired-triple, pair-star and\n+center-disjoint interfaces. The checks below are adapted from\n+stopped_product/complex.py (copyright 2026 icekylinx, Apache-2.0, PR #104).\n+\n+The witness complex-dag.json.gz lists the ordinary\n+additions after the v triple inputs and the retained roots: the disjoint sums\n+D[t], the pair stars P(a,b,i) and the center-disjoint sums A_i. Every support,\n+core, cover, type and rank is recomputed here from the operands; nothing is\n+read from the witness except the operand pairs and the root indices.\n+\"\"\"\n+import gzip, json, struct, sys, array\n+from fractions import Fraction\n+from itertools import combinations\n+from pathlib import Path\n+\n+\n+def write_array(f, values):\n+ \"\"\"Little-endian array writer, as partial_swap.binary.write_array.\"\"\"\n+ if sys.byteorder != 'little' and values.itemsize > 1:\n+ values = array.array(values.typecode, values)\n+ values.byteswap()\n+ values.tofile(f)\n+\n+\n+def build(witness, prefix):\n+ w = json.loads(gzip.decompress(Path(witness).read_bytes()))\n+ h, v, d = w['h'], w['v'], w['central_disjoint']\n+ assert (h, d, w['center_denominator']) == (24, 24, 21)\n+ triples = list(combinations(range(h), 3))\n+ assert v == len(triples)\n+ args = [(0, 0)]; support = [0]; core = [0]; cover = [0]; types = [0]; ranks = [0]\n+ for j, t in enumerate(triples):\n+ mask = sum(1 << a for a in t)\n+ args.append((0, 0)); support.append(1 << j); core.append(mask); cover.append(mask)\n+ types.append(1); ranks.append(1)\n+ flat = w['args']\n+ assert len(flat) % 2 == 0\n+ for k in range(0, len(flat), 2):\n+ a, b, x = flat[k], flat[k+1], len(args)\n+ assert 0 < a < x and 0 < b < x, 'Operands must precede their sum'\n+ assert not support[a] & support[b], 'Ordinary additions must be cancellation-free'\n+ args.append((a, b)); support.append(support[a] | support[b])\n+ core.append(core[a] & core[b]); cover.append(cover[a] | cover[b])\n+ if core[x].bit_count() >= 2:\n+ types.append(1); ranks.append(support[x].bit_count())\n+ else:\n+ types.append(2); ranks.append(cover[x].bit_count())\n+ n = len(args)\n+ point_masks = [sum(1 << j for j, t in enumerate(triples) if a in t) for a in range(h)]\n+ full_support = (1 << v) - 1\n+ roots, kind = [], []\n+ assert len(w['D']) == v\n+ for t, node in zip(triples, w['D']):\n+ assert 0 < node < n\n+ assert support[node] == full_support & ~(point_masks[t[0]]|point_masks[t[1]]|point_masks[t[2]])\n+ target_mask = sum(1 << a for a in t)\n+ if types[node] == 2:\n+ assert not cover[node] & target_mask\n+ else:\n+ assert types[node] == 1\n+ assert not support[node] & (point_masks[t[0]]^point_masks[t[1]]^point_masks[t[2]])\n+ roots.append(node); kind.append(0)\n+ stars = [(a, b, i) for a, b in combinations(range(h), 2) for i in range(h) if i not in (a, b)]\n+ assert len(w['P']) == len(stars)\n+ pair_outputs = {}\n+ for (a, b, i), node in zip(stars, w['P']):\n+ assert 0 < node < n\n+ assert support[node] == point_masks[a] & point_masks[b] & ~point_masks[i]\n+ assert types[node] == 1\n+ assert not support[node] & (point_masks[a]^point_masks[b]^point_masks[i])\n+ pair_outputs[a, b, i] = node\n+ roots.append(node); kind.append(0)\n+ assert len(w['A']) == d\n+ for i, node in enumerate(w['A']):\n+ assert 0 < node < n\n+ assert support[node] == full_support & ~point_masks[i]\n+ assert types[node] == 2 and cover[node] == ((1 << h)-1) ^ (1 << i)\n+ assert ranks[node] == h-1\n+ roots.append(node); kind.append(1)\n+ # Every A_i avoids i, so sum A_i = (h-3)T. The decoder is T=sum A_i/21\n+ # and the scatter is T-(1/2)sum_{i in target} A_i.\n+ decoder = Fraction(1, h-3)\n+ assert decoder == Fraction(1, 21)\n+ scatter_coefficients = [decoder, decoder-Fraction(1, 2)]\n+ for coefficient in scatter_coefficients:\n+ odd_denominator = coefficient.denominator\n+ while odd_denominator % 2 == 0:\n+ odd_denominator //= 2\n+ assert 21 % odd_denominator == 0 and abs(coefficient) <= 1\n+ for source in triples:\n+ assert sum(i not in source for i in range(h))*decoder == 1\n+ Dset = set(range(d))\n+ for triple in triples:\n+ k = len(Dset.intersection(triple))\n+ assert 2*(3-k)-2*(d-k) == 2*(3-d)\n+ patterns = {}\n+ for target in triples:\n+ chosen = len(Dset.intersection(target))\n+ if chosen not in patterns:\n+ patterns[chosen] = target\n+ for chosen, target in patterns.items():\n+ target_set = set(target)\n+ for source in triples:\n+ k = len(Dset.intersection(source))\n+ total_coefficient = Fraction(2*(3-k)-2*(d-k), 2*(3-d))\n+ scalar = Fraction(len((target_set-Dset).intersection(source)), 2)\n+ scalar -= Fraction(len((target_set & Dset)-set(source)), 2)\n+ scalar += Fraction(chosen-1, 2)*total_coefficient\n+ assert scalar == Fraction(len(target_set.intersection(source))-1, 2)\n+ for j, t in enumerate(triples):\n+ masks = [point_masks[a] for a in t]\n+ two = (masks[0]&masks[1]&~masks[2]) | (masks[0]&masks[2]&~masks[1]) | (masks[1]&masks[2]&~masks[0])\n+ actual = 0\n+ for a, b in combinations(t, 2):\n+ excluded = next(i for i in t if i not in (a, b))\n+ actual |= support[pair_outputs[a, b, excluded]]\n+ assert actual == two\n+ assert masks[0]&masks[1]&masks[2] == 1 << j\n+ assert [((k-1)+(k == 0)-(k == 2)) for k in range(4)] == [0, 0, 0, 2]\n+\n+ def contained(x, y):\n+ tx, ty = types[x], types[y]\n+ if tx == 1 and ty == 1: return not(core[y]&~core[x] or cover[x]&~cover[y])\n+ if tx in (1, 2) and ty == 2: return not cover[x]&~cover[y]\n+ return False\n+ active = [0]*n; stack = list(roots)\n+ while stack:\n+ x = stack.pop()\n+ if not x or active[x]: continue\n+ active[x] = 1\n+ if args[x][0]: stack.extend(args[x])\n+ degree = [0]*n\n+ for x in range(1, n):\n+ if active[x]:\n+ if types[x] == 1:\n+ assert core[x].bit_count() >= 2 and ranks[x] == support[x].bit_count()\n+ else:\n+ assert types[x] == 2 and ranks[x] == cover[x].bit_count()\n+ if active[x] and args[x][0]:\n+ for y in args[x]:\n+ assert y < x and contained(y, x), 'Binary frame nesting failed'\n+ degree[y] += 1\n+ for x in roots: degree[x] += 1\n+ H = [0]*(h+1); c = 0; loss = 0\n+ for x in range(1, n):\n+ if not active[x]: continue\n+ r = ranks[x]\n+ if args[x][0]:\n+ c += 1; H[r] += degree[x]-1; H[h-r] += 1\n+ for y in args[x]:\n+ assert r >= ranks[y]\n+ H[r-ranks[y]] += 1\n+ else: H[1] += degree[x]\n+ for x, k in zip(roots, kind):\n+ r = ranks[x]\n+ if k: H[r] += 1; H[h] += 1; loss += r\n+ else: H[h-1-r] += 1; H[1] += 1\n+ q = len(roots); R = c+q\n+ result = dict(h=h, v=v, c=c, q=q, R=R, loss=loss, central_disjoint=d, histogram=H,\n+ rank_sum=sum(r*m for r, m in enumerate(H)))\n+ assert loss == h*(h-1) and result['rank_sum'] == h*R+2*loss\n+ result['center_denominator'] = 21\n+ result['scalar_validation'] = dict(ordinary_supports_exact=True, centers_exact=True,\n+ center_decoder='sum A_i / 21', scatter_coefficients=list(map(str, scatter_coefficients)),\n+ rational_scalar_identity_exact=True, mixed_center_scatter_exact=True, binary_frames_nested=True,\n+ binary_frames_nondegenerate=True)\n+ with open(str(prefix)+'.bin', 'wb') as f:\n+ f.write(struct.pack('<4I', h, v, n, q))\n+ write_array(f, array.array('I', (a for pair in args for a in pair)))\n+ write_array(f, array.array('Q', core)); write_array(f, array.array('Q', cover))\n+ write_array(f, array.array('I', roots)); write_array(f, array.array('I', kind))\n+ write_array(f, array.array('B', active))\n+ with open(str(prefix)+'.labels', 'wb') as f:\n+ write_array(f, array.array('I', ranks)); write_array(f, array.array('B', types))\n+ Path(str(prefix)+'.json').write_text(json.dumps(result, indent=2)+'\\n')\n+ return result" + }, + { + "sha": "b2169aefe31d0805cce4635260498bcc8c6e7492", + "filename": "scripts/deferred_product_bit_checks.py", + "status": "added", + "additions": 40, + "deletions": 0, + "changes": 40, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_bit_checks.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_bit_checks.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product_bit_checks.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,40 @@\n+#!/usr/bin/env python3\n+\"\"\"Run PR #97's round-seven bit checks on a temporary copy of research/deferred-signed.\n+\n+Runs, unchanged: the literal frame ledger (both shears, reflected continuity, event histogram),\n+Swapnil Jain's check_word.py (F2 and Z replay with arbitrary scratch) and check_frames.py\n+(exact frames, sigma/V-leaf nesting in time order, histogram). The ledger rewrites its receipt\n+with an elapsed time, so it runs on a copy and every other field is compared with the committed receipt.\n+\"\"\"\n+import json\n+from pathlib import Path\n+import shutil\n+import subprocess\n+import sys\n+import tempfile\n+\n+ROOT = Path(__file__).resolve().parents[1]\n+SOURCE = ROOT / 'research/deferred-signed'\n+\n+\n+def main():\n+ assert not sys.flags.optimize, 'Run without -O'\n+ with tempfile.TemporaryDirectory(prefix='deferred-product-bit-') as tmp:\n+ copy = Path(tmp) / 'deferred-signed'\n+ shutil.copytree(SOURCE, copy, ignore=shutil.ignore_patterns('__pycache__'))\n+ subprocess.run([sys.executable, str(copy / 'round7_literal_frame_ledger.py')], check=True,\n+ stdout=subprocess.DEVNULL)\n+ new = json.loads((copy / 'round7-literal-ledger/result.json').read_text())\n+ old = json.loads((SOURCE / 'round7-literal-ledger/result.json').read_text())\n+ drop = ('elapsed',)\n+ assert {k: v for k, v in new.items() if k not in drop} == {k: v for k, v in old.items() if k not in drop}, \\\n+ 'literal ledger receipt changed'\n+ checks = copy / 'swapnil-round7/independent/deferred-readout'\n+ for script in ('check_word.py', 'check_frames.py'):\n+ out = subprocess.run([sys.executable, script], cwd=checks, check=True, capture_output=True, text=True).stdout\n+ assert 'ALL PASS' in out, script\n+ print('PASS round-seven bit word: literal ledger, check_word, check_frames')\n+\n+\n+if __name__ == '__main__':\n+ main()" + }, + { + "sha": "83bf78351281c8cd4c3a95d5274e63a2e113b8c5", + "filename": "scripts/deferred_product_complex.py", + "status": "added", + "additions": 49, + "deletions": 0, + "changes": 49, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_complex.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_complex.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product_complex.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,49 @@\n+#!/usr/bin/env python3\n+\"\"\"Replay the selected h24 all-disjoint rational-center complex producer from its shipped addition DAG.\n+\n+Every support, core, cover, label type and rank is recomputed from the operand pairs\n+(scripts/deferred_product/replayed.py); the unchanged PR #104 matcher\n+(scripts/endpoint_gauge/match_complex_general.cpp) then rebuilds the role count and the\n+physical histogram, which must equal certificates/deferred-product-complex-input.json.\n+Same flow as scripts/stopped_product_producer.py (icekylinx), with the replayed build.\n+\"\"\"\n+import json\n+import os\n+from pathlib import Path\n+import shlex\n+import subprocess\n+import sys\n+import tempfile\n+\n+ROOT = Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+from copied_centers.corners import require\n+from copied_centers.physical import copied_histogram\n+from endpoint_gauge_producer import compare\n+from deferred_product.replayed import build\n+\n+\n+def main():\n+ require(sys.flags.optimize == 0, 'Run without -O: mathematical assertions must remain enabled')\n+ expected = json.loads((ROOT / 'certificates/deferred-product-complex-input.json').read_text())\n+ require((expected['h'], expected['central_disjoint'], expected['center_denominator']) == (24, 24, 21),\n+ 'Wrong rational-center parameters')\n+ compiler = os.environ.get('CXX', 'c++')\n+ with tempfile.TemporaryDirectory(prefix='deferred-product-') as directory:\n+ work = Path(directory)\n+ prefix = work / 'complex_replayed_d24'\n+ construction = build(ROOT / 'certificates/deferred-product-complex-dag.json.gz', prefix)\n+ program = work / 'match_complex_general'\n+ subprocess.run([*shlex.split(compiler), '-O3', '-std=c++17',\n+ str(ROOT / 'scripts/endpoint_gauge/match_complex_general.cpp'), '-o', str(program)], check=True)\n+ matched = json.loads(subprocess.check_output(\n+ [str(program), str(prefix) + '.bin', str(prefix) + '.labels'], text=True))\n+ compare(matched, expected, 'complex h=24 replayed rational centers')\n+ require(construction['R'] == matched['baseline_R'], 'Wrong raw complex roles')\n+ copied_histogram(matched)\n+ print('PASS replayed complex producer: R=%d (baseline %d, matched %d), histogram equal' % (\n+ matched['R'], matched['baseline_R'], matched['matched']))\n+\n+\n+if __name__ == '__main__':\n+ main()" + }, + { + "sha": "1fe60872e94d6cbc16d45a8d8aa3dd856a614be5", + "filename": "scripts/deferred_product_complex_frames.py", + "status": "added", + "additions": 53, + "deletions": 0, + "changes": 53, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_complex_frames.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_complex_frames.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product_complex_frames.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,53 @@\n+#!/usr/bin/env python3\n+\"\"\"Word-level gate-frame replay of the selected complex producer (independent of the matcher's accounting).\n+\n+The shipped word (certificates/deferred-product-complex-word.json.gz) must encode exactly the shipped DAG\n+(same operand pairs, centre roots and piece roots). scripts/deferred_product/complex_frames.py then expands\n+the full signed two-stage copied-center word (early pass at 0, V at , mixer at labels, centre copies at 0,\n+pieces at t^perp, inverse mixer and -V at F; stage two reversed with complemented frames and exchanged\n+banks), checks nesting and nondegenerate whole residuals on every move, and rebuilds the paid histogram,\n+which must equal PR #104's profile of the shipped row. Alternating rank-2 residuals are allowed: PR #104\n+(notes/stopped-product-complex.tex) executes every nondegenerate binary residual, alternating forms\n+included, as one child by the retained Gauss normal form (notes/endpoint-gauge-complex.tex).\n+\"\"\"\n+import gzip, json, sys\n+from collections import Counter\n+from pathlib import Path\n+\n+ROOT = Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+sys.argv = [sys.argv[0], '--allow-alternating'] # read by the frame module at import\n+from deferred_product import complex_frames as cf\n+import stopped_product_network as spn\n+\n+\n+def main():\n+ assert not sys.flags.optimize, 'Run without -O'\n+ word = json.loads(gzip.decompress((ROOT / 'certificates/deferred-product-complex-word.json.gz').read_bytes()))\n+ dag = json.loads(gzip.decompress((ROOT / 'certificates/deferred-product-complex-dag.json.gz').read_bytes()))\n+ v = dag['v']\n+ assert (word['h'], word['v']) == (dag['h'], v) == (24, 2024)\n+ flat = dag['args']\n+ assert len(word['args']) == v + 1 + len(flat) // 2\n+ for k in range(len(flat) // 2):\n+ assert list(word['args'][v + 1 + k]) == [flat[2 * k], flat[2 * k + 1]], 'word and DAG differ'\n+ assert sorted(n for _, n, _ in word['retained']) == sorted(dag['A']), 'centre roots differ'\n+ assert sorted(n for _, n, _ in word['pieces']) == sorted(dag['D'] + dag['P']), 'piece roots differ'\n+ w = cf.Word(word)\n+ events, initial, final, bad, ok_final = cf.forward(w)\n+ breaks, end = cf.reflect(w, events, initial, final)\n+ paid, cls = cf.paid_histogram(w, events)\n+ row = json.loads((ROOT / 'certificates/deferred-product-complex-input.json').read_text())\n+ expected = spn.profile(row)['child_multiplicities']\n+ h = w.h\n+ assert not bad, bad[:3]\n+ assert ok_final and breaks == 0 and end, 'stage-one endpoints or stage-two reflection'\n+ assert cls['aux'] == w.R * h and cls['data'] == 2 * v * (h - 1) and cls['center'] == len(w.rout) * (h - 1)\n+ assert dict(paid) == {int(t): n for t, n in expected.items()}, 'paid histogram differs from the row profile'\n+ print('PASS complex word: %d moves, 0 violations, reflection continuous, histogram == row profile; '\n+ 'alternating rank-2 residuals %d (one-child Gauss normal form)' % (\n+ sum(1 for e in events if e[0] == 'move'), cf.ALTERNATING.get(2, 0)))\n+\n+\n+if __name__ == '__main__':\n+ main()" + }, + { + "sha": "b757c19fe0df669b15fd7b1c62d84dd3dfecaa72", + "filename": "scripts/deferred_product_network.py", + "status": "added", + "additions": 167, + "deletions": 0, + "changes": 167, + "blob_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_network.py", + "raw_url": "https://github.com/CrocSwap/integer-mult-bounds/raw/cbb05ce504d571546d9b7794c186a613c659c3bf/scripts%2Fdeferred_product_network.py", + "contents_url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/scripts%2Fdeferred_product_network.py?ref=cbb05ce504d571546d9b7794c186a613c659c3bf", + "patch": "@@ -0,0 +1,167 @@\n+#!/usr/bin/env python3\n+\"\"\"Deferred bit word (#97, Swapnil Jain round 7) under PR #104's one-child stopped-product rule, with the\n+complex row of the selected h24 producer; exact moments, stopped saving, bridge and assembly.\n+\n+Every bit residual of the frozen round-seven schedule (gauged and plain exteriors, slot chain steps, centre\n+copies, y_T and X_S chain steps, data connectors, copy corrections) is a nested projector residual and becomes\n+ONE child of its rank (notes/stopped-product-factorization.tex; research/deferred-product/PROOF.md). The\n+complex row uses the unchanged #104 profile. Constants and enclosures are those of stopped_product_network.py.\n+\"\"\"\n+import sys, json\n+from collections import Counter\n+from fractions import Fraction as Q\n+from hashlib import sha256\n+from math import comb\n+from pathlib import Path\n+\n+ROOT = Path(__file__).resolve().parents[1]\n+sys.path.insert(0, str(ROOT / 'scripts'))\n+DR = ROOT / 'research/deferred-signed/swapnil-round7/independent/deferred-readout'\n+sys.path[:0] = [str(DR), str(DR.parent / 'two-stage-bit'), str(DR.parents[1] / 'scripts')]\n+import stopped_product_network as spn\n+import deferred as dr\n+from certify import require\n+from copied_centers_network import finite_bridge as copied_bridge\n+from partial_swap_network import moment\n+from structured_bulk_assembly import assembly, js\n+\n+GRID = 10**10\n+ATOM, OLD, PHASE_STOP = spn.ATOM, spn.OLD, spn.PHASE_STOP\n+\n+\n+def bit_profile():\n+ \"\"\"One-child list of the round-seven deferred word (both stages, all invocations).\"\"\"\n+ h = 23\n+ W, D = dr.load(h)\n+ S = dr.Schedule(W, D)\n+ v, R, m = S.v, S.R, h * h\n+ rk = dr.chain_ranks(S) # recorded exact dims, checked by check_frames.py (part X)\n+ yl = S.ylevels(S.adjoint()) # Z supports, as in the pinned round-seven histogram\n+ xd = S.xdata()\n+ z = Counter()\n+ for _ in range(2): # stage two: complement time-reversal, same residual multiset\n+ for s in range(R):\n+ z[m - (h - S.f[s])] += v # exterior of rank m - r_u (plain slots: r_u = h)\n+ for r, c in rk.items():\n+ z[r] += v * c # slot chain steps\n+ z[h - 1] += v * h # centre copies U_c -> 0\n+ for t in range(v):\n+ ds = sorted(set([0] + yl[t] + [h - 1]))\n+ for a, b in zip(ds, ds[1:]):\n+ z[b - a] += v # y_T chain steps\n+ for xs in xd:\n+ for x in xs:\n+ z[x] += v # X_S chain steps\n+ N = v * v\n+ z[(h - 1) ** 2] += 2 * N # data connectors (I-P)(x)(I-Q)\n+ z[1] += N # copy corrections\n+ Wb, L = 2 * N + 2 * v * R, 2 * v * h * (h - 1)\n+ s = Wb * m - N + L\n+ require(sum(t * n for t, n in z.items()) == s, 'Complete rank mass')\n+ require(all(0 < t < m and n > 0 for t, n in z.items()), 'Shrinking children')\n+ z = dict(sorted(z.items()))\n+ return dict(dimensions=[h, h], m=m, N=N, B1=v * R, B2=v * R, W=Wb, L=L, total_rank=s, deficit=N - L,\n+ maxchild=max(z), child_multiplicities=z, roles=R)\n+\n+\n+def coarse_ok(p, saving):\n+ spn.COARSE = saving\n+ spn.AB = (1 - ATOM) * saving + ATOM * OLD\n+ try:\n+ return spn.coarse_moment(p)\n+ except Exception as error:\n+ if 'moments' in str(error) or 'enclosure' in str(error):\n+ return None\n+ raise\n+\n+\n+def largest(predicate, hi):\n+ lo = 0\n+ while hi - lo > 1:\n+ mid = (lo + hi) // 2\n+ if predicate(mid):\n+ lo = mid\n+ else:\n+ hi = mid\n+ return lo\n+\n+\n+def contracts(phase, a):\n+ try:\n+ moment(phase['m'], phase['W'], phase['child_multiplicities'], a, True)\n+ return True\n+ except ValueError as error:\n+ if 'does not contract' in str(error):\n+ return False\n+ raise\n+\n+\n+def bridge_for(bit, phase, row, previous):\n+ bridge = copied_bridge(bit, phase, [row, row])\n+ old_bit = previous['finite_bridge']['bit']\n+ old_degree = old_bit['halving_degree'] * old_bit['wire_bits']\n+ require(old_degree == 252, 'Inherited ordinary leaf row stock')\n+ coarse = bridge.pop('bit')\n+ c = bridge['complex']\n+ coefficient = coarse['halving_degree'] * coarse['wire_bits'] + old_degree + c['halving_degree'] * c['wire_bits']\n+ degree = 1000 * ((coefficient * 51) // 25000 + 1) # smallest sufficient multiple of 1000\n+ require(Q(degree) > Q(51 * coefficient, 25), 'Product stock strictly sufficient')\n+ bridge.update(bit_coarse=coarse, ordinary_leaf_row_degree=old_degree)\n+ bridge['rows'] = dict(coefficient=coefficient, degree=degree, suffix_slope=4 * degree,\n+ degree_gap=Q(degree) - Q(51 * coefficient, 25),\n+ contract='W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse')\n+ require(row['h'] == row['central_disjoint'] == 24 and row['h'] - 3 == 21, 'Selected all-disjoint centers')\n+ bridge['semantic'].update(fixed_odd_divisor=21,\n+ exact_grid='One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding')\n+ return bridge\n+\n+\n+def certificate(complex_row_path):\n+ require(not sys.flags.optimize, 'Run without -O')\n+ read = lambda name: json.loads((ROOT / 'certificates' / name).read_text())\n+ previous = read('copied-centers-network.json')\n+ require(Q(previous['bit']['saving']) == OLD, 'Certified ordinary leaf saving')\n+ bit = bit_profile()\n+ complex_row = json.loads(Path(complex_row_path).read_text())\n+ phase = spn.profile(complex_row)\n+ c = largest(lambda k: coarse_ok(bit, Q(k, GRID)) is not None, GRID // 1000)\n+ COARSE = Q(c, GRID)\n+ bm = coarse_ok(bit, COARSE)\n+ require(bm is not None and coarse_ok(bit, Q(c + 1, GRID)) is None, 'Largest coarse grid saving')\n+ AB = (1 - ATOM) * COARSE + ATOM * OLD\n+ a = largest(lambda k: contracts(phase, Q(k, GRID)), GRID // 1000)\n+ AC = Q(a, GRID)\n+ cm = moment(phase['m'], phase['W'], phase['child_multiplicities'], AC, True)\n+ require(not contracts(phase, Q(a + 1, GRID)), 'Next complex grid point must fail')\n+ assembly_bit = min(AB, (1 - PHASE_STOP) * AC - Q(1, GRID))\n+ bridge = bridge_for(bit, phase, complex_row, previous)\n+ eta = Q(1, 10**8)\n+ q = assembly_bit * (1 - 2 * eta)\n+ eps = (1 - eta) / (1 + q * (1 + eta) + q)\n+ k = (eps * q * GRID).__floor__()\n+ if Q(k, GRID) >= eps * q:\n+ k -= 1\n+ KAPPA = Q(k, GRID)\n+ assembled = assembly(assembly_bit, AC, bridge, KAPPA, beta=PHASE_STOP)\n+ require(len(assembled['strict_constraints']) == 47 and len(assembled['margins']) == 7, 'Complete assembly')\n+ rejection = None\n+ try:\n+ assembly(assembly_bit, AC, bridge, KAPPA + Q(1, GRID), beta=PHASE_STOP)\n+ except Exception as error: # the inherited assembly rejects by assertion\n+ rejection = str(error)\n+ require(rejection is not None, 'Next kappa grid point must fail')\n+ assembled['parameters']['actual_bit_saving'] = AB\n+ return dict(status='Conditional stopped product-ring multiplication witness: deferred bit word, selected complex row',\n+ kappa=KAPPA, next_kappa_rejection=rejection, coarse_bit_saving=COARSE, ordinary_bit_saving=AB,\n+ a_complex=AC, assembly_bit=assembly_bit, binding='bit' if assembly_bit == AB else 'complex',\n+ bit=dict(counts=bit, **bm), complex=dict(counts=phase, **cm), finite_bridge=bridge, assembly=assembled,\n+ complex_row_sha256=sha256(Path(complex_row_path).read_bytes()).hexdigest())\n+\n+\n+if __name__ == '__main__':\n+ out = certificate(sys.argv[1])\n+ Path(sys.argv[2]).write_text(json.dumps(js(out), indent=2, sort_keys=True) + '\\n')\n+ print('PASS kappa=%s = %.7e; coarse bit %s (%.7e), ordinary bit %.7e, complex %s (%.7e), binding %s, maxchild %d, row degree %d'\n+ % (out['kappa'], float(out['kappa']), out['coarse_bit_saving'], float(out['coarse_bit_saving']),\n+ float(out['ordinary_bit_saving']), out['a_complex'], float(out['a_complex']), out['binding'],\n+ out['bit']['counts']['maxchild'], out['finite_bridge']['rows']['degree']))" + } + ] +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/DOWNLOAD_AUDIT.json b/research/completed-core-sharing/inputs/research/pr117-public/DOWNLOAD_AUDIT.json new file mode 100644 index 0000000000..e7a43bd218 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/DOWNLOAD_AUDIT.json @@ -0,0 +1,1036 @@ +{ + "commit": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "parent": "854ba7dca98651eab2050402384e1a7784534f0a", + "status": "All changed files copied/downloaded and Git blob hashes verified; no downloaded code executed", + "files": [ + { + "path": ".github/workflows/verify.yml", + "git_blob_sha": "0b6f8dd385305864d4d94edd1b1c64998419353b", + "sha256": "1933f3e13d7f54ba1c51cc598262b587a110cce85435dcf3d91892d8df03e665", + "size": 2282, + "origin": "network" + }, + { + "path": "Makefile", + "git_blob_sha": "9f2cc673123983169f2848d5057ae07462aa09c8", + "sha256": "a89772184646c7b05ab0dd4c8b128defbfd6e15aea46ac8b0655c1f313001109", + "size": 18056, + "origin": "network" + }, + { + "path": "NOTICE", + "git_blob_sha": "f7343a16289ee2691e7dbc592e4c27179eba84ea", + "sha256": "a0030510cd3b5334fb113eae759aadd2c25951bd353dfb69ad9cb780ae5adf30", + "size": 19832, + "origin": "network" + }, + { + "path": "README.md", + "git_blob_sha": "f2e3b79ca2f083db30e382933625f1b2c2737267", + "sha256": "e64fba8077840a0341890e7f740f9aa7699df8fc1e56804f6a11aaeb8baa53a6", + "size": 12607, + "origin": "network" + }, + { + "path": "certificates/deferred-product-complex-dag.json.gz", + "git_blob_sha": "a5b0598e4c328acef11baaa32852acdbfc97eeef", + "sha256": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "size": 362071, + "origin": "network" + }, + { + "path": "certificates/deferred-product-complex-input.json", + "git_blob_sha": "92f157e9584017d1af452638abef22e16e206295", + "sha256": "21f957e6d840e027ffdd1d7d3f95fd7d364c2cdef338c4ca79d25194e24179ca", + "size": 935, + "origin": "network" + }, + { + "path": "certificates/deferred-product-complex-word.json.gz", + "git_blob_sha": "6426bc17a99c5c2ee75b984fdc8011a64563bae9", + "sha256": "c683e371b647a15944eed570c6cb8f9cb686c9ed24d616bb9c6c00d29803f718", + "size": 1688240, + "origin": "network" + }, + { + "path": "certificates/deferred-product-network.json", + "git_blob_sha": "fcd087c9fac3f92b676496b4d8367d3f0b95a9c6", + "sha256": "3fa91f03cc70bb76d67e2eb75b15dc07c3986fd396845bf14707f91ce3e9f903", + "size": 19189, + "origin": "network" + }, + { + "path": "certificates/joint-dual-kappa.json", + "git_blob_sha": "2b6e7723481daa8a6e28f9e6dc03f688a1fc69a5", + "sha256": "0c7222cd8184d9f2cf8ac39c72c14acae3b099d25939cecdb2208c2f57811ded", + "size": 37861, + "origin": "network" + }, + { + "path": "certificates/joint-dual-validation.json", + "git_blob_sha": "c72af03fbe41eff594b7add611ee228fc8e3a91a", + "sha256": "d9f1b2b262c25abeff5e81b90273a8ba0cd0bcade5b9a672f0070c471036fc79", + "size": 5825, + "origin": "network" + }, + { + "path": "research/deferred-product/PROOF.md", + "git_blob_sha": "a9d3b9856ab18cfdc73d536bb93f97c28c8ec26f", + "sha256": "e4bdd57667e11d808515c74e8975fb807130cb9192aea97a090f9abdd26c77e8", + "size": 5160, + "origin": "network" + }, + { + "path": "research/deferred-product/README.md", + "git_blob_sha": "5bb63d08557484e442e059c2b0832aeffe407e60", + "sha256": "24209712c711a6283ae9975b7e20368d5dc6257bb0359b0c53d0f243171ea845", + "size": 1889, + "origin": "network" + }, + { + "path": "research/deferred-signed/PROOF.md", + "git_blob_sha": "d96717353e80003b5c43c45e966c3afb87c17387", + "sha256": "cf5cced8cecace5f4308647523bc86a0869daeb1aa49c382bec03411674a1741", + "size": 13881, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/README.md", + "git_blob_sha": "58791689052f575743783a830ce7a2638968bd91", + "sha256": "b1d761d02a5bb3413f705c9fac321a96e9b42f4bfd949c175131af97316b7463", + "size": 3076, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/SOURCE.json", + "git_blob_sha": "3521d3c5cdba3a93b29cd7e9b2603caa37f4b705", + "sha256": "eca8ccc565dc6145b8da703a752f7dd54873993bb5bc7ec0c23bd6649a2ac1d0", + "size": 19758, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/VALIDATION.json", + "git_blob_sha": "a221c78912e406d2535f5a9ceee58f94999c7eb8", + "sha256": "c267be2b45769619b1fcb078b5aaa40f24ce1f0345161d180f138d297cd19264", + "size": 18672, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/check_complex_identity.py", + "git_blob_sha": "833fbded74951c775043573f19f5288e8f7c2de3", + "sha256": "8a31abe1d46ab3aa76b954cb87004e28d4974cce5eea2dea17d6283992902e7d", + "size": 1564, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round6-complex-interface-controls.json", + "git_blob_sha": "bda184640fd3c74440262da306ba9b91bdf5c57c", + "sha256": "7f4375ff2baefd6455d5353968d4c1a38666cda7f417ebd21286f09e16131d22", + "size": 935, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round6-complex-literal-ledger/result.json", + "git_blob_sha": "b52fceb9147dad059cf8db5888b2a98035f8e33c", + "sha256": "db1d41515236c2710b4caeb22d91eea63cf1deeb0d659346d0661da71ed07baa", + "size": 1938, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round6_complex_interface_controls.py", + "git_blob_sha": "7a84af93ed875da010ad7c8dc89c0e78d9e0873c", + "sha256": "7ca3e245c7bdd814d6315f2b32ef5e0d4610834dd9e3190cc551a182c87bf5ed", + "size": 5278, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round6_complex_literal_ledger.py", + "git_blob_sha": "9f1b5b3e3a4daa1f42ae29af073fc07661880095", + "sha256": "a1384fb5283d9d11775942b91e31887fa05ddcd50c6a50fa3f11902b32f73c36", + "size": 7175, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7-balanced-assembly-candidate.json", + "git_blob_sha": "b34f25ad511f42a43038a2917223a5b2edab19b9", + "sha256": "bcf0623dc4eab9fdb858f4375a5a183b72b150853e8da030005d8fcd0b83f2ae", + "size": 6439, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7-literal-ledger/result.json", + "git_blob_sha": "b6449a74d8689a0ed294b14713e0e78ce577e24f", + "sha256": "65343d92f68d0d7756bb4c5adbdcb43171b00ce7fa7398e951245cf2ab119c0f", + "size": 4223, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7-tensor-endpoint-controls.json", + "git_blob_sha": "a121d26ca3d51d231b73cc7bde67a277ff29cc22", + "sha256": "8383f9afa241ad495941b3d724286f0d94e4c4adee71d8ea744d88d813acec4c", + "size": 1577, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7_balanced_assembly_candidate.py", + "git_blob_sha": "f0230cc0a436be82cb66b80624677b6b5be211eb", + "sha256": "0e3b13922295c0ece6e6354d7ba93529b3c51e70ece15a20d089f65f134e33b7", + "size": 3149, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7_literal_frame_ledger.py", + "git_blob_sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "sha256": "02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59", + "size": 8657, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/round7_tensor_endpoint_controls.py", + "git_blob_sha": "2db779468c4f67a72b2ecf2d715fd6bea81ef946", + "sha256": "f1487b01167ef37cd180a0d969c815bcf26e627f3c264b89ccd974b63478ae91", + "size": 2265, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/.gitignore", + "git_blob_sha": "fcaeafddb14b5916950724f02f3be328f0c36ddf", + "sha256": "e4142bca62926744f1a60693914db92bb41be0b9ea4fbd4dd73e3af2178b0c8b", + "size": 23, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/IMPORT.json", + "git_blob_sha": "0167c6fda13daee13d1bbf9b885e13bb09d90aaa", + "sha256": "4b5f15981e846084b6def674ce0903c2d4ef0c930ea0c40093a2a8584164102d", + "size": 11154, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/LICENSE", + "git_blob_sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "size": 11357, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/Makefile", + "git_blob_sha": "fdff0234e8d7adbc975c8487e7fb6a17820518df", + "sha256": "42714be051b771e6ea414d3f7da4b9beb93990d5d6e1521dc665b3b2718a888a", + "size": 2026, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/NOTICE", + "git_blob_sha": "be2e7e5a9838fe7e284aff3babc864455c2281d2", + "sha256": "058a663112e633ab5349ce33b6119bacca2b9fd6c0a89918c4c0435d6dd7a008", + "size": 2543, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/README.md", + "git_blob_sha": "09708066640450a0aea89976579b5aba82098ac1", + "sha256": "07409d6f8ca1becb0cf1f7bf7f485b879bfb53663c93becefc8f4e44de6f50b9", + "size": 17023, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/complex-source-frames.pdf", + "git_blob_sha": "68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0", + "sha256": "f102b238e86a650190e2c94232fbafd3f50d30693151019a7d7b5b4addf620fd", + "size": 53103, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/copied-centres.pdf", + "git_blob_sha": "c290bc5431382e6af840895e6892fba1dc165c7a", + "sha256": "bbd2333d9049b8f42565e2b24d6faa5c69fcc4e67b873a7bef1f6e607e4979f4", + "size": 43970, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/data-edge-batching.pdf", + "git_blob_sha": "cb94268721cc71fe42eb54c76b43fff566492d37", + "sha256": "9f712eb870cfad37af333acefce5162754f85087afc9647e2d86b30a70ba5c03", + "size": 39141, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/deferred-readout.pdf", + "git_blob_sha": "7aa9fb30817c371cc2b9a717965925168bf18e96", + "sha256": "ca659ffa1dccdb05ebbcb95c8ca6342704bcc98656a57be9a05aa71faafe0bdb", + "size": 66148, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/fine-field-lemma.pdf", + "git_blob_sha": "ff5bd622016110694ff79aa283e25b52953d8832", + "sha256": "648168584f12381f1756156aea22a3fff108b94de36c62652b75558b81c0a118", + "size": 95968, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/flag-basis.pdf", + "git_blob_sha": "39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5", + "sha256": "35cbcff404998f4e66c026e98c72f895bd8f8f2b90ba8d60b390af1d150b2cf7", + "size": 54385, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/partial-swap-batching.pdf", + "git_blob_sha": "a03f30c451a2baf59a69f8d5b30d12687f9ffdfc", + "sha256": "2a76b1ce513c08d408a7524d825e922cc7a3939a772237d3a08f9683f2235289", + "size": 60416, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/round3-combination.pdf", + "git_blob_sha": "0706f9d115468ca9314c47503b190346be67a0c9", + "sha256": "cc56ddcff426818b0fb096a47f837fceb98b928d31c428f6dccaca53aff4b3c7", + "size": 45026, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/segmented-inverse.pdf", + "git_blob_sha": "65a2e177778547c4029570aee05237d1e69dcf3d", + "sha256": "cb33411a0b9b552ec881b884498567997c10f9cb9d63cb7d5a864277ccebdfb0", + "size": 104153, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/stack-notes.pdf", + "git_blob_sha": "827f07e6b5be63d903f8f5becc1a57cf99355db0", + "sha256": "3c1181d1e3b6a55d8092d39e37c7b0ef712d8ace0b76dc8f493578bef6006eae", + "size": 94315, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/external/pr24-bit-network.json", + "git_blob_sha": "4e212f628196ee434aa67b09a1cedcd8d4d72e85", + "sha256": "f9ddc6c33dda1abdaf05d0fff651d02e9a04557ebbb1b8da11d4d6de8de08d91", + "size": 1634, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/identities.json", + "git_blob_sha": "a87f969d341e04fa60fd48eff7cbd639bda955b1", + "sha256": "76b35a0fdb1bf1926325bf33648dbae3e0de34699ce6dd1e95a23a09f762cd44", + "size": 982, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/round7/deferred_23.json.gz", + "git_blob_sha": "4a4431bd425aa4499f25e67df4e0d2cddd7df15c", + "sha256": "8c38e947ff9e021e308000dd82bb5e2194eb265d8b75194e22ce783d3e75317c", + "size": 1524681, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/round7/witness_23.json.gz", + "git_blob_sha": "3d86f83b871ba07c3b1562aa6d953ae86b9750ba", + "sha256": "b2486aa2bb222bacea6e52162a3920780e45dd8edc5d7cb03eabea336a1c6588", + "size": 771258, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/witness.json", + "git_blob_sha": "94339ac381b3a3eea3f5edfb0638bbd06d617282", + "sha256": "ffb5ac42a64969dae7d19012e5102d7aeb66c3eee529bde9812bd182cb9eafa1", + "size": 1307, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/README.md", + "git_blob_sha": "95a5da44ed26c34d3cb8dec581894a873ab5ade3", + "sha256": "b1e790d7a268716b62d19f1e6617b9f55f81bbfbd0c474a3a0801918b5ba6a7b", + "size": 1374, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/bc.py", + "git_blob_sha": "53e00de297d6f693c19c88425292647f594dac63", + "sha256": "056ca643666dff4405eecfb6f0f8a33da3a50244c65d9bc2e28fa95ea32956e1", + "size": 778, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_cert.py", + "git_blob_sha": "103bbb7d271c2bfd05206a35aabd14986eaf9c0e", + "sha256": "c4b0d8b9cdb7dceb881747826356fb6eedd5ad465c483ed7cda0ba2a8d2d90d4", + "size": 1754, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_hist.py", + "git_blob_sha": "5b04ed68ec9fb3c66bdd96025d14ed3dcb2a1458", + "sha256": "dbfa0844ff605abfe386f30f3bf9859c3f1b040eae019e184668c82439d788d1", + "size": 3955, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/labels.py", + "git_blob_sha": "ec70ed13a59851c16202665dd34f667fde54708d", + "sha256": "4edb0206c6f44081c1be434a529fce3527a46a35fee3e874a97898d60eabbe20", + "size": 3259, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/roles.py", + "git_blob_sha": "d0d0594e2dee738f64401face0007501c9ccb4b9", + "sha256": "499e4f7ea700a917e7c3991b91ac99e1b0eb7eb51fb6d362b395d0056b64bdee", + "size": 1070, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/side.py", + "git_blob_sha": "2a625732bb10238aeb2d0f256dabd794b276262b", + "sha256": "90703356b485a21bbcf2f4dca9c1cc7109767a16afd2a04ac113b2c6e1d569ce", + "size": 8238, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_labels.py", + "git_blob_sha": "ae6a68014ad822a09a729fc06f89a2375730a65e", + "sha256": "f1a2ff1e6aa68e3052d77d664744d85ac76c31f7b779bd66be018ee82ea0aec7", + "size": 4296, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_sim.py", + "git_blob_sha": "ca684ec9badd9f4305d584f4786f6042d35b87e3", + "sha256": "ef9c47f92ef46aa7f701493aab95d65f930d4d31db214bc83b683cf7ddb7868b", + "size": 8353, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_trace.py", + "git_blob_sha": "965b9101c68167a245b17bbdf49f884b2f62d5db", + "sha256": "688e609cc0adbfba17dd74984d382121ce6741afc7e2da548ee553ea15c4d3c9", + "size": 7269, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/cert.py", + "git_blob_sha": "bb6879adcd3b2a0c78afba69ea05ed154e4b786b", + "sha256": "f9352729213b8441d076708b738d158093caa34d050fa2d838b61e07eb3a298b", + "size": 1983, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/frames.py", + "git_blob_sha": "45126062136d58f2d4fedcf549f40cd95d456c7f", + "sha256": "8629850bd465250cdf298b47b86504f2ac507d5fa044f8c0d2a20b451d19aa0f", + "size": 4206, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/hist.py", + "git_blob_sha": "30fc761818781e881962cbab3efcb0547e1173a1", + "sha256": "e20d077acfc95e2f8239fcdcc03146cc15607996e2734eb2d00b68ed7d43ec64", + "size": 6689, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/producer.py", + "git_blob_sha": "10d2110f9bf25a857f5b7fef76bb95fa367d3eac", + "sha256": "e1715616ac8cafa8f63b7c0a2e7deacdba7daea94662e0a84626d5374fd27b5c", + "size": 12485, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/run.py", + "git_blob_sha": "fe438f91656df7dc6b236d7b2000261282776228", + "sha256": "fff6190b4f197689aad55077be882e8c95e0b699d366eadee5882cf8ff08be44", + "size": 1365, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_frames.py", + "git_blob_sha": "f22b6998f9415dd0b081a146f00e5c30065d6689", + "sha256": "1cb2b8cde2a8b3f12008da0d335dcdd38005cc692367423d9589aa1f4d6306e8", + "size": 15297, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_lifted.py", + "git_blob_sha": "4a19240e2fe5f55891d842fd451bd0cb24e4ae76", + "sha256": "c3e87ad6b31f377df549421f53d22b99131d2228dcd08a1956913211383cbd6c", + "size": 36417, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_stair.py", + "git_blob_sha": "d3d1dea1a9a42601410fb5cd3edc5888d63d217b", + "sha256": "5b684020b394869d1b899dfffbdf1518de6b3b3562c0f5a2a81a2f43ced42d40", + "size": 10844, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_word.py", + "git_blob_sha": "7db40994e4d74afe191c3fd8ac5c9acc9b438eeb", + "sha256": "c31a321e28556c9d9cb3397e48292e8ecefc0b08e233243d7849bd585213af65", + "size": 11772, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/deferred.py", + "git_blob_sha": "b77bb4861c38b731e5b41a17af8fc1b63b56ec42", + "sha256": "e92ac1db9fce8608cf5302336f05750fa327eda99f7170ed32e7323220ffc164", + "size": 9289, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/linalg.py", + "git_blob_sha": "a81cbaa61e2c09075f900546ec46833103b77ac1", + "sha256": "56cc779911a3c5c901bc5194ccaf97f720157a2c4ba602b07ee8642af2676b8b", + "size": 6412, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/README.md", + "git_blob_sha": "536b9b40604d1391582b5e86ccc6aac64dc236d7", + "sha256": "8f9bb3c2e7037e5c601b740e195cc5207bf3eec906fdea9c6f4ee73a7ca98da0", + "size": 439, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/factor.py", + "git_blob_sha": "9908b695e021f9069123e2bf15095caf1ccae337", + "sha256": "a246d8d4b4d110125406648f9fb49725894c3652102049caf3555ab191fc0e7b", + "size": 3120, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/frames.py", + "git_blob_sha": "31c8130c5946574fd6996a56dac246ee688bffb1", + "sha256": "6931781fc7097daf44327de262ef9df68d95f3ebab3b2a6c22422066c1e7ea1a", + "size": 9402, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/moment.py", + "git_blob_sha": "1d0c379fb8490f6f51717888da5904c9c1168e44", + "sha256": "a1c5fa749b41d483dafb66d7ba56d2e77a8735befbbcac8391b8e1d8ce1ee2d3", + "size": 2205, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/test_factor.py", + "git_blob_sha": "aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0", + "sha256": "0c1da25c545e1e7cdd6eca5140579a6b6273789de39171487624c7ff6490dec6", + "size": 5524, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/README.md", + "git_blob_sha": "390bb577fd4ec1fa774ded95887ce5855adc17e7", + "sha256": "ef301c65851d91dc7ea0e920b33de4d36ee1249f768a504c8e5b3a29dd4abf7c", + "size": 893, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/complexside.py", + "git_blob_sha": "5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6", + "sha256": "6ae9a08122efbad803b375dd5696485c6911ff799111dcf09811fd88bcc71539", + "size": 2484, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/export.py", + "git_blob_sha": "7f95483f148e9022245b3240659478c66ed5df00", + "sha256": "de3fb97184ac8a9a654190023913b1eb2158a8ff70bb069ec8353092e6483de9", + "size": 562, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/global.cpp", + "git_blob_sha": "eac7e283d2ad8484d4f0718ba455304035a5440d", + "sha256": "7312be680d8026b5b9730a7e531f7a2cc6a7d445a65d14bb18ec4e3c2f393f1a", + "size": 11513, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/local.py", + "git_blob_sha": "5e8157d957e67293c66f6793911ef77cf6581135", + "sha256": "75362c04f5fd538dc8491b913d89cba7d9c30933b9e475372e75a79ce56353bd", + "size": 7590, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/bruhat8.py", + "git_blob_sha": "f2c4ece08c01503a9ef42f67081b3abe0aab9321", + "sha256": "e703992629634ff50337828d6fc1ec23daf2bc1e5f742adb62878fe3a5a85951", + "size": 1204, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/cert_rt.py", + "git_blob_sha": "9113ef8fe31f59ed446658e856318e03f44f062e", + "sha256": "b15adc5aa1ea5761fb7dd5873c4dd44d28f15705c6ab2b1df87d3bd4b69e9a77", + "size": 2123, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkgm.py", + "git_blob_sha": "b5dd1bef63c86ab9acf49e9093fff704267ebd39", + "sha256": "73281a2fe6506cf17934497a476e2fff97bf994b1b950e0f735b3dfd6510916b", + "size": 1507, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkside.py", + "git_blob_sha": "f2ac3d9eb82c2428f1ec23c8a071bfbc387e4ad7", + "sha256": "92465c6b1fb5f4830d56af1d54222f917cab8cbfd67b1eb4e707dc0d8c5076a8", + "size": 3204, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/corners.py", + "git_blob_sha": "810144541f6811b2407df94b5ca95deb25f6ff6d", + "sha256": "f4c5d20e62967a2a7484bea59f44366daa82ca4c169691e9003e7fee76273c2b", + "size": 5671, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flag_existence.py", + "git_blob_sha": "a6143f138385df59b936814ec33b4bb6611330ec", + "sha256": "aa4205b2c59bb50faaff2f01bac8fb9b62dbb855638ea8cde678f801de30ad08", + "size": 5766, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flagbasis.py", + "git_blob_sha": "98893c5a204513a784e783a5fd25b16570a75f39", + "sha256": "b3b6df4f3d024aba1de9b54903a41e4163feb397f0e412d3c9c60f7558204b5d", + "size": 14081, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/gmside.py", + "git_blob_sha": "69862f57d00c67c575e51be323b2db351796172a", + "sha256": "a8cda0c24718980bd02b7983d340b0b97ce91f2241b81ef4127042ba81932847", + "size": 1667, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/moment.py", + "git_blob_sha": "c514c372102a9ae4189bd573f6fb0d276fc54f1e", + "sha256": "4ca6b15fa6cf799b7252d9a70d5c66dcbe86f3cc16b03b7c6f03ccda66df41be", + "size": 3907, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/orders.py", + "git_blob_sha": "86df1026f34ea313176aa06fe264d3e6b6469875", + "sha256": "ff0f0515eda0f4dc995d07436e65663c553bfa01748fa2eeec96dcee8d0a34c3", + "size": 1665, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/rtgm.py", + "git_blob_sha": "c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04", + "sha256": "1cdb902014b3c9d2a72deda999905dd04fbd555f7813d4664ca0e16355b42fdc", + "size": 7431, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/side_chains.py", + "git_blob_sha": "d08377f94ea85799a1aadac6aef69df4607297fe", + "sha256": "98c8b33d5761a6135238983a05b81a4250c0a9f02979096ae110d1104c77970d", + "size": 6893, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/sidegen.py", + "git_blob_sha": "7ab495d87c762cfc00e485711d5f5d58d97e3fc1", + "sha256": "e97ec987bd20d86e73c92f940f2ba2650f39209db14dc5f00b88436481fa4e28", + "size": 5515, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round5.lean", + "git_blob_sha": "2577a55fb158a46bb7c82db5e7f53587c5b5e91b", + "sha256": "bb45184861572975a9d9f9d3f515c9897794a30fdab4efd81b074da16629ac56", + "size": 5337, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round6.lean", + "git_blob_sha": "50514f86023fd1e948dd9bf9c9be2ec11d12e166", + "sha256": "27a4b348551cb8cce209864c08096230dba5e9f4ab04e469fcfedb61bca9b78a", + "size": 4793, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round7.lean", + "git_blob_sha": "b523099790aadab761c9a7a1085583f988d16d9b", + "sha256": "fc897ba78f0b4e429104bef7e15d728c9095f1b948f9e51b76252a368819631d", + "size": 6309, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump.py", + "git_blob_sha": "dcc74f0aa73809eed6a1b60b6a4630945864e964", + "sha256": "5cd0ec7494bbe5441c44ab6b9f2155172e1e9a75852ecdcd7aef0ebc5a36d11f", + "size": 1457, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump6.py", + "git_blob_sha": "564d980dd46da700b9cef392e8273bb2f02b6cc4", + "sha256": "f32e6de60a389803f2226b2229944404ea9e09a9291f83c8eefae54b2dc158f2", + "size": 1235, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump7.py", + "git_blob_sha": "44046768cb7bd1a34158321385f0ebad726a968d", + "sha256": "068cfb9e4139ddbcff8d3b987b92415ed0ddee20e5a4ccdf2fed5c116d52834e", + "size": 1550, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/gen.py", + "git_blob_sha": "a19afaa20c5024ff12f9f57252d49832906dbf44", + "sha256": "e4c7051a4051989bb659553884773d06dd3f09e34ba2710ad5142b702294cfc4", + "size": 5896, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round5-histograms.json", + "git_blob_sha": "d04e8b717dda125c010e7d1717f68530c79b03a6", + "sha256": "88e0befd88833b9c67f84a2cfcb47f07101c95a2aa4d72b8a72df837cb954168", + "size": 1498, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round6-histograms.json", + "git_blob_sha": "d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3", + "sha256": "e1d955df15523fd0f83c82e2a4bc080bf378ee50deb3003fce4771ac30f4ed26", + "size": 956, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round7-histograms.json", + "git_blob_sha": "830484689b2a0801992ce6b6e884014bc9c933fe", + "sha256": "8fd0abe6c230980b9a0c4a175e06ca1808b0fe5ead0cf9f268496111c2e11d2c", + "size": 2338, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/complex-source-frames.tex", + "git_blob_sha": "65b9e9129a5c4ebe205c0c971f8559a571808b95", + "sha256": "942a4369dd843736732a5ec27a1616e3ae1c2f2f8cc00b67e4a88759548a15e0", + "size": 4632, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/copied-centres.tex", + "git_blob_sha": "cdcc820c95c9aa984a703460a968421bb37189a0", + "sha256": "7b7fe97b021e00bfb2139d15e41be9ba8579803884ac2082c2b7f6ab53879aba", + "size": 4267, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/data-edge-batching.tex", + "git_blob_sha": "76c91c10c96bbb0432f7f4996c5734e5eee0b956", + "sha256": "31e7ef597a439945fd74fcfb0d8fc8fdc01d0baa7d00f69caf9aab66c7c93dc5", + "size": 2201, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/deferred-readout.tex", + "git_blob_sha": "3b6dab87052c5c941a38e857d9caba60423c944a", + "sha256": "953963b0a986bed4ac7c5c8d0ec0cd593f6525691bec9ea55a058d60669ec411", + "size": 8621, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/fine-field-lemma.tex", + "git_blob_sha": "331789a6f16c5aef87a37eedef147a3146450b86", + "sha256": "838204a16fff7dc4bc575107a5745ba28d93f4928b7e1a9100ba2c12f7b63b8d", + "size": 19643, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/flag-basis.tex", + "git_blob_sha": "5647021edd381d28fbb44ced0f8f7bcfcdeaa72f", + "sha256": "0f00ee0558ca661e4a793322e6336d9a6189f7d8e1be4e90be6232bb9327d59f", + "size": 6846, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/partial-swap-batching.tex", + "git_blob_sha": "319f6447632924760047f4a49d0f070a3094de37", + "sha256": "f82e5ff671a7532308c0b4e5424f76a80653e0d170779b27c9e72b3c8311de21", + "size": 7133, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/round3-combination.tex", + "git_blob_sha": "74d1f9a16673bb2b6258028a4259df7f0be67b35", + "sha256": "1f3eab33880c137591b6f984aa3220ca8fbc1e833a91c2aeea430f3c62580b74", + "size": 4060, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/segmented-inverse.tex", + "git_blob_sha": "09ad215ccf3876d604fbbea1f25e772cd63e875b", + "sha256": "cce6dcb88dc507c679691786909251cf79f681c673716c89524a15dbc1e97436", + "size": 19302, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/stack-notes.tex", + "git_blob_sha": "2c77009e0119100371d9546519f9fa06e5fe814f", + "sha256": "0f7725b97b6c85adc6fc38045703ca39b52ddfa9e76d14e446dbe948c47faae8", + "size": 16610, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate.py", + "git_blob_sha": "71c743a58a3d7027b865572f8bb2c5f6afe8c9db", + "sha256": "dbce6f0d3cc3cbd076686f2adf4a592fac8850abc0fd718a0933694770e9167c", + "size": 4597, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round3.py", + "git_blob_sha": "c5a9fa429bd88f7134eadf5c85eb7ce39c573e28", + "sha256": "53deb36c0f5daffc68ee02dabf189d2700f39a2bb3f01b55c663c49cd315b9ae", + "size": 4474, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round4.py", + "git_blob_sha": "5f6b2c6910563bf534f43d308d57679a90f10033", + "sha256": "a6113295a7af30b581d1230e630bba3dc7759be7807d8b2628aeaca31cddf441", + "size": 2915, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round5.py", + "git_blob_sha": "73403788933bd05b3d3d117a09a38ca519c85482", + "sha256": "6c948d995fdc60df70a36f1fe658b9dd06960fafd48badfce2144fc764a3d2b9", + "size": 3413, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round6.py", + "git_blob_sha": "aeb3e6f6c4490a097e82763517005519ed9fba3d", + "sha256": "f1d65865357b535ddd4d98b0f3bfc1947b9a434993e7c5ba1536d3a62439948f", + "size": 2479, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round7.py", + "git_blob_sha": "32c0058d832b43cb95e288467e152f72ca6083ac", + "sha256": "6f858bb8b601967e45f73eafe698cf8c5f0417182a8b1c1541c1e96b7a0f5107", + "size": 3532, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_fine_field.py", + "git_blob_sha": "13d2316ee5bf9a01514855267dee54ae583111a4", + "sha256": "93710f045ab8e8c0d4881380368405214484759e63f9f933a5c5c0f85871bd4c", + "size": 19709, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_gs_path.py", + "git_blob_sha": "b1e4281c733dc395155c4547ffc50a7b3a87fd2a", + "sha256": "9f39eeda5fed8920fffaa3309df3531e1ff3a30c3b8659745ab583012e0669ec", + "size": 13237, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_identities.py", + "git_blob_sha": "b4c481350ad8890d479fdcf954f79a04c15cd548", + "sha256": "27a91fe1fab8a0171ec59edf697c0e41fd5747792a0385e2e9f3b38beaa5b91a", + "size": 2762, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_reuse_inverse.py", + "git_blob_sha": "447418acb431af6110b10f62f9581378cf24f1bf", + "sha256": "f038a6cb823711434620412753b885962613c377cf1d0568ff6f20be09edf8d9", + "size": 5681, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_segmented_inverse.py", + "git_blob_sha": "089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c", + "sha256": "0fe5d5597c9925921979d22654ec60d45049178e423f1a54fdd63e3fe5853da3", + "size": 3976, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_subblock_inverse.py", + "git_blob_sha": "a9876c9fc01ca077dcaf13b095019357560ffd6c", + "sha256": "49fb7c2bd29bd714929e4397ea9e11a0b5e258be8ef665e33d573faded600479", + "size": 3733, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round3.py", + "git_blob_sha": "33116082d2d11bbcfa0144c54dda5c6b8fb42e1c", + "sha256": "7d9af1fb8b48c4eae029e2b37daf460c8cb727308ed840b0197f40593b618886", + "size": 1262, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round4.py", + "git_blob_sha": "68bb03e902271d87c59a102e0a83205d87cc870e", + "sha256": "b21bc2654452b04f8404670c42adc9fcd8e46ede578b5cb0aa88c7243a89ad20", + "size": 1781, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round5.py", + "git_blob_sha": "f88e4647631a1b525faac9151fa76f0534edfd15", + "sha256": "cd0c77f9e6af31fa8a6c4efe27cfca200183322cf9128e4c6ed1d675cd0c52c4", + "size": 1750, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round6.py", + "git_blob_sha": "5af8799c2c1df73d277b3ca38dabc1b9d8b64b05", + "sha256": "58bd299b361c8119c2ffa1381582346ef8f1a0cf448d847c19ec9bdbe19f78c3", + "size": 1063, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round7.py", + "git_blob_sha": "ad6d0de81e1c3cdc38f860b28619be93f597f475", + "sha256": "c0e988d363f9d989275693b340e97b59dc16e4d8835e1e9ea3d4c589da277a0f", + "size": 2199, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_witness.py", + "git_blob_sha": "a4412d43150ccb76e8cef7947a8e6f7cf3165ea5", + "sha256": "8cc1b358bd92a31d454c7dc9a2739d1d9cb53f19e3f88035aa4cd6babf11cb77", + "size": 2066, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/complex-prior-replay.json", + "git_blob_sha": "0d53f10d142b7ce4c567b0b0169b1ca9103713ee", + "sha256": "04201d7df9fe95f10859d482a2386b65fdcba5f8d7347e7837866de88ff75de4", + "size": 8359, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/round6_complex_interface_controls.py", + "git_blob_sha": "7a84af93ed875da010ad7c8dc89c0e78d9e0873c", + "sha256": "7ca3e245c7bdd814d6315f2b32ef5e0d4610834dd9e3190cc551a182c87bf5ed", + "size": 5278, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/round6_complex_literal_ledger.py", + "git_blob_sha": "269d26c42193642091ac51f1760c345fef6b7601", + "sha256": "b973d467d949912edc1cf65ee22703f9692431de72e3d87d82f442a6f7a61a1c", + "size": 7152, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/round7_balanced_assembly_candidate.py", + "git_blob_sha": "f82253aa70a818b5ae59c51f1da56021d1a207a9", + "sha256": "e10abe35cc8b536d78eda3e234ef48a6a7e49019893ec3d920779f2ac66443fd", + "size": 3151, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/round7_literal_frame_ledger.py", + "git_blob_sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "sha256": "02617ba608f971e3bdd2b45d4cbfc3d0d629873a0b9f7c22b12f347d099fdb59", + "size": 8657, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/round7_tensor_endpoint_controls.py", + "git_blob_sha": "2db779468c4f67a72b2ecf2d715fd6bea81ef946", + "sha256": "f1487b01167ef37cd180a0d969c815bcf26e627f3c264b89ccd974b63478ae91", + "size": 2265, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-full-basis.json", + "git_blob_sha": "3fc62f301d4f50d680cfbfe9417c4f2ed7e02b26", + "sha256": "1bcd74316f11ebc2c36f0c9b5638f314a3982c97e96c572816602087169f0e42", + "size": 853, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-moment-audit.json", + "git_blob_sha": "ac62a25d8caf1b992a85f0ea3c61f2686a864ecf", + "sha256": "92567c2050caeaf987358acee5dde5d8610e0f12bff6385899e3c043d6cefb89", + "size": 22652, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-validation-job.json", + "git_blob_sha": "869231d71d1f1298ed521fa643d9989bfdb2633b", + "sha256": "bb9488bd2c19423e4ccff4cd8e5052f0848a5b107a133a31179c020d26a7465e", + "size": 1483, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/deferred-signed/verify.py", + "git_blob_sha": "b3536e65e5ecb3222acf1c0e92d7ed330eed20cb", + "sha256": "cebcddbdfc553c37da7ab6b66b7e94c1dcd0610b82e79453ed937831c400c418", + "size": 6920, + "origin": "research/round7-main-integration/tree" + }, + { + "path": "research/joint-dual/SOURCE.json", + "git_blob_sha": "ff8cf2ab100ca13d099347c8375b20ffe4e13594", + "sha256": "86f6410e019b72d0675756e1480c607823011e0acfb31ea3dc71bf16cd938797", + "size": 6620, + "origin": "network" + }, + { + "path": "scripts/deferred_product/complex_frames.py", + "git_blob_sha": "b8db662f7182fe59602784b5e05600c613ce99bb", + "sha256": "5adb4d4e2298dcc3730f7480ebda207ef284ffb357185452a3b5cee30a31b39d", + "size": 16461, + "origin": "network" + }, + { + "path": "scripts/deferred_product/replayed.py", + "git_blob_sha": "673fbbba70fd80b490d7990bf3c4c682e34e385d", + "sha256": "99c1e3694ae06a7ce7a370b04ecb45ea3fcfe69a6e6e7f4c4606e0a6c74c3184", + "size": 8372, + "origin": "network" + }, + { + "path": "scripts/deferred_product_bit_checks.py", + "git_blob_sha": "b2169aefe31d0805cce4635260498bcc8c6e7492", + "sha256": "68a45428f50e61b89945fee796bf687190a1a693aa9e52307e17116b6031fb9b", + "size": 1882, + "origin": "network" + }, + { + "path": "scripts/deferred_product_complex.py", + "git_blob_sha": "83bf78351281c8cd4c3a95d5274e63a2e113b8c5", + "sha256": "09cddef34a469965c3014571bdd1a77a08b5acbaca83f37675d9691052a18867", + "size": 2358, + "origin": "network" + }, + { + "path": "scripts/deferred_product_complex_frames.py", + "git_blob_sha": "1fe60872e94d6cbc16d45a8d8aa3dd856a614be5", + "sha256": "c5fa21c40efbf9c3a7f5b132a0e591e947fe372ea8324c447649457c80877c43", + "size": 3098, + "origin": "network" + }, + { + "path": "scripts/deferred_product_network.py", + "git_blob_sha": "b757c19fe0df669b15fd7b1c62d84dd3dfecaa72", + "sha256": "420db93c65920bee13e43d3ed9afc1be56891d647a8098b3267a8f71a39fb9f5", + "size": 8210, + "origin": "network" + } + ] +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/INHERITED_SOURCE_AUDIT.json b/research/completed-core-sharing/inputs/research/pr117-public/INHERITED_SOURCE_AUDIT.json new file mode 100644 index 0000000000..44272d0887 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/INHERITED_SOURCE_AUDIT.json @@ -0,0 +1,53 @@ +{ + "commit": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "files": [ + { + "path": "scripts/endpoint_gauge/match_complex_general.cpp", + "git_blob_sha": "48df1bfea2ea5368cc612655cbd827527bb9e698", + "sha256": "fb83c08125521128a38f5ee53f91d192904cc3372ad8f196ad9576e5f4f727da", + "copied_from": "research/current-public-main/tree/scripts/endpoint_gauge/match_complex_general.cpp" + }, + { + "path": "scripts/partial_swap/binary_io.hpp", + "git_blob_sha": "4058f0f06ef0665d8ac97868298881210482b514", + "sha256": "d0be783f61ac4b7981e7e48a8c1139b52572302ba76c191c0e9a1b16a1a05e0e", + "copied_from": "research/current-public-main/tree/scripts/partial_swap/binary_io.hpp" + }, + { + "path": "notes/copied-centers-complex.tex", + "git_blob_sha": "fddd7bc7f2a2f749ba6eada19d153bf9243ee31c", + "sha256": "18eac6d5c5755e53230c0c12a633f38b6ce9666ef0322c1aff79394f2952af72", + "copied_from": "research/current-public-main/tree/notes/copied-centers-complex.tex" + }, + { + "path": "notes/structured-bulk-complex.tex", + "git_blob_sha": "53868b41b2fe979cae9dae242ea0e0aef5681257", + "sha256": "70eb8da7ea58cd9fcc79aa800bcc98a883ddfc505e91b45e7362afba1c8ea480", + "copied_from": "research/current-public-main/tree/notes/structured-bulk-complex.tex" + }, + { + "path": "notes/complex-circuit-construction.tex", + "git_blob_sha": "a5887b38d4c397fe8d7426bf4d6da8b9ea8e2ea2", + "sha256": "7c3341762dfae1997d658bdc1cdf398c04c4a1347333857b529737f6992048a1", + "copied_from": "research/current-public-main/tree/notes/complex-circuit-construction.tex" + }, + { + "path": "notes/endpoint-gauge-complex.tex", + "git_blob_sha": "907a0ceda8df0317ddc7f2b71df5af2aa4d47dfc", + "sha256": "dfee33b0281e5551bb6927f757ff0240abade60ae1800f715afd88853ae0191e", + "copied_from": "research/current-public-main/tree/notes/endpoint-gauge-complex.tex" + }, + { + "path": "references/semantic-bulk/pr21/translated-partial-complex.tex", + "git_blob_sha": "1b8fb4196372c5322da8fd8d907209b248795d7b", + "sha256": "c5c9bb75a3eede63ad706eabac58c7d31ee480d92fd7e065f5302e726834ee52", + "copied_from": "research/current-public-main/tree/references/semantic-bulk/pr21/translated-partial-complex.tex" + }, + { + "path": "notes/stopped-product-complex.tex", + "git_blob_sha": "4a9037137cd3158dbeca6d9e3b1881a599ebfcb5", + "sha256": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "copied_from": "research/round8-network-pr104/tree/notes/stopped-product-complex.tex" + } + ] +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/TREE.json b/research/completed-core-sharing/inputs/research/pr117-public/TREE.json new file mode 100644 index 0000000000..17cd1c5133 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/TREE.json @@ -0,0 +1,14772 @@ +{ + "sha": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cbb05ce504d571546d9b7794c186a613c659c3bf", + "tree": [ + { + "path": ".gitattributes", + "mode": "100644", + "type": "blob", + "sha": "41aef290fd0cf1838cb0cba28e04a97b506e8692", + "size": 409, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/41aef290fd0cf1838cb0cba28e04a97b506e8692" + }, + { + "path": ".github", + "mode": "040000", + "type": "tree", + "sha": "bd3061b08f5ac115ed8ec50f30ecc18e83d0460f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/bd3061b08f5ac115ed8ec50f30ecc18e83d0460f" + }, + { + "path": ".github/ISSUE_TEMPLATE", + "mode": "040000", + "type": "tree", + "sha": "16d13c334901c2bc20f966888d02fb62367192ca", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/16d13c334901c2bc20f966888d02fb62367192ca" + }, + { + "path": ".github/ISSUE_TEMPLATE/research-review.md", + "mode": "100644", + "type": "blob", + "sha": "dbeff4055794edfeec2d36b6578d5af8f357c834", + "size": 491, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dbeff4055794edfeec2d36b6578d5af8f357c834" + }, + { + "path": ".github/pull_request_template.md", + "mode": "100644", + "type": "blob", + "sha": "4880dea7fe58283f87c0a568ac73d438de4b3484", + "size": 192, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4880dea7fe58283f87c0a568ac73d438de4b3484" + }, + { + "path": ".github/workflows", + "mode": "040000", + "type": "tree", + "sha": "2b4d31ab2200f8c7e854e70d98ad17f7b7fbc4fe", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2b4d31ab2200f8c7e854e70d98ad17f7b7fbc4fe" + }, + { + "path": ".github/workflows/parallel-announcements.yml", + "mode": "100644", + "type": "blob", + "sha": "a77dc73fe4312eb4bc9f5321845919087171e545", + "size": 1442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a77dc73fe4312eb4bc9f5321845919087171e545" + }, + { + "path": ".github/workflows/swapnil-parallel.yml", + "mode": "100644", + "type": "blob", + "sha": "b75402eea3e8681ed4f19d1e1085a3e4490908ea", + "size": 1547, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b75402eea3e8681ed4f19d1e1085a3e4490908ea" + }, + { + "path": ".github/workflows/verify.yml", + "mode": "100644", + "type": "blob", + "sha": "0b6f8dd385305864d4d94edd1b1c64998419353b", + "size": 2282, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b6f8dd385305864d4d94edd1b1c64998419353b" + }, + { + "path": ".gitignore", + "mode": "100644", + "type": "blob", + "sha": "0c5efbf1d45aa74aa385f586b053c70e170a8324", + "size": 140, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c5efbf1d45aa74aa385f586b053c70e170a8324" + }, + { + "path": "CITATION.cff", + "mode": "100644", + "type": "blob", + "sha": "4b0e653341fd282911a80ce4d87d6412cbd8bdef", + "size": 2383, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4b0e653341fd282911a80ce4d87d6412cbd8bdef" + }, + { + "path": "CONTRIBUTING.md", + "mode": "100644", + "type": "blob", + "sha": "41defc90222be266c7108cb7b6f868c245ae88ec", + "size": 2640, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/41defc90222be266c7108cb7b6f868c245ae88ec" + }, + { + "path": "CONTRIBUTORS.md", + "mode": "100644", + "type": "blob", + "sha": "d490b0f3c6ad5a5572c1f7ae055e702c0406844f", + "size": 14783, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d490b0f3c6ad5a5572c1f7ae055e702c0406844f" + }, + { + "path": "LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "Makefile", + "mode": "100644", + "type": "blob", + "sha": "9f2cc673123983169f2848d5057ae07462aa09c8", + "size": 18056, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9f2cc673123983169f2848d5057ae07462aa09c8" + }, + { + "path": "NOTICE", + "mode": "100644", + "type": "blob", + "sha": "f7343a16289ee2691e7dbc592e4c27179eba84ea", + "size": 19832, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f7343a16289ee2691e7dbc592e4c27179eba84ea" + }, + { + "path": "PATCHING.md", + "mode": "100644", + "type": "blob", + "sha": "a02e230256b9592416b88c0f332df6f1c4c64d51", + "size": 1491, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a02e230256b9592416b88c0f332df6f1c4c64d51" + }, + { + "path": "README.md", + "mode": "100644", + "type": "blob", + "sha": "f2e3b79ca2f083db30e382933625f1b2c2737267", + "size": 12607, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2e3b79ca2f083db30e382933625f1b2c2737267" + }, + { + "path": "SOURCES.json", + "mode": "100644", + "type": "blob", + "sha": "380b5425c2797a0c11709cb02dcfbb544613f980", + "size": 12427, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/380b5425c2797a0c11709cb02dcfbb544613f980" + }, + { + "path": "artifacts", + "mode": "040000", + "type": "tree", + "sha": "7d717a161320df3cde2d1622b60daa20da71537f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/7d717a161320df3cde2d1622b60daa20da71537f" + }, + { + "path": "artifacts/batched-23-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "f0d42d430159f3f46dcf447ecb5df8aa9355e208", + "size": 178176, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0d42d430159f3f46dcf447ecb5df8aa9355e208" + }, + { + "path": "artifacts/compact-control-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "12b3faf7a62a865c9069f31fb05f7b09b9defbdf", + "size": 107112, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/12b3faf7a62a865c9069f31fb05f7b09b9defbdf" + }, + { + "path": "artifacts/complex-compression-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "609146526017ae88411401cbac2bbb87aa69e005", + "size": 75544, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/609146526017ae88411401cbac2bbb87aa69e005" + }, + { + "path": "artifacts/dag-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "b68b2e3fc12439e43afe0c9d62cea1d2c9b7cf82", + "size": 78403, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b68b2e3fc12439e43afe0c9d62cea1d2c9b7cf82" + }, + { + "path": "artifacts/endpoint-gauge-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "43b15efc39184cd6f7e673fde22259acf1d2c5b1", + "size": 144409, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/43b15efc39184cd6f7e673fde22259acf1d2c5b1" + }, + { + "path": "artifacts/incidence-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "a97a11f4db2c98ef6de74cf1db27f602a1c9229a", + "size": 80447, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a97a11f4db2c98ef6de74cf1db27f602a1c9229a" + }, + { + "path": "artifacts/nonadjacent-axis-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "571eec9a952ffee970ab85248ed1ee9ecd7afc6a", + "size": 71407, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/571eec9a952ffee970ab85248ed1ee9ecd7afc6a" + }, + { + "path": "artifacts/paired-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "037457b8762a2512b99b948eac638fd77a1426b7", + "size": 92408, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/037457b8762a2512b99b948eac638fd77a1426b7" + }, + { + "path": "artifacts/parameter-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "89df8d8bc5952e0c5f37599302036aa9d9a3f9e7", + "size": 89015, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/89df8d8bc5952e0c5f37599302036aa9d9a3f9e7" + }, + { + "path": "artifacts/partial-swap-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "8db9ece570030bcf1acd32a6b8316800ddca394c", + "size": 137389, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8db9ece570030bcf1acd32a6b8316800ddca394c" + }, + { + "path": "artifacts/routing-tuned-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "f6fb764d594cc14bd18e56d72634520ccb7cf795", + "size": 61797, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f6fb764d594cc14bd18e56d72634520ccb7cf795" + }, + { + "path": "artifacts/shared-point-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "cd8c62b9eee141fb26d581e17fb9d88d04771da4", + "size": 68375, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cd8c62b9eee141fb26d581e17fb9d88d04771da4" + }, + { + "path": "artifacts/stage-reuse-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "5784fdf8c02835446620e41ecf7a3f6cbc2f771a", + "size": 67483, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5784fdf8c02835446620e41ecf7a3f6cbc2f771a" + }, + { + "path": "artifacts/ternary-note.pdf", + "mode": "100644", + "type": "blob", + "sha": "0adb36b0cdd18e7a4c1a350277412b36d1268525", + "size": 91658, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0adb36b0cdd18e7a4c1a350277412b36d1268525" + }, + { + "path": "certificates", + "mode": "040000", + "type": "tree", + "sha": "37cacfcb505b3af4f9ef9e69af93d5da2181cf9f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/37cacfcb505b3af4f9ef9e69af93d5da2181cf9f" + }, + { + "path": "certificates/additive-label-audit.json", + "mode": "100644", + "type": "blob", + "sha": "8b2751304230f1abeac012171aa0fb88363f486a", + "size": 2722, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8b2751304230f1abeac012171aa0fb88363f486a" + }, + { + "path": "certificates/affine-vector-screens.json", + "mode": "100644", + "type": "blob", + "sha": "47e598ab3dbc5f879d4b2c123c3464497f97e9e3", + "size": 4318, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/47e598ab3dbc5f879d4b2c123c3464497f97e9e3" + }, + { + "path": "certificates/batched-network.json", + "mode": "100644", + "type": "blob", + "sha": "4b9060363969c94b61b6779abce9d80ccfaff40f", + "size": 11495, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4b9060363969c94b61b6779abce9d80ccfaff40f" + }, + { + "path": "certificates/bit-compression-audit.json", + "mode": "100644", + "type": "blob", + "sha": "2c8b221ad7935d49d2479fd44762cf8299066d19", + "size": 228264, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c8b221ad7935d49d2479fd44762cf8299066d19" + }, + { + "path": "certificates/block-carry-audit.json", + "mode": "100644", + "type": "blob", + "sha": "badaa769fd980bf7aec2e0c93a04bed38bc9ad10", + "size": 11077, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/badaa769fd980bf7aec2e0c93a04bed38bc9ad10" + }, + { + "path": "certificates/block-core.json", + "mode": "100644", + "type": "blob", + "sha": "0d6e1779e43744d53ce3b63c270ac0f17cdc5b30", + "size": 26552, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d6e1779e43744d53ce3b63c270ac0f17cdc5b30" + }, + { + "path": "certificates/block-label-audit.json", + "mode": "100644", + "type": "blob", + "sha": "305f30bfff610455647232a53e0701fc7a89d4f5", + "size": 5417, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/305f30bfff610455647232a53e0701fc7a89d4f5" + }, + { + "path": "certificates/block-label-target.json", + "mode": "100644", + "type": "blob", + "sha": "15b9609b64d73899f04232b76119367dc1acf0f6", + "size": 3580, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/15b9609b64d73899f04232b76119367dc1acf0f6" + }, + { + "path": "certificates/cancellation-audit.json", + "mode": "100644", + "type": "blob", + "sha": "2caca153e40fa95f737c53827e3359ff23476a9e", + "size": 3987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2caca153e40fa95f737c53827e3359ff23476a9e" + }, + { + "path": "certificates/coded-carry-audit.json", + "mode": "100644", + "type": "blob", + "sha": "ff8e816c2b13a596fb4bce5ff92b1f24d5036118", + "size": 3368, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff8e816c2b13a596fb4bce5ff92b1f24d5036118" + }, + { + "path": "certificates/compact-control-audit.json", + "mode": "100644", + "type": "blob", + "sha": "4c9bbc30f8a27e0e96d7761af7a7a2f17d0fdbf8", + "size": 1492, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4c9bbc30f8a27e0e96d7761af7a7a2f17d0fdbf8" + }, + { + "path": "certificates/compact-control-layer.json", + "mode": "100644", + "type": "blob", + "sha": "a087e47b8be8b7fe1f21ea2ea60b1f53e0b877d8", + "size": 14830, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a087e47b8be8b7fe1f21ea2ea60b1f53e0b877d8" + }, + { + "path": "certificates/complex-compression.json", + "mode": "100644", + "type": "blob", + "sha": "97c4be9571b5ec6cd4141fae4361bc34719e5a6d", + "size": 20402, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/97c4be9571b5ec6cd4141fae4361bc34719e5a6d" + }, + { + "path": "certificates/complex-network.json", + "mode": "100644", + "type": "blob", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62a6091887a3894535c1d059e1b0c527d556eb76" + }, + { + "path": "certificates/controlled-bit-rank-moment.json", + "mode": "100644", + "type": "blob", + "sha": "052e4feff596416dc72107f4061567fb1f87f317", + "size": 3884, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/052e4feff596416dc72107f4061567fb1f87f317" + }, + { + "path": "certificates/copied-centers-bit-axes.json", + "mode": "100644", + "type": "blob", + "sha": "bfb3a217ee1bd5decd8cf0150b8ed5573c303b72", + "size": 1011, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bfb3a217ee1bd5decd8cf0150b8ed5573c303b72" + }, + { + "path": "certificates/copied-centers-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "368757d1b4867a78931e4fe671ac965bc047d4ea", + "size": 519, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/368757d1b4867a78931e4fe671ac965bc047d4ea" + }, + { + "path": "certificates/copied-centers-corner-25-23.json", + "mode": "100644", + "type": "blob", + "sha": "421e35a7c065abf5a87b1b76b5a1a184722088c7", + "size": 64845, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/421e35a7c065abf5a87b1b76b5a1a184722088c7" + }, + { + "path": "certificates/copied-centers-input.json", + "mode": "100644", + "type": "blob", + "sha": "817b9e9b3c6bfed1f419c9704e1d02a09b91c09e", + "size": 11303, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/817b9e9b3c6bfed1f419c9704e1d02a09b91c09e" + }, + { + "path": "certificates/copied-centers-network.json", + "mode": "100644", + "type": "blob", + "sha": "20bbb6806ce0611e481512894d1fd73d97c2970f", + "size": 22787, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/20bbb6806ce0611e481512894d1fd73d97c2970f" + }, + { + "path": "certificates/core-limits.json", + "mode": "100644", + "type": "blob", + "sha": "1baba5e751287437aed548615d46b4f82cc9ff1c", + "size": 13794, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1baba5e751287437aed548615d46b4f82cc9ff1c" + }, + { + "path": "certificates/cube-core-family.json", + "mode": "100644", + "type": "blob", + "sha": "2e78dffcd381968341172601c7c85a651538863e", + "size": 20567, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e78dffcd381968341172601c7c85a651538863e" + }, + { + "path": "certificates/cyclic-topology-audit.json", + "mode": "100644", + "type": "blob", + "sha": "3c85c2ce1becc5e7c45993921d84bd6ea97c4545", + "size": 40632, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3c85c2ce1becc5e7c45993921d84bd6ea97c4545" + }, + { + "path": "certificates/dag-network.json", + "mode": "100644", + "type": "blob", + "sha": "3f9ce3c184af699cccb438acdd5b47e6458200e0", + "size": 3805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f9ce3c184af699cccb438acdd5b47e6458200e0" + }, + { + "path": "certificates/deferred-product-complex-dag.json.gz", + "mode": "100644", + "type": "blob", + "sha": "a5b0598e4c328acef11baaa32852acdbfc97eeef", + "size": 362071, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5b0598e4c328acef11baaa32852acdbfc97eeef" + }, + { + "path": "certificates/deferred-product-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "92f157e9584017d1af452638abef22e16e206295", + "size": 935, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/92f157e9584017d1af452638abef22e16e206295" + }, + { + "path": "certificates/deferred-product-complex-word.json.gz", + "mode": "100644", + "type": "blob", + "sha": "6426bc17a99c5c2ee75b984fdc8011a64563bae9", + "size": 1688240, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6426bc17a99c5c2ee75b984fdc8011a64563bae9" + }, + { + "path": "certificates/deferred-product-network.json", + "mode": "100644", + "type": "blob", + "sha": "fcd087c9fac3f92b676496b4d8367d3f0b95a9c6", + "size": 19189, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fcd087c9fac3f92b676496b4d8367d3f0b95a9c6" + }, + { + "path": "certificates/disjoint-tensor-compression.json", + "mode": "100644", + "type": "blob", + "sha": "323a46ad8fe77f3d70747b97ce5a0d0fcffaaac5", + "size": 17668, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/323a46ad8fe77f3d70747b97ce5a0d0fcffaaac5" + }, + { + "path": "certificates/dyadic-central-factor.json", + "mode": "100644", + "type": "blob", + "sha": "a85cb8a395065fffc985ead49cb0362532909c97", + "size": 4981, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a85cb8a395065fffc985ead49cb0362532909c97" + }, + { + "path": "certificates/early-sharing-audit.json", + "mode": "100644", + "type": "blob", + "sha": "344a4582845190583a35f222cb0296e4fa1fc378", + "size": 9214, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/344a4582845190583a35f222cb0296e4fa1fc378" + }, + { + "path": "certificates/endpoint-gauge-bit-axes.json", + "mode": "100644", + "type": "blob", + "sha": "f37510e4c3eebeb0f90bd79e2c3ddf2940361825", + "size": 1981, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f37510e4c3eebeb0f90bd79e2c3ddf2940361825" + }, + { + "path": "certificates/endpoint-gauge-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "a39d70088ad456528d52f71e6e4b80721ee3d52f", + "size": 9624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a39d70088ad456528d52f71e6e4b80721ee3d52f" + }, + { + "path": "certificates/endpoint-gauge-input.json", + "mode": "100644", + "type": "blob", + "sha": "97105e697e0327be58290c0b109034ed917496b9", + "size": 7323, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/97105e697e0327be58290c0b109034ed917496b9" + }, + { + "path": "certificates/endpoint-gauge-network.json", + "mode": "100644", + "type": "blob", + "sha": "39aba2fd88afed8d5b5ff8cc068a1be5026b17ab", + "size": 35249, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39aba2fd88afed8d5b5ff8cc068a1be5026b17ab" + }, + { + "path": "certificates/fano-completion-audit.json", + "mode": "100644", + "type": "blob", + "sha": "32ee20346e32d98f6fc294d8777422fb9c65bc68", + "size": 130537, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32ee20346e32d98f6fc294d8777422fb9c65bc68" + }, + { + "path": "certificates/fano-permutation-audit.json", + "mode": "100644", + "type": "blob", + "sha": "e25cd5dcc65cb4bb426a68fcfeccac2c54622956", + "size": 242516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e25cd5dcc65cb4bb426a68fcfeccac2c54622956" + }, + { + "path": "certificates/fast-gaussian.json", + "mode": "100644", + "type": "blob", + "sha": "23190c54a060cf4bc4c3ec35e72a74af3d2ca500", + "size": 4231, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/23190c54a060cf4bc4c3ec35e72a74af3d2ca500" + }, + { + "path": "certificates/fused-block-audit.json", + "mode": "100644", + "type": "blob", + "sha": "efad46873f5badb529d631868918f177fff9e629", + "size": 2286, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/efad46873f5badb529d631868918f177fff9e629" + }, + { + "path": "certificates/gather-schedule-audit.json", + "mode": "100644", + "type": "blob", + "sha": "3c9c5b3eaffa465eaf38cf272a09030cbb727cea", + "size": 2989, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3c9c5b3eaffa465eaf38cf272a09030cbb727cea" + }, + { + "path": "certificates/general-network-guard.json", + "mode": "100644", + "type": "blob", + "sha": "9194b3b1d5592647a1c614342df4c064cd378760", + "size": 10201, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9194b3b1d5592647a1c614342df4c064cd378760" + }, + { + "path": "certificates/incidence-network.json", + "mode": "100644", + "type": "blob", + "sha": "a6ca128e7f15f123e9355b6adbf435b1b0e0584b", + "size": 4493, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a6ca128e7f15f123e9355b6adbf435b1b0e0584b" + }, + { + "path": "certificates/incidence-partition-screen.json", + "mode": "100644", + "type": "blob", + "sha": "cc726689cd764e7d65b5b9a94dc268b84c18a590", + "size": 2130, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cc726689cd764e7d65b5b9a94dc268b84c18a590" + }, + { + "path": "certificates/inplace-side.json", + "mode": "100644", + "type": "blob", + "sha": "8d3240c59c26c1839c2cf7a9b063fd30cbbe5a84", + "size": 74394, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8d3240c59c26c1839c2cf7a9b063fd30cbbe5a84" + }, + { + "path": "certificates/joint-dual-compiler.json", + "mode": "100644", + "type": "blob", + "sha": "919fff2e6dac36adecf8ab4503a0d6fd65605e61", + "size": 7060, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/919fff2e6dac36adecf8ab4503a0d6fd65605e61" + }, + { + "path": "certificates/joint-dual-kappa.json", + "mode": "100644", + "type": "blob", + "sha": "2b6e7723481daa8a6e28f9e6dc03f688a1fc69a5", + "size": 37861, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2b6e7723481daa8a6e28f9e6dc03f688a1fc69a5" + }, + { + "path": "certificates/joint-dual-profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "09b01ba7aba253bc2dd8cd77cd989f6200d103f9", + "size": 286, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/09b01ba7aba253bc2dd8cd77cd989f6200d103f9" + }, + { + "path": "certificates/joint-dual-profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "8ba424f2a05476980ada061e35f4017f0d0b4bed", + "size": 299, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8ba424f2a05476980ada061e35f4017f0d0b4bed" + }, + { + "path": "certificates/joint-dual-repository-validation.json", + "mode": "100644", + "type": "blob", + "sha": "5811f46b2c9f5d4df7bc06ebb812a46b70f5351f", + "size": 12447, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5811f46b2c9f5d4df7bc06ebb812a46b70f5351f" + }, + { + "path": "certificates/joint-dual-transitions-23.json", + "mode": "100644", + "type": "blob", + "sha": "0b8e78bed7936d0eefed721470dd270bd93953c0", + "size": 703, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b8e78bed7936d0eefed721470dd270bd93953c0" + }, + { + "path": "certificates/joint-dual-transitions-25.json", + "mode": "100644", + "type": "blob", + "sha": "e3ca531a858798204e7bd1b445c39a8e89c3691e", + "size": 736, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e3ca531a858798204e7bd1b445c39a8e89c3691e" + }, + { + "path": "certificates/joint-dual-validation.json", + "mode": "100644", + "type": "blob", + "sha": "c72af03fbe41eff594b7add611ee228fc8e3a91a", + "size": 5825, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c72af03fbe41eff594b7add611ee228fc8e3a91a" + }, + { + "path": "certificates/joint-dual-word-23.json.gz", + "mode": "100644", + "type": "blob", + "sha": "143f2684b069c9c6bc034b91fa5deb3ddab3abf7", + "size": 1947485, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/143f2684b069c9c6bc034b91fa5deb3ddab3abf7" + }, + { + "path": "certificates/joint-dual-word-25.json.gz", + "mode": "100644", + "type": "blob", + "sha": "fc67bf3a5789da29392ca8f82ff0fbed906af2e3", + "size": 2604330, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fc67bf3a5789da29392ca8f82ff0fbed906af2e3" + }, + { + "path": "certificates/joint-frame-audit.json", + "mode": "100644", + "type": "blob", + "sha": "e09158a22932b607b426aee7052bc5e0dc88f157", + "size": 2442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e09158a22932b607b426aee7052bc5e0dc88f157" + }, + { + "path": "certificates/joint-return-audit.json", + "mode": "100644", + "type": "blob", + "sha": "1d7b18e04423dba9bc259b6b090074bbf274beea", + "size": 6119, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d7b18e04423dba9bc259b6b090074bbf274beea" + }, + { + "path": "certificates/layer-preparation.json", + "mode": "100644", + "type": "blob", + "sha": "dfe152d196508d83dd2fa8416427919dce185d02", + "size": 281028, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dfe152d196508d83dd2fa8416427919dce185d02" + }, + { + "path": "certificates/mixed-point-audit.json", + "mode": "100644", + "type": "blob", + "sha": "1f6c0fec1b4a96094a16e474121c3b4b2982e99c", + "size": 13136, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f6c0fec1b4a96094a16e474121c3b4b2982e99c" + }, + { + "path": "certificates/network-research.json", + "mode": "100644", + "type": "blob", + "sha": "c0f2e68fd3d6a16d873bc8c7a4187262bd4b0e73", + "size": 5141, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c0f2e68fd3d6a16d873bc8c7a4187262bd4b0e73" + }, + { + "path": "certificates/network-search.json", + "mode": "100644", + "type": "blob", + "sha": "76d69b4cacdb848a163b1cb5653cfade4c59cd8e", + "size": 503218, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/76d69b4cacdb848a163b1cb5653cfade4c59cd8e" + }, + { + "path": "certificates/network-variants.json", + "mode": "100644", + "type": "blob", + "sha": "ff0f0b89759e4d50b211ea2314080c8432a15b38", + "size": 22219, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff0f0b89759e4d50b211ea2314080c8432a15b38" + }, + { + "path": "certificates/nonadjacent-axis.json", + "mode": "100644", + "type": "blob", + "sha": "0c39f5b43ea097aafe480779ef1bc6e5da0921cc", + "size": 8249, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c39f5b43ea097aafe480779ef1bc6e5da0921cc" + }, + { + "path": "certificates/paired-network.json", + "mode": "100644", + "type": "blob", + "sha": "2c778d2d6460be7e49dc156426394ba986bf49a1", + "size": 7626, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c778d2d6460be7e49dc156426394ba986bf49a1" + }, + { + "path": "certificates/parameters.json", + "mode": "100644", + "type": "blob", + "sha": "68b2357f47ac1ff5c4dbd642737fe3d3c8cb1abc", + "size": 45097, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68b2357f47ac1ff5c4dbd642737fe3d3c8cb1abc" + }, + { + "path": "certificates/parity-side.json", + "mode": "100644", + "type": "blob", + "sha": "afbbf2d3b7c21526853f7db7860071c4a63c475d", + "size": 3952, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/afbbf2d3b7c21526853f7db7860071c4a63c475d" + }, + { + "path": "certificates/partial-swap-input.json", + "mode": "100644", + "type": "blob", + "sha": "f125702774d354e8fd03013dc14a3750623caa0b", + "size": 6320, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f125702774d354e8fd03013dc14a3750623caa0b" + }, + { + "path": "certificates/partial-swap-network.json", + "mode": "100644", + "type": "blob", + "sha": "52075f2463f60af5e16571347f24274fce73a1ea", + "size": 29631, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/52075f2463f60af5e16571347f24274fce73a1ea" + }, + { + "path": "certificates/positive-side-core.json", + "mode": "100644", + "type": "blob", + "sha": "1f502784954eea2995a775130aa760a847370ae2", + "size": 404956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f502784954eea2995a775130aa760a847370ae2" + }, + { + "path": "certificates/prime-field28.json", + "mode": "100644", + "type": "blob", + "sha": "0c505954e25362226d116c2c2e5299d02005f85f", + "size": 7770, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c505954e25362226d116c2c2e5299d02005f85f" + }, + { + "path": "certificates/prime-subset-limits.json", + "mode": "100644", + "type": "blob", + "sha": "bf1f08535e42d3823456c84b312266f1e9193482", + "size": 413918, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bf1f08535e42d3823456c84b312266f1e9193482" + }, + { + "path": "certificates/quadratic-affine-vectors.json", + "mode": "100644", + "type": "blob", + "sha": "18c312304cad0076e58581186ec4d02916c13434", + "size": 11678, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/18c312304cad0076e58581186ec4d02916c13434" + }, + { + "path": "certificates/rank-product-core.json", + "mode": "100644", + "type": "blob", + "sha": "63e8c3fa30871f6dc755f68d165e40f13e785e88", + "size": 92965, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/63e8c3fa30871f6dc755f68d165e40f13e785e88" + }, + { + "path": "certificates/routing-tuned.json", + "mode": "100644", + "type": "blob", + "sha": "f8acadcc0cea248bc4be016cd56fa3da1023b7aa", + "size": 4564, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f8acadcc0cea248bc4be016cd56fa3da1023b7aa" + }, + { + "path": "certificates/scratch-pooling-audit.json", + "mode": "100644", + "type": "blob", + "sha": "57e323724c639837f7890280cf3dfe23429c1003", + "size": 3426, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/57e323724c639837f7890280cf3dfe23429c1003" + }, + { + "path": "certificates/shared-core.json", + "mode": "100644", + "type": "blob", + "sha": "65a6fd5c193fda3257a2b7aa5f7fbf73e9382d32", + "size": 74007, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65a6fd5c193fda3257a2b7aa5f7fbf73e9382d32" + }, + { + "path": "certificates/shared-point-network.json", + "mode": "100644", + "type": "blob", + "sha": "f4acb3df895808c7a142c83cd4c7d4faabd068e8", + "size": 4869, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f4acb3df895808c7a142c83cd4c7d4faabd068e8" + }, + { + "path": "certificates/short-guard-audit.json", + "mode": "100644", + "type": "blob", + "sha": "9ef159d0e7640f7cce0c0b5b12c6d001025953d5", + "size": 2971, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9ef159d0e7640f7cce0c0b5b12c6d001025953d5" + }, + { + "path": "certificates/signed-sparse-core.json", + "mode": "100644", + "type": "blob", + "sha": "6df574842352040939ab635c2057e27f4e2d19d7", + "size": 245491, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6df574842352040939ab635c2057e27f4e2d19d7" + }, + { + "path": "certificates/single-intersection.json", + "mode": "100644", + "type": "blob", + "sha": "bbd43997f7bd569bc7db90a2d4da984f7e926204", + "size": 1053615, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bbd43997f7bd569bc7db90a2d4da984f7e926204" + }, + { + "path": "certificates/skip-frame-compiler.json", + "mode": "100644", + "type": "blob", + "sha": "21a8212d5dd3ea85a6d68d5aaef3191e65858e08", + "size": 6976, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/21a8212d5dd3ea85a6d68d5aaef3191e65858e08" + }, + { + "path": "certificates/skip-frame-kappa.json", + "mode": "100644", + "type": "blob", + "sha": "7afcd673cd747cd4593cfca3f2740680c559d563", + "size": 35019, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7afcd673cd747cd4593cfca3f2740680c559d563" + }, + { + "path": "certificates/skip-frame-mechanism-review.json", + "mode": "100644", + "type": "blob", + "sha": "49b2b5b95b76fb5e895e5357320e1c96e38f6cca", + "size": 5059, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/49b2b5b95b76fb5e895e5357320e1c96e38f6cca" + }, + { + "path": "certificates/skip-frame-profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "f9c392a475b725ef32e70b0a9e84af10f9e95f21", + "size": 286, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f9c392a475b725ef32e70b0a9e84af10f9e95f21" + }, + { + "path": "certificates/skip-frame-profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "776d70e4878756f7b2b18e7f0c4e5026564e61a7", + "size": 299, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/776d70e4878756f7b2b18e7f0c4e5026564e61a7" + }, + { + "path": "certificates/skip-frame-repository-validation.json", + "mode": "100644", + "type": "blob", + "sha": "b6bd91611d1ec7ba6fa848ab32a8e130f7570ea1", + "size": 1599, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b6bd91611d1ec7ba6fa848ab32a8e130f7570ea1" + }, + { + "path": "certificates/skip-frame-reproduction.json", + "mode": "100644", + "type": "blob", + "sha": "d6313564634f35501c9e0ae7d55b7f521b2d2fc4", + "size": 866, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d6313564634f35501c9e0ae7d55b7f521b2d2fc4" + }, + { + "path": "certificates/skip-frame-transitions-23.json", + "mode": "100644", + "type": "blob", + "sha": "140a12dbf5b514ec47156ed84aac427940a2f835", + "size": 703, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/140a12dbf5b514ec47156ed84aac427940a2f835" + }, + { + "path": "certificates/skip-frame-transitions-25.json", + "mode": "100644", + "type": "blob", + "sha": "1f233f963d71f009c218e69471f8446d168eb77f", + "size": 738, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f233f963d71f009c218e69471f8446d168eb77f" + }, + { + "path": "certificates/skip-frame-validation.json", + "mode": "100644", + "type": "blob", + "sha": "700f8f3459e6ecf76d05a452bcbf5fa1485634d5", + "size": 5777, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/700f8f3459e6ecf76d05a452bcbf5fa1485634d5" + }, + { + "path": "certificates/skip-frame-word-23.json.gz", + "mode": "100644", + "type": "blob", + "sha": "6d59a725de413450bf6c1e88b818df1156400637", + "size": 1941755, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6d59a725de413450bf6c1e88b818df1156400637" + }, + { + "path": "certificates/skip-frame-word-25.json.gz", + "mode": "100644", + "type": "blob", + "sha": "e80222538008b0840536ce0cd7bda7670217db8e", + "size": 2603776, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e80222538008b0840536ce0cd7bda7670217db8e" + }, + { + "path": "certificates/small-block-witness.json", + "mode": "100644", + "type": "blob", + "sha": "6351040b0b4070e5f9acb6cf2ef55849232108f8", + "size": 3301, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6351040b0b4070e5f9acb6cf2ef55849232108f8" + }, + { + "path": "certificates/sparse-fusion-audit.json", + "mode": "100644", + "type": "blob", + "sha": "584ea8d56bbc3c6c12867f9551b425764fbe653d", + "size": 3206, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/584ea8d56bbc3c6c12867f9551b425764fbe653d" + }, + { + "path": "certificates/split-centers-audit.json", + "mode": "100644", + "type": "blob", + "sha": "9bb1130d6a5684389b2e43b0ba4f4f7a547c0f42", + "size": 4976, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9bb1130d6a5684389b2e43b0ba4f4f7a547c0f42" + }, + { + "path": "certificates/stage-pair-audit.json", + "mode": "100644", + "type": "blob", + "sha": "2e4d46b0a333f2b2a63907fa0d924b1070b4cefa", + "size": 23367, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e4d46b0a333f2b2a63907fa0d924b1070b4cefa" + }, + { + "path": "certificates/stage-reuse.json", + "mode": "100644", + "type": "blob", + "sha": "8439758da145b133cb7b6cadccf3535c92a44ca8", + "size": 4978, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8439758da145b133cb7b6cadccf3535c92a44ca8" + }, + { + "path": "certificates/stopped-product-bit-axis.json", + "mode": "100644", + "type": "blob", + "sha": "5824891de9f7cd0ff3ba7a1fc63d9e0e245eb42c", + "size": 562, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5824891de9f7cd0ff3ba7a1fc63d9e0e245eb42c" + }, + { + "path": "certificates/stopped-product-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "7b1d99c51869ab176f4cb9ea497cba954ebde0b4", + "size": 502, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7b1d99c51869ab176f4cb9ea497cba954ebde0b4" + }, + { + "path": "certificates/stopped-product-input.json", + "mode": "100644", + "type": "blob", + "sha": "f0a910a4950aadc435a2f4f8397bc59f40e47e9d", + "size": 10267, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0a910a4950aadc435a2f4f8397bc59f40e47e9d" + }, + { + "path": "certificates/stopped-product-network.json", + "mode": "100644", + "type": "blob", + "sha": "998a8a7ea263f0c65c76557f5a0a0e2734d6bbab", + "size": 19387, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/998a8a7ea263f0c65c76557f5a0a0e2734d6bbab" + }, + { + "path": "certificates/stronger-rank-screens.json", + "mode": "100644", + "type": "blob", + "sha": "b8c1114ece376f1fcf6d5852942078b81f1cb026", + "size": 8934, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b8c1114ece376f1fcf6d5852942078b81f1cb026" + }, + { + "path": "certificates/structured-bulk-bit-axes.json", + "mode": "100644", + "type": "blob", + "sha": "0f2d2a6d303fb75337042ae9f63048078a71ef98", + "size": 1739, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0f2d2a6d303fb75337042ae9f63048078a71ef98" + }, + { + "path": "certificates/structured-bulk-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "61e4b474972dd819f9f278047235efb3d2965cb7", + "size": 9966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/61e4b474972dd819f9f278047235efb3d2965cb7" + }, + { + "path": "certificates/structured-bulk-input.json", + "mode": "100644", + "type": "blob", + "sha": "efcdef15702cba70b2b204d7d5141e2d14bcb1bd", + "size": 12740, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/efcdef15702cba70b2b204d7d5141e2d14bcb1bd" + }, + { + "path": "certificates/structured-bulk-network.json", + "mode": "100644", + "type": "blob", + "sha": "27ec86aeeab6e6a8bfcb18281648708128455e70", + "size": 28872, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/27ec86aeeab6e6a8bfcb18281648708128455e70" + }, + { + "path": "certificates/structured-bulk-rankone-exactness.json", + "mode": "100644", + "type": "blob", + "sha": "69015e51ece0279ff3f7a3e731e87f76f673f083", + "size": 2390, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/69015e51ece0279ff3f7a3e731e87f76f673f083" + }, + { + "path": "certificates/structured-bulk-rankone-profiles.json", + "mode": "100644", + "type": "blob", + "sha": "39d566bf81755122f9b76c232505afd9c991189d", + "size": 490, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39d566bf81755122f9b76c232505afd9c991189d" + }, + { + "path": "certificates/subset-core-family.json", + "mode": "100644", + "type": "blob", + "sha": "8f0b097bfcee498909043dbe0680a3acdaf62a54", + "size": 1131403, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8f0b097bfcee498909043dbe0680a3acdaf62a54" + }, + { + "path": "certificates/ternary-side.json", + "mode": "100644", + "type": "blob", + "sha": "2c5c9f6ea8ba3200c39283bc7e0059d802268c71", + "size": 30353, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c5c9f6ea8ba3200c39283bc7e0059d802268c71" + }, + { + "path": "docs", + "mode": "040000", + "type": "tree", + "sha": "92747db3980171c618b64e4317d02dc5bab111df", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/92747db3980171c618b64e4317d02dc5bab111df" + }, + { + "path": "docs/announcement.md", + "mode": "100644", + "type": "blob", + "sha": "46b4a072333628dcc7b10861e8e2a7df386e336c", + "size": 2100, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/46b4a072333628dcc7b10861e8e2a7df386e336c" + }, + { + "path": "docs/audit.md", + "mode": "100644", + "type": "blob", + "sha": "70c11b50a4a3113cbcb77d99f41adf4e41783b19", + "size": 15591, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/70c11b50a4a3113cbcb77d99f41adf4e41783b19" + }, + { + "path": "docs/ci-verification.md", + "mode": "100644", + "type": "blob", + "sha": "36c7f082f0aebd8ef389d99c2604a546a5a4b5bf", + "size": 4119, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/36c7f082f0aebd8ef389d99c2604a546a5a4b5bf" + }, + { + "path": "docs/nonadjacent-axis-audit.md", + "mode": "100644", + "type": "blob", + "sha": "061525abfcfe6e6a94e7e704f621bca18ebcf727", + "size": 9874, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/061525abfcfe6e6a94e7e704f621bca18ebcf727" + }, + { + "path": "docs/packed-movement-audit.md", + "mode": "100644", + "type": "blob", + "sha": "52a0bce0ba24046b3fdec942adcf1998e9d0ef65", + "size": 9831, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/52a0bce0ba24046b3fdec942adcf1998e9d0ef65" + }, + { + "path": "docs/pre-community-research-reproducibility.md", + "mode": "100644", + "type": "blob", + "sha": "38252ab476feedf50109f745cf330a190029b976", + "size": 19761, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38252ab476feedf50109f745cf330a190029b976" + }, + { + "path": "docs/release-notes.md", + "mode": "100644", + "type": "blob", + "sha": "dc20a6ddf6185f1c9ea639776e9734cd4af70ac3", + "size": 3866, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dc20a6ddf6185f1c9ea639776e9734cd4af70ac3" + }, + { + "path": "docs/releases", + "mode": "040000", + "type": "tree", + "sha": "f25d0df6d9e59c1602ca7d4689fa1ac77c8831c3", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f25d0df6d9e59c1602ca7d4689fa1ac77c8831c3" + }, + { + "path": "docs/releases/community-kappa-15.md", + "mode": "100644", + "type": "blob", + "sha": "90e7ff9a198440ab6b6a6674818a81f267fac675", + "size": 3405, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/90e7ff9a198440ab6b6a6674818a81f267fac675" + }, + { + "path": "docs/reproducibility.md", + "mode": "100644", + "type": "blob", + "sha": "7b966039e00750ece35a75a197e9aa03891285b5", + "size": 14160, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7b966039e00750ece35a75a197e9aa03891285b5" + }, + { + "path": "docs/research", + "mode": "040000", + "type": "tree", + "sha": "c338096b5ce933c0bc1750f6fca52a4213613c8b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c338096b5ce933c0bc1750f6fca52a4213613c8b" + }, + { + "path": "docs/research/additive-label-obstruction.md", + "mode": "100644", + "type": "blob", + "sha": "8b15df008ec4ea3a5bd6b2d81af6e2340902c440", + "size": 4115, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8b15df008ec4ea3a5bd6b2d81af6e2340902c440" + }, + { + "path": "docs/research/affine-vector-screens.md", + "mode": "100644", + "type": "blob", + "sha": "13f454478b554408cb55fdb31d514162b5c4b241", + "size": 3447, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13f454478b554408cb55fdb31d514162b5c4b241" + }, + { + "path": "docs/research/batched-review.md", + "mode": "100644", + "type": "blob", + "sha": "e2cfd014e2410c078bee21250705b7bcd4592d62", + "size": 2513, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e2cfd014e2410c078bee21250705b7bcd4592d62" + }, + { + "path": "docs/research/bit-compression-audit.md", + "mode": "100644", + "type": "blob", + "sha": "644c6587e436e3577e121dab27bfb817a6e92249", + "size": 8853, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/644c6587e436e3577e121dab27bfb817a6e92249" + }, + { + "path": "docs/research/block-carry-audit.md", + "mode": "100644", + "type": "blob", + "sha": "f18240968cb8d0314ad6aa3a7f40df9f155e5b48", + "size": 13239, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f18240968cb8d0314ad6aa3a7f40df9f155e5b48" + }, + { + "path": "docs/research/block-core.md", + "mode": "100644", + "type": "blob", + "sha": "ee553171c25fa3376e8b36ea527de1646e2ec6a3", + "size": 3654, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ee553171c25fa3376e8b36ea527de1646e2ec6a3" + }, + { + "path": "docs/research/block-label-feasibility.md", + "mode": "100644", + "type": "blob", + "sha": "e54533a35037c2a8c896196ef20a8ecc4cadbd3e", + "size": 10770, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e54533a35037c2a8c896196ef20a8ecc4cadbd3e" + }, + { + "path": "docs/research/cancellation-audit.md", + "mode": "100644", + "type": "blob", + "sha": "073c05724b3b1ccd947bf140baa70a6b128bde9c", + "size": 13280, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/073c05724b3b1ccd947bf140baa70a6b128bde9c" + }, + { + "path": "docs/research/coded-carry-audit.md", + "mode": "100644", + "type": "blob", + "sha": "0ea862415a56fda392cd5c9ef431e2fbf0392854", + "size": 10310, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0ea862415a56fda392cd5c9ef431e2fbf0392854" + }, + { + "path": "docs/research/community-audit-arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "7cafd096feca925137a51717e6e468fda279469c", + "size": 1592, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7cafd096feca925137a51717e6e468fda279469c" + }, + { + "path": "docs/research/community-final-audit.md", + "mode": "100644", + "type": "blob", + "sha": "2de4442a9e805b6a89d42b2437fdc92c2fd4ce6b", + "size": 16899, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2de4442a9e805b6a89d42b2437fdc92c2fd4ce6b" + }, + { + "path": "docs/research/community-followup-arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "55919f5cbef9549dd8bc656ede230a7af60d44d8", + "size": 1669, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/55919f5cbef9549dd8bc656ede230a7af60d44d8" + }, + { + "path": "docs/research/community-followup-integration.md", + "mode": "100644", + "type": "blob", + "sha": "91083519fe7053d7a209f5b7954804643ce9ddd5", + "size": 3853, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/91083519fe7053d7a209f5b7954804643ce9ddd5" + }, + { + "path": "docs/research/community-followup-review.md", + "mode": "100644", + "type": "blob", + "sha": "8048a13839e2d1481ac39ad91f1eff0e9f8730cb", + "size": 9748, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8048a13839e2d1481ac39ad91f1eff0e9f8730cb" + }, + { + "path": "docs/research/community-followup-validation.json", + "mode": "100644", + "type": "blob", + "sha": "85cef76e10522f8d8d5ca149bef83baa56b24065", + "size": 2567, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/85cef76e10522f8d8d5ca149bef83baa56b24065" + }, + { + "path": "docs/research/community-integration-validation.json", + "mode": "100644", + "type": "blob", + "sha": "40fd56877b12f5eeab378431f8ad1876ecab740d", + "size": 946, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/40fd56877b12f5eeab378431f8ad1876ecab740d" + }, + { + "path": "docs/research/community-integration.md", + "mode": "100644", + "type": "blob", + "sha": "3f8cbcbcefb4968526f849b524418aec9f0430ac", + "size": 7654, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f8cbcbcefb4968526f849b524418aec9f0430ac" + }, + { + "path": "docs/research/community-pair-arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "db88b8e5e069d7f0451eebd9ce3467a7e5d00c6f", + "size": 912, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db88b8e5e069d7f0451eebd9ce3467a7e5d00c6f" + }, + { + "path": "docs/research/community-round2-arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "637aa0199f167cc6c8319cfc73275b0801a740c9", + "size": 917, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/637aa0199f167cc6c8319cfc73275b0801a740c9" + }, + { + "path": "docs/research/community-round2-review.md", + "mode": "100644", + "type": "blob", + "sha": "22f4015455a75a7f634e49615ee38fc4e14e7895", + "size": 11999, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/22f4015455a75a7f634e49615ee38fc4e14e7895" + }, + { + "path": "docs/research/community-round2-twitter.md", + "mode": "100644", + "type": "blob", + "sha": "8ec77fd543718ab9aaac99c5326140111c3e386e", + "size": 18932, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8ec77fd543718ab9aaac99c5326140111c3e386e" + }, + { + "path": "docs/research/community-round2-validation.json", + "mode": "100644", + "type": "blob", + "sha": "4eac30c37df1097ca8c7bc7e30450b442e865051", + "size": 7686, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4eac30c37df1097ca8c7bc7e30450b442e865051" + }, + { + "path": "docs/research/community-transfer-review.md", + "mode": "100644", + "type": "blob", + "sha": "715e411543402712d9be687fd3c95ff8cbf4e76f", + "size": 7559, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/715e411543402712d9be687fd3c95ff8cbf4e76f" + }, + { + "path": "docs/research/compact-control-audit.md", + "mode": "100644", + "type": "blob", + "sha": "05ec3e60318f0d81354f1d259affa2c1ba78b660", + "size": 8153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05ec3e60318f0d81354f1d259affa2c1ba78b660" + }, + { + "path": "docs/research/compact-control-review.md", + "mode": "100644", + "type": "blob", + "sha": "f61a7465ab9728ffa31449111ccf10ebedfec709", + "size": 7118, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f61a7465ab9728ffa31449111ccf10ebedfec709" + }, + { + "path": "docs/research/complex-compression-review.md", + "mode": "100644", + "type": "blob", + "sha": "2721d5394e4d533f969db9dc1760e0db3393017f", + "size": 5239, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2721d5394e4d533f969db9dc1760e0db3393017f" + }, + { + "path": "docs/research/complex-compression.md", + "mode": "100644", + "type": "blob", + "sha": "51dd6e1a2960841324d4530b8e3f9cc12989e908", + "size": 6574, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/51dd6e1a2960841324d4530b8e3f9cc12989e908" + }, + { + "path": "docs/research/contribution-review.md", + "mode": "100644", + "type": "blob", + "sha": "25602c6a81b0baa0f93ff42e017dea487623f5ce", + "size": 11645, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/25602c6a81b0baa0f93ff42e017dea487623f5ce" + }, + { + "path": "docs/research/contribution-snapshot.json", + "mode": "100644", + "type": "blob", + "sha": "0b5163c7b4fd033d35037ce9604f90e6ddd6539e", + "size": 19392, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b5163c7b4fd033d35037ce9604f90e6ddd6539e" + }, + { + "path": "docs/research/contributor-announcements.md", + "mode": "100644", + "type": "blob", + "sha": "fdde1cb73c34b429e296585953c504d5e0e62a2c", + "size": 5713, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fdde1cb73c34b429e296585953c504d5e0e62a2c" + }, + { + "path": "docs/research/contributor-social-sources.json", + "mode": "100644", + "type": "blob", + "sha": "6d0edf21337e269fc668491c75388569ce043041", + "size": 20663, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6d0edf21337e269fc668491c75388569ce043041" + }, + { + "path": "docs/research/core-limits.md", + "mode": "100644", + "type": "blob", + "sha": "05bae052b5c2af58766ae5c241a15e0d4e628cc3", + "size": 5149, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05bae052b5c2af58766ae5c241a15e0d4e628cc3" + }, + { + "path": "docs/research/cross-point-sharing.md", + "mode": "100644", + "type": "blob", + "sha": "2d97f6a98e8361cccedea92bf0966d247e151376", + "size": 5296, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2d97f6a98e8361cccedea92bf0966d247e151376" + }, + { + "path": "docs/research/cube-core-family.md", + "mode": "100644", + "type": "blob", + "sha": "f95aa1af51a060261b6e2b72c65d7ecbb73eff7a", + "size": 8536, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f95aa1af51a060261b6e2b72c65d7ecbb73eff7a" + }, + { + "path": "docs/research/current-status.md", + "mode": "100644", + "type": "blob", + "sha": "c90e0e2cfce8815fef3cd37b780a299fba523e78", + "size": 9369, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c90e0e2cfce8815fef3cd37b780a299fba523e78" + }, + { + "path": "docs/research/cyclic-topology-audit.md", + "mode": "100644", + "type": "blob", + "sha": "234410f1922eb4e0c144836a647817ef7c8e88c0", + "size": 9659, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/234410f1922eb4e0c144836a647817ef7c8e88c0" + }, + { + "path": "docs/research/disjoint-tensor-compression.md", + "mode": "100644", + "type": "blob", + "sha": "5c6f8f52f79e4c56f47d5e9cd26d5549f02b60fc", + "size": 2628, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5c6f8f52f79e4c56f47d5e9cd26d5549f02b60fc" + }, + { + "path": "docs/research/dyadic-central-factor.md", + "mode": "100644", + "type": "blob", + "sha": "033537f01d3fced8515fac9e2c10b7048d351df3", + "size": 2147, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/033537f01d3fced8515fac9e2c10b7048d351df3" + }, + { + "path": "docs/research/early-sharing-and-centers.md", + "mode": "100644", + "type": "blob", + "sha": "945661f9954155acf87dd9d6dbca47d18509bbdd", + "size": 8822, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/945661f9954155acf87dd9d6dbca47d18509bbdd" + }, + { + "path": "docs/research/fano-completion-audit.md", + "mode": "100644", + "type": "blob", + "sha": "820f070c55a1574b5b7147531495062434ec9157", + "size": 10493, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/820f070c55a1574b5b7147531495062434ec9157" + }, + { + "path": "docs/research/fano-permutation-audit.md", + "mode": "100644", + "type": "blob", + "sha": "c80cc61e10a06a0b5611e4e07056f932550e4c51", + "size": 9071, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c80cc61e10a06a0b5611e4e07056f932550e4c51" + }, + { + "path": "docs/research/fused-block-audit.md", + "mode": "100644", + "type": "blob", + "sha": "a6020c272835a00d441aa711b2dc566402deaab0", + "size": 9629, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a6020c272835a00d441aa711b2dc566402deaab0" + }, + { + "path": "docs/research/gather-schedule-audit.md", + "mode": "100644", + "type": "blob", + "sha": "092af2728c84380c52dccdc9d5ed78efff0948a3", + "size": 13796, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/092af2728c84380c52dccdc9d5ed78efff0948a3" + }, + { + "path": "docs/research/general-network-guard.md", + "mode": "100644", + "type": "blob", + "sha": "3ae7a583308355535d4f32db412af4d750190234", + "size": 2187, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3ae7a583308355535d4f32db412af4d750190234" + }, + { + "path": "docs/research/incidence-network.md", + "mode": "100644", + "type": "blob", + "sha": "e8d34704cc51a17a8d51c873a646403f67142a23", + "size": 9281, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e8d34704cc51a17a8d51c873a646403f67142a23" + }, + { + "path": "docs/research/inplace-side.md", + "mode": "100644", + "type": "blob", + "sha": "a0bb57cacd27d7c2921f6060f59b42aeb1355311", + "size": 5607, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a0bb57cacd27d7c2921f6060f59b42aeb1355311" + }, + { + "path": "docs/research/joint-frame-audit.md", + "mode": "100644", + "type": "blob", + "sha": "a5b00d16c3e81d235981c572009339f77c8f1f5b", + "size": 9333, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5b00d16c3e81d235981c572009339f77c8f1f5b" + }, + { + "path": "docs/research/joint-return-audit.md", + "mode": "100644", + "type": "blob", + "sha": "91fa0c059336a0e0356b4c1c63fe3801b6982333", + "size": 9517, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/91fa0c059336a0e0356b4c1c63fe3801b6982333" + }, + { + "path": "docs/research/layer-preparation.md", + "mode": "100644", + "type": "blob", + "sha": "3d416e361ad05b7e23fe59b7283e971e9ef3bbb0", + "size": 10963, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3d416e361ad05b7e23fe59b7283e971e9ef3bbb0" + }, + { + "path": "docs/research/mixed-point-audit.md", + "mode": "100644", + "type": "blob", + "sha": "31f712b8f78cee8a05b8cb490c8c979c79265ee2", + "size": 10268, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31f712b8f78cee8a05b8cb490c8c979c79265ee2" + }, + { + "path": "docs/research/network-screens.md", + "mode": "100644", + "type": "blob", + "sha": "bc69870f7cfa30752ee898719055db6a8b6903f7", + "size": 8110, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc69870f7cfa30752ee898719055db6a8b6903f7" + }, + { + "path": "docs/research/network-search-log.md", + "mode": "100644", + "type": "blob", + "sha": "da9fc3dd700457dc3d3b88b28b37a899f772e306", + "size": 9634, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/da9fc3dd700457dc3d3b88b28b37a899f772e306" + }, + { + "path": "docs/research/next-steps.md", + "mode": "100644", + "type": "blob", + "sha": "7fbb8639935a196f985d1c41873798fccc2affa0", + "size": 12491, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7fbb8639935a196f985d1c41873798fccc2affa0" + }, + { + "path": "docs/research/overnight-25-progress.md", + "mode": "100644", + "type": "blob", + "sha": "4f406262fc564a16c9e360696aa805fb2362e49d", + "size": 19176, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4f406262fc564a16c9e360696aa805fb2362e49d" + }, + { + "path": "docs/research/pair-ranked-screen.json", + "mode": "100644", + "type": "blob", + "sha": "3420861cd725307a30b18ac0b0acf47e54f5937a", + "size": 678, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3420861cd725307a30b18ac0b0acf47e54f5937a" + }, + { + "path": "docs/research/paired-network.md", + "mode": "100644", + "type": "blob", + "sha": "5e2fb285f683acf21930b70455502c65d8a7c80d", + "size": 6815, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e2fb285f683acf21930b70455502c65d8a7c80d" + }, + { + "path": "docs/research/parity-side.md", + "mode": "100644", + "type": "blob", + "sha": "b36c404820b3e9c0f28be64ba4ea2a8e924704b3", + "size": 6127, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b36c404820b3e9c0f28be64ba4ea2a8e924704b3" + }, + { + "path": "docs/research/positive-side-core.md", + "mode": "100644", + "type": "blob", + "sha": "ae16884ecd3d8364aa7d68c48756b0872f30600d", + "size": 5714, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ae16884ecd3d8364aa7d68c48756b0872f30600d" + }, + { + "path": "docs/research/pre-community-research-history.md", + "mode": "100644", + "type": "blob", + "sha": "55a3ee787e3512d1b53d1b73a1de9e568838183b", + "size": 6837, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/55a3ee787e3512d1b53d1b73a1de9e568838183b" + }, + { + "path": "docs/research/pre-community-research-status.md", + "mode": "100644", + "type": "blob", + "sha": "9edde749d4a5d1b891a437b68032654ce0855445", + "size": 25006, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9edde749d4a5d1b891a437b68032654ce0855445" + }, + { + "path": "docs/research/preserved-research-manifest.json", + "mode": "100644", + "type": "blob", + "sha": "99fe99e89164a7e7f0966ef4aa061c01c5408105", + "size": 44527, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/99fe99e89164a7e7f0966ef4aa061c01c5408105" + }, + { + "path": "docs/research/preserved-research-validation.json", + "mode": "100644", + "type": "blob", + "sha": "1e23a215801bccee48883be30b1271f54cf4d1ab", + "size": 693, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1e23a215801bccee48883be30b1271f54cf4d1ab" + }, + { + "path": "docs/research/preserved-research.md", + "mode": "100644", + "type": "blob", + "sha": "e48daf006e652dc0d3913bba7de4c61e3d8d2b9f", + "size": 6549, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e48daf006e652dc0d3913bba7de4c61e3d8d2b9f" + }, + { + "path": "docs/research/prime-subset-limits.md", + "mode": "100644", + "type": "blob", + "sha": "586135a3c2752e625bbafe420d14cd76282b5a60", + "size": 4347, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/586135a3c2752e625bbafe420d14cd76282b5a60" + }, + { + "path": "docs/research/quadratic-affine-vectors.md", + "mode": "100644", + "type": "blob", + "sha": "75e23443f04dca4fb6e469a174e85481fa9cd2c8", + "size": 4699, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/75e23443f04dca4fb6e469a174e85481fa9cd2c8" + }, + { + "path": "docs/research/quick-67-screen.md", + "mode": "100644", + "type": "blob", + "sha": "ea70c4f92dd745f7dba8a964ef3db190a18715a6", + "size": 4017, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ea70c4f92dd745f7dba8a964ef3db190a18715a6" + }, + { + "path": "docs/research/rank-product-core.md", + "mode": "100644", + "type": "blob", + "sha": "9b683864233d79b4d9d982a48bdefd1a1bc875d0", + "size": 14358, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9b683864233d79b4d9d982a48bdefd1a1bc875d0" + }, + { + "path": "docs/research/result-history.md", + "mode": "100644", + "type": "blob", + "sha": "58f8f3314ee3402e042d122c6a34570f9bd2cc52", + "size": 14096, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/58f8f3314ee3402e042d122c6a34570f9bd2cc52" + }, + { + "path": "docs/research/shared-computation.md", + "mode": "100644", + "type": "blob", + "sha": "3a0056bb96c3471b68b42e08bf100acc8672d1b1", + "size": 8243, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a0056bb96c3471b68b42e08bf100acc8672d1b1" + }, + { + "path": "docs/research/shared-core.md", + "mode": "100644", + "type": "blob", + "sha": "3c6c1e0230782e50c9fd540c67436a7d6c6ab473", + "size": 3973, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3c6c1e0230782e50c9fd540c67436a7d6c6ab473" + }, + { + "path": "docs/research/short-guard-audit.md", + "mode": "100644", + "type": "blob", + "sha": "5ac003dc27f9dab07d653671065360a1cb4ec1a0", + "size": 11226, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5ac003dc27f9dab07d653671065360a1cb4ec1a0" + }, + { + "path": "docs/research/signed-sparse-core.md", + "mode": "100644", + "type": "blob", + "sha": "60cb0419442680e12746581c87151b2ed30db56c", + "size": 5979, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/60cb0419442680e12746581c87151b2ed30db56c" + }, + { + "path": "docs/research/single-intersection.md", + "mode": "100644", + "type": "blob", + "sha": "7cdf4555e9f9e043debbfe1e3a49fa201234d710", + "size": 4091, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7cdf4555e9f9e043debbfe1e3a49fa201234d710" + }, + { + "path": "docs/research/small-block-control.md", + "mode": "100644", + "type": "blob", + "sha": "e1d0e97aee2462ae3a213a2ecefe3fd5dfb0c600", + "size": 3377, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e1d0e97aee2462ae3a213a2ecefe3fd5dfb0c600" + }, + { + "path": "docs/research/sparse-fusion-audit.md", + "mode": "100644", + "type": "blob", + "sha": "32a3553a9e8a5072f1b669130e628d92ca868b5c", + "size": 10263, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32a3553a9e8a5072f1b669130e628d92ca868b5c" + }, + { + "path": "docs/research/stage-pair-audit.md", + "mode": "100644", + "type": "blob", + "sha": "357176cc66c420d8c4a886a38a5f3c670f9d80e1", + "size": 12498, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/357176cc66c420d8c4a886a38a5f3c670f9d80e1" + }, + { + "path": "docs/research/stronger-rank-screens.md", + "mode": "100644", + "type": "blob", + "sha": "5e4252cede0b1927b1fa1b17fd6d6d9c897272f8", + "size": 11258, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e4252cede0b1927b1fa1b17fd6d6d9c897272f8" + }, + { + "path": "docs/research/subset-core-family.md", + "mode": "100644", + "type": "blob", + "sha": "da6d8d75697e271db1e0eef14caa24ff4429b98f", + "size": 9158, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/da6d8d75697e271db1e0eef14caa24ff4429b98f" + }, + { + "path": "docs/research/ternary-release.md", + "mode": "100644", + "type": "blob", + "sha": "47ce84ab397c224772074dfdbb3e8edf784274a8", + "size": 2557, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/47ce84ab397c224772074dfdbb3e8edf784274a8" + }, + { + "path": "docs/research/ternary-review.md", + "mode": "100644", + "type": "blob", + "sha": "2ca3cc89c9a72fb83a3645f60a75833386cef022", + "size": 4196, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2ca3cc89c9a72fb83a3645f60a75833386cef022" + }, + { + "path": "docs/research/ternary-side-candidate.md", + "mode": "100644", + "type": "blob", + "sha": "511491dead844c6f0cc6fea60f63ab2dfb8ea89d", + "size": 5902, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/511491dead844c6f0cc6fea60f63ab2dfb8ea89d" + }, + { + "path": "docs/stopped-product.md", + "mode": "100644", + "type": "blob", + "sha": "a53cfa9638f195e307b8aa7de58bd95a4197ae52", + "size": 2126, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a53cfa9638f195e307b8aa7de58bd95a4197ae52" + }, + { + "path": "formal", + "mode": "040000", + "type": "tree", + "sha": "71182f8e076c9423355fddeabf451b0cade8c5ae", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/71182f8e076c9423355fddeabf451b0cade8c5ae" + }, + { + "path": "formal/circuit", + "mode": "040000", + "type": "tree", + "sha": "ba2d414af6efe50e83f7288efacda73206b70ace", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ba2d414af6efe50e83f7288efacda73206b70ace" + }, + { + "path": "formal/circuit/README.md", + "mode": "100644", + "type": "blob", + "sha": "7871454c8139df16a64e12bad6c48d545293e430", + "size": 1191, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7871454c8139df16a64e12bad6c48d545293e430" + }, + { + "path": "formal/circuit/check_paired.py", + "mode": "100644", + "type": "blob", + "sha": "76d7cd161fa3b5cc9e43aca8d29aad57b993a7c9", + "size": 4158, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/76d7cd161fa3b5cc9e43aca8d29aad57b993a7c9" + }, + { + "path": "formal/circuit/export_paired.py", + "mode": "100644", + "type": "blob", + "sha": "ba86bc6f7daa8cf625b873d10375072f20693658", + "size": 764, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ba86bc6f7daa8cf625b873d10375072f20693658" + }, + { + "path": "formal/lean", + "mode": "040000", + "type": "tree", + "sha": "5a12adbb0045552cbc6ca198eae57d3379b4ed03", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5a12adbb0045552cbc6ca198eae57d3379b4ed03" + }, + { + "path": "formal/lean/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "2b0095269262a259e61bc31cca4523fd73865541", + "size": 6, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2b0095269262a259e61bc31cca4523fd73865541" + }, + { + "path": "formal/lean/AuditAll.lean", + "mode": "100644", + "type": "blob", + "sha": "a8b583018023dc06928ff47fb0a4c887866f6fd8", + "size": 17157, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8b583018023dc06928ff47fb0a4c887866f6fd8" + }, + { + "path": "formal/lean/KappaCheck.lean", + "mode": "100644", + "type": "blob", + "sha": "fae11c72de3ca0a2cedd9eb1655671054590769d", + "size": 185, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fae11c72de3ca0a2cedd9eb1655671054590769d" + }, + { + "path": "formal/lean/KappaCheck", + "mode": "040000", + "type": "tree", + "sha": "3be42bd5b9ab81211c8ac8a9aa25d499caab39d4", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3be42bd5b9ab81211c8ac8a9aa25d499caab39d4" + }, + { + "path": "formal/lean/KappaCheck/Certificates.lean", + "mode": "100644", + "type": "blob", + "sha": "e7823cb19b5aee9dfc5c3a3a4b48aa4d92467b3f", + "size": 1332, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7823cb19b5aee9dfc5c3a3a4b48aa4d92467b3f" + }, + { + "path": "formal/lean/KappaCheck/CrocSwap.lean", + "mode": "100644", + "type": "blob", + "sha": "340496d1883cadbad960cbe3b181b78cbc50e80c", + "size": 30412, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/340496d1883cadbad960cbe3b181b78cbc50e80c" + }, + { + "path": "formal/lean/KappaCheck/Frames.lean", + "mode": "100644", + "type": "blob", + "sha": "fc4295f7be2ebbafd39d8de2309e21bedba9de51", + "size": 4198, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fc4295f7be2ebbafd39d8de2309e21bedba9de51" + }, + { + "path": "formal/lean/KappaCheck/Guard.lean", + "mode": "100644", + "type": "blob", + "sha": "6c7bddf3d123a313938576acdfc92b7670f2ecac", + "size": 11988, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c7bddf3d123a313938576acdfc92b7670f2ecac" + }, + { + "path": "formal/lean/KappaCheck/Layout.lean", + "mode": "100644", + "type": "blob", + "sha": "6157202537ecc684af8a36553035c007fc7237c2", + "size": 4241, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6157202537ecc684af8a36553035c007fc7237c2" + }, + { + "path": "formal/lean/KappaCheck/Movement.lean", + "mode": "100644", + "type": "blob", + "sha": "437d69779537790a96d9d9c8314858b7bfd56da5", + "size": 6913, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/437d69779537790a96d9d9c8314858b7bfd56da5" + }, + { + "path": "formal/lean/KappaCheck/Network.lean", + "mode": "100644", + "type": "blob", + "sha": "baf8d46daffa031de0a8303bdbb6b098b9c2a117", + "size": 5542, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/baf8d46daffa031de0a8303bdbb6b098b9c2a117" + }, + { + "path": "formal/lean/PRChecksA.lean", + "mode": "100644", + "type": "blob", + "sha": "d4efa1945891751ca2d0ca824115cea648fabae0", + "size": 130, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d4efa1945891751ca2d0ca824115cea648fabae0" + }, + { + "path": "formal/lean/PRChecksA", + "mode": "040000", + "type": "tree", + "sha": "7f357748f59b69ccbfd328ffb548af769c080976", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/7f357748f59b69ccbfd328ffb548af769c080976" + }, + { + "path": "formal/lean/PRChecksA/Axioms.lean", + "mode": "100644", + "type": "blob", + "sha": "a525385d3a41697f9378a71615e5d7d21061763b", + "size": 3813, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a525385d3a41697f9378a71615e5d7d21061763b" + }, + { + "path": "formal/lean/PRChecksA/Base.lean", + "mode": "100644", + "type": "blob", + "sha": "652716f0d0e7a0681a9d7cc3f739fc8410a945f2", + "size": 10786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/652716f0d0e7a0681a9d7cc3f739fc8410a945f2" + }, + { + "path": "formal/lean/PRChecksA/Bit.lean", + "mode": "100644", + "type": "blob", + "sha": "544fafa4d7eb751087d7a085a151ce596217b948", + "size": 8415, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/544fafa4d7eb751087d7a085a151ce596217b948" + }, + { + "path": "formal/lean/PRChecksA/PR3.lean", + "mode": "100644", + "type": "blob", + "sha": "16be07a1be54344df9308d5c809752669a0cd39e", + "size": 11739, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/16be07a1be54344df9308d5c809752669a0cd39e" + }, + { + "path": "formal/lean/PRChecksA/PR4.lean", + "mode": "100644", + "type": "blob", + "sha": "f7c0cd336f538607f86a35b323a4084724aeb887", + "size": 12257, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f7c0cd336f538607f86a35b323a4084724aeb887" + }, + { + "path": "formal/lean/PRChecksA/PR8.lean", + "mode": "100644", + "type": "blob", + "sha": "80e3518f95a9afdeb86d03472279b65e619661e8", + "size": 11124, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/80e3518f95a9afdeb86d03472279b65e619661e8" + }, + { + "path": "formal/lean/PRChecksB.lean", + "mode": "100644", + "type": "blob", + "sha": "93ce2cb260b9f74567dd002794372891a74f450e", + "size": 116, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/93ce2cb260b9f74567dd002794372891a74f450e" + }, + { + "path": "formal/lean/PRChecksB", + "mode": "040000", + "type": "tree", + "sha": "547c16329e180fce510e32fe4d6851c3febbd9e4", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/547c16329e180fce510e32fe4d6851c3febbd9e4" + }, + { + "path": "formal/lean/PRChecksB/Common.lean", + "mode": "100644", + "type": "blob", + "sha": "6a1a2b4b6c0737ddbf3a9deb6ae26d3fbd7f8315", + "size": 7755, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6a1a2b4b6c0737ddbf3a9deb6ae26d3fbd7f8315" + }, + { + "path": "formal/lean/PRChecksB/PR5.lean", + "mode": "100644", + "type": "blob", + "sha": "14464e748f0a028a97f93ec5dab41b76b5f331c8", + "size": 30807, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/14464e748f0a028a97f93ec5dab41b76b5f331c8" + }, + { + "path": "formal/lean/PRChecksB/PR5Analytic.lean", + "mode": "100644", + "type": "blob", + "sha": "fd2414424a27503cf51311838216d9da0d4f9194", + "size": 28718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fd2414424a27503cf51311838216d9da0d4f9194" + }, + { + "path": "formal/lean/PRChecksB/PR6.lean", + "mode": "100644", + "type": "blob", + "sha": "10be8e4fe74d7d329ea1cb4294bb7126fa5e3c26", + "size": 17892, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/10be8e4fe74d7d329ea1cb4294bb7126fa5e3c26" + }, + { + "path": "formal/lean/PRChecksB/PR7.lean", + "mode": "100644", + "type": "blob", + "sha": "ebd2355c3c8989ea160859104e69005bb4dad46b", + "size": 20523, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ebd2355c3c8989ea160859104e69005bb4dad46b" + }, + { + "path": "formal/lean/PRChecksC.lean", + "mode": "100644", + "type": "blob", + "sha": "46a4e135d04cfd8c24901d3447676061a4ac2c43", + "size": 137, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/46a4e135d04cfd8c24901d3447676061a4ac2c43" + }, + { + "path": "formal/lean/PRChecksC", + "mode": "040000", + "type": "tree", + "sha": "2762db1faa56dfc03db7f5add0ec7fe7689c022c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2762db1faa56dfc03db7f5add0ec7fe7689c022c" + }, + { + "path": "formal/lean/PRChecksC/Assembly.lean", + "mode": "100644", + "type": "blob", + "sha": "5d998cda1a8dbd52c1b4d01c83925a730c16483d", + "size": 4477, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d998cda1a8dbd52c1b4d01c83925a730c16483d" + }, + { + "path": "formal/lean/PRChecksC/Common.lean", + "mode": "100644", + "type": "blob", + "sha": "a06a3c1e8d5ff5e3506f6c46d4e3b3a147339f15", + "size": 11461, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a06a3c1e8d5ff5e3506f6c46d4e3b3a147339f15" + }, + { + "path": "formal/lean/PRChecksC/PR10.lean", + "mode": "100644", + "type": "blob", + "sha": "4293b06b188d20bef4936960e5bc22f0b4a7866c", + "size": 26211, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4293b06b188d20bef4936960e5bc22f0b4a7866c" + }, + { + "path": "formal/lean/PRChecksC/PR11.lean", + "mode": "100644", + "type": "blob", + "sha": "c395cbe27b8ba86cc4ed1db147d18ffac534d7ba", + "size": 13020, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c395cbe27b8ba86cc4ed1db147d18ffac534d7ba" + }, + { + "path": "formal/lean/PRChecksC/PR12.lean", + "mode": "100644", + "type": "blob", + "sha": "000bfda409a9d8f2c1bcdc71688dc6d3b1989ba9", + "size": 13540, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/000bfda409a9d8f2c1bcdc71688dc6d3b1989ba9" + }, + { + "path": "formal/lean/PRChecksC/PR9.lean", + "mode": "100644", + "type": "blob", + "sha": "e9d43b236660467cd1695af7417b9ab89956db8a", + "size": 8627, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e9d43b236660467cd1695af7417b9ab89956db8a" + }, + { + "path": "formal/lean/README.md", + "mode": "100644", + "type": "blob", + "sha": "39d8af431241fb799fd14c5dc2dd9320c414cb17", + "size": 3798, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39d8af431241fb799fd14c5dc2dd9320c414cb17" + }, + { + "path": "formal/lean/SOURCES.md", + "mode": "100644", + "type": "blob", + "sha": "f2203fb62d546555521210b271b9ca30845671f1", + "size": 29816, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2203fb62d546555521210b271b9ca30845671f1" + }, + { + "path": "formal/lean/lake-manifest.json", + "mode": "100644", + "type": "blob", + "sha": "36433bd6697cc16c39ff03acf97431386cb0f2c2", + "size": 3098, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/36433bd6697cc16c39ff03acf97431386cb0f2c2" + }, + { + "path": "formal/lean/lakefile.toml", + "mode": "100644", + "type": "blob", + "sha": "b6abf04c93acf5ec745aa06aa1b503575b454186", + "size": 412, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b6abf04c93acf5ec745aa06aa1b503575b454186" + }, + { + "path": "formal/lean/lean-toolchain", + "mode": "100644", + "type": "blob", + "sha": "980709bbbae28702ec58c368b84fdf6638093c63", + "size": 25, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/980709bbbae28702ec58c368b84fdf6638093c63" + }, + { + "path": "formal/lean/sources.py", + "mode": "100644", + "type": "blob", + "sha": "eedaedad3b825414e7f3bc597a6e12b6d4a9e9d4", + "size": 32652, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eedaedad3b825414e7f3bc597a6e12b6d4a9e9d4" + }, + { + "path": "formal/open-prs", + "mode": "040000", + "type": "tree", + "sha": "ac810c8c974cfa31036dbac4c7b9b999a756eb8f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ac810c8c974cfa31036dbac4c7b9b999a756eb8f" + }, + { + "path": "formal/open-prs/README.md", + "mode": "100644", + "type": "blob", + "sha": "5ca7f08744cf7f59c67563810165344cc7d69b4c", + "size": 4142, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5ca7f08744cf7f59c67563810165344cc7d69b4c" + }, + { + "path": "formal/open-prs/axioms", + "mode": "040000", + "type": "tree", + "sha": "6f56d13fb797364eba8ceb6d566162ca616bf5c3", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6f56d13fb797364eba8ceb6d566162ca616bf5c3" + }, + { + "path": "formal/open-prs/axioms/AxiomsB.lean", + "mode": "100644", + "type": "blob", + "sha": "06aef93951d859b4396a079181c69a48752a91ae", + "size": 5937, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/06aef93951d859b4396a079181c69a48752a91ae" + }, + { + "path": "formal/open-prs/axioms/AxiomsC.lean", + "mode": "100644", + "type": "blob", + "sha": "4a05dee539a4c831ee01cf454adaa4a5ec8391d5", + "size": 4046, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a05dee539a4c831ee01cf454adaa4a5ec8391d5" + }, + { + "path": "formal/open-prs/axioms/axioms-output-B.txt", + "mode": "100644", + "type": "blob", + "sha": "b20f0a25414b1c6b7566895b72e00983b72fa332", + "size": 11924, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b20f0a25414b1c6b7566895b72e00983b72fa332" + }, + { + "path": "formal/open-prs/axioms/check_axioms_B.py", + "mode": "100644", + "type": "blob", + "sha": "4bd7353d155aaf262ee77b558c69466cc9ab03d4", + "size": 1918, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4bd7353d155aaf262ee77b558c69466cc9ab03d4" + }, + { + "path": "formal/open-prs/data", + "mode": "040000", + "type": "tree", + "sha": "0a8b76d417c0857a3aaec881a3dfce96c3030793", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0a8b76d417c0857a3aaec881a3dfce96c3030793" + }, + { + "path": "formal/open-prs/data/MANIFEST.json", + "mode": "100644", + "type": "blob", + "sha": "0977469a8ea80d57154ae95fa0543b6f7b2be4e6", + "size": 4419, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0977469a8ea80d57154ae95fa0543b6f7b2be4e6" + }, + { + "path": "formal/open-prs/data/pr10", + "mode": "040000", + "type": "tree", + "sha": "386be292efc41c34ec05a86ef43df89acd07edda", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/386be292efc41c34ec05a86ef43df89acd07edda" + }, + { + "path": "formal/open-prs/data/pr10/certificates", + "mode": "040000", + "type": "tree", + "sha": "6db1fa08de3de4ce90d8bd102b44648b2abc2b78", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6db1fa08de3de4ce90d8bd102b44648b2abc2b78" + }, + { + "path": "formal/open-prs/data/pr10/certificates/batched-network.json", + "mode": "100644", + "type": "blob", + "sha": "4b9060363969c94b61b6779abce9d80ccfaff40f", + "size": 11495, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4b9060363969c94b61b6779abce9d80ccfaff40f" + }, + { + "path": "formal/open-prs/data/pr10/certificates/controlled-bit-rank-moment.json", + "mode": "100644", + "type": "blob", + "sha": "052e4feff596416dc72107f4061567fb1f87f317", + "size": 3884, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/052e4feff596416dc72107f4061567fb1f87f317" + }, + { + "path": "formal/open-prs/data/pr11", + "mode": "040000", + "type": "tree", + "sha": "57cb12b0174f38f44f557cae44aafa7273873445", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/57cb12b0174f38f44f557cae44aafa7273873445" + }, + { + "path": "formal/open-prs/data/pr11/research", + "mode": "040000", + "type": "tree", + "sha": "ae54bf3109eaa4f5fde66bac0ae153c7502c4d16", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ae54bf3109eaa4f5fde66bac0ae153c7502c4d16" + }, + { + "path": "formal/open-prs/data/pr11/research/geometric-dimensions", + "mode": "040000", + "type": "tree", + "sha": "bfc2768e51bf56b1301704208daf23a05fca9ced", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/bfc2768e51bf56b1301704208daf23a05fca9ced" + }, + { + "path": "formal/open-prs/data/pr11/research/geometric-dimensions/README.md", + "mode": "100644", + "type": "blob", + "sha": "a625b8069d8fb0cff10c4cde538660d76d1750a0", + "size": 9365, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a625b8069d8fb0cff10c4cde538660d76d1750a0" + }, + { + "path": "formal/open-prs/data/pr11/research/geometric-dimensions/report.json", + "mode": "100644", + "type": "blob", + "sha": "ca6d000c9dc3ec2c7c00bf265fe588c916dfde5f", + "size": 13858, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca6d000c9dc3ec2c7c00bf265fe588c916dfde5f" + }, + { + "path": "formal/open-prs/data/pr12", + "mode": "040000", + "type": "tree", + "sha": "abd99e7402fdbb0cdc76c84aae82e50ccfdfeada", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/abd99e7402fdbb0cdc76c84aae82e50ccfdfeada" + }, + { + "path": "formal/open-prs/data/pr12/research", + "mode": "040000", + "type": "tree", + "sha": "b637ca2c09fd99a0f43997c6e2e2f086a444efba", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/b637ca2c09fd99a0f43997c6e2e2f086a444efba" + }, + { + "path": "formal/open-prs/data/pr12/research/batched-followup", + "mode": "040000", + "type": "tree", + "sha": "2354051d96e8b59acaefce0907e4e60fc20714d1", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2354051d96e8b59acaefce0907e4e60fc20714d1" + }, + { + "path": "formal/open-prs/data/pr12/research/batched-followup/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "5be341cb003578d0788fa3ca9c4cb7be48d1c47a", + "size": 201851, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5be341cb003578d0788fa3ca9c4cb7be48d1c47a" + }, + { + "path": "formal/open-prs/data/pr3", + "mode": "040000", + "type": "tree", + "sha": "f4b0d2359b6827eb2e154f7dce0bf38ba24f070f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f4b0d2359b6827eb2e154f7dce0bf38ba24f070f" + }, + { + "path": "formal/open-prs/data/pr3/certificates", + "mode": "040000", + "type": "tree", + "sha": "8a3b0fddc017a7a1cac033f51e88a09420ad781a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8a3b0fddc017a7a1cac033f51e88a09420ad781a" + }, + { + "path": "formal/open-prs/data/pr3/certificates/complex-network.json", + "mode": "100644", + "type": "blob", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62a6091887a3894535c1d059e1b0c527d556eb76" + }, + { + "path": "formal/open-prs/data/pr3/certificates/paired-network.json", + "mode": "100644", + "type": "blob", + "sha": "2c778d2d6460be7e49dc156426394ba986bf49a1", + "size": 7626, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c778d2d6460be7e49dc156426394ba986bf49a1" + }, + { + "path": "formal/open-prs/data/pr3/docs", + "mode": "040000", + "type": "tree", + "sha": "173c6ec2c5c21b727bc96c5f0e98ddccace037d5", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/173c6ec2c5c21b727bc96c5f0e98ddccace037d5" + }, + { + "path": "formal/open-prs/data/pr3/docs/research", + "mode": "040000", + "type": "tree", + "sha": "d542cf061617175d50666dfa37d071f0eeacac1c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/d542cf061617175d50666dfa37d071f0eeacac1c" + }, + { + "path": "formal/open-prs/data/pr3/docs/research/complex-circuit.md", + "mode": "100644", + "type": "blob", + "sha": "8a5640282383c94b6a3966bab4ce9006490a7f23", + "size": 6284, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8a5640282383c94b6a3966bab4ce9006490a7f23" + }, + { + "path": "formal/open-prs/data/pr3/notes", + "mode": "040000", + "type": "tree", + "sha": "f2efc35bcc4959e5bb3495e28e94d24847f068b7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f2efc35bcc4959e5bb3495e28e94d24847f068b7" + }, + { + "path": "formal/open-prs/data/pr3/notes/complex-circuit-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "a5887b38d4c397fe8d7426bf4d6da8b9ea8e2ea2", + "size": 12029, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5887b38d4c397fe8d7426bf4d6da8b9ea8e2ea2" + }, + { + "path": "formal/open-prs/data/pr3/notes/complex-circuit-note.tex", + "mode": "100644", + "type": "blob", + "sha": "6cce575cb8491b7044b0b17b24868011e9e077f8", + "size": 6232, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6cce575cb8491b7044b0b17b24868011e9e077f8" + }, + { + "path": "formal/open-prs/data/pr4", + "mode": "040000", + "type": "tree", + "sha": "fcbee3787b3c8851a23c8afe6190a71e71df1a75", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/fcbee3787b3c8851a23c8afe6190a71e71df1a75" + }, + { + "path": "formal/open-prs/data/pr4/README.md", + "mode": "100644", + "type": "blob", + "sha": "55eee198fff4b9a79f3852fdba4bc89ffad6c80f", + "size": 7942, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/55eee198fff4b9a79f3852fdba4bc89ffad6c80f" + }, + { + "path": "formal/open-prs/data/pr4/certificates", + "mode": "040000", + "type": "tree", + "sha": "8da537c7152a74c5f00d69cc581afd5461e85d95", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8da537c7152a74c5f00d69cc581afd5461e85d95" + }, + { + "path": "formal/open-prs/data/pr4/certificates/paired-network.json", + "mode": "100644", + "type": "blob", + "sha": "2c778d2d6460be7e49dc156426394ba986bf49a1", + "size": 7626, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c778d2d6460be7e49dc156426394ba986bf49a1" + }, + { + "path": "formal/open-prs/data/pr4/certificates/retained-complex-layer.json", + "mode": "100644", + "type": "blob", + "sha": "caf2ffc8bbe769947fe3a9e12e91464a796ad2e8", + "size": 5810, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/caf2ffc8bbe769947fe3a9e12e91464a796ad2e8" + }, + { + "path": "formal/open-prs/data/pr4/docs", + "mode": "040000", + "type": "tree", + "sha": "365431958bdfcc8eb1818e4ca0aef8bde6d5faf7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/365431958bdfcc8eb1818e4ca0aef8bde6d5faf7" + }, + { + "path": "formal/open-prs/data/pr4/docs/research", + "mode": "040000", + "type": "tree", + "sha": "5ade309673e49628514c1088ce616983c264ba68", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5ade309673e49628514c1088ce616983c264ba68" + }, + { + "path": "formal/open-prs/data/pr4/docs/research/shared-retained-complex.md", + "mode": "100644", + "type": "blob", + "sha": "aa83dc57044a905cfe6d854e80059bd6b8780dcd", + "size": 3923, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa83dc57044a905cfe6d854e80059bd6b8780dcd" + }, + { + "path": "formal/open-prs/data/pr4/notes", + "mode": "040000", + "type": "tree", + "sha": "53703423ee6930659462c7f6084dacc9b07f75ab", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/53703423ee6930659462c7f6084dacc9b07f75ab" + }, + { + "path": "formal/open-prs/data/pr4/notes/compact-control-note.tex", + "mode": "100644", + "type": "blob", + "sha": "0d837f6242a3dcff2c434b863987ff39f875746e", + "size": 8406, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d837f6242a3dcff2c434b863987ff39f875746e" + }, + { + "path": "formal/open-prs/data/pr4/notes/retained-complex-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "9724ac58930e47ee7fde44be1c616fbdefd767cb", + "size": 11870, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9724ac58930e47ee7fde44be1c616fbdefd767cb" + }, + { + "path": "formal/open-prs/data/pr4/notes/retained-complex-note.tex", + "mode": "100644", + "type": "blob", + "sha": "05ead21e2f41db568afa2a94664e681254ba8422", + "size": 2120, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05ead21e2f41db568afa2a94664e681254ba8422" + }, + { + "path": "formal/open-prs/data/pr4/patches", + "mode": "040000", + "type": "tree", + "sha": "10ad130b4ea1db0710198dc3eac4bd590678695a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/10ad130b4ea1db0710198dc3eac4bd590678695a" + }, + { + "path": "formal/open-prs/data/pr4/patches/retained-complex-31.patch", + "mode": "100644", + "type": "blob", + "sha": "f3902f07cfe8ff2fc55205a4397e396174779a80", + "size": 94793, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f3902f07cfe8ff2fc55205a4397e396174779a80" + }, + { + "path": "formal/open-prs/data/pr5", + "mode": "040000", + "type": "tree", + "sha": "fc8e281e672dc17d78f9f69530b21993ba00af02", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/fc8e281e672dc17d78f9f69530b21993ba00af02" + }, + { + "path": "formal/open-prs/data/pr5/certificates", + "mode": "040000", + "type": "tree", + "sha": "ae1602755a8752c534c18e1184f731d919a4593c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ae1602755a8752c534c18e1184f731d919a4593c" + }, + { + "path": "formal/open-prs/data/pr5/certificates/complex-network.json", + "mode": "100644", + "type": "blob", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62a6091887a3894535c1d059e1b0c527d556eb76" + }, + { + "path": "formal/open-prs/data/pr5/certificates/fast-gaussian.json", + "mode": "100644", + "type": "blob", + "sha": "23190c54a060cf4bc4c3ec35e72a74af3d2ca500", + "size": 4231, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/23190c54a060cf4bc4c3ec35e72a74af3d2ca500" + }, + { + "path": "formal/open-prs/data/pr6", + "mode": "040000", + "type": "tree", + "sha": "0f507fd23c36056bdbdbc3cf809ced418c6951dd", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0f507fd23c36056bdbdbc3cf809ced418c6951dd" + }, + { + "path": "formal/open-prs/data/pr6/certificates", + "mode": "040000", + "type": "tree", + "sha": "65cafe193e5110c868f9f325454cdf48dc191dd2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/65cafe193e5110c868f9f325454cdf48dc191dd2" + }, + { + "path": "formal/open-prs/data/pr6/certificates/aligned-bit-network.json", + "mode": "100644", + "type": "blob", + "sha": "3906dbce07f7a1194ede536fa7ae9d6f1d4163e9", + "size": 5442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3906dbce07f7a1194ede536fa7ae9d6f1d4163e9" + }, + { + "path": "formal/open-prs/data/pr6/certificates/complex-network.json", + "mode": "100644", + "type": "blob", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62a6091887a3894535c1d059e1b0c527d556eb76" + }, + { + "path": "formal/open-prs/data/pr6/certificates/fast-gaussian.json", + "mode": "100644", + "type": "blob", + "sha": "23190c54a060cf4bc4c3ec35e72a74af3d2ca500", + "size": 4231, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/23190c54a060cf4bc4c3ec35e72a74af3d2ca500" + }, + { + "path": "formal/open-prs/data/pr7", + "mode": "040000", + "type": "tree", + "sha": "c089028149b428fc2fd0e767e884cbe79fd70403", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c089028149b428fc2fd0e767e884cbe79fd70403" + }, + { + "path": "formal/open-prs/data/pr7/certificates", + "mode": "040000", + "type": "tree", + "sha": "3a67eb01e273c99c4254492deca9272da2573034", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3a67eb01e273c99c4254492deca9272da2573034" + }, + { + "path": "formal/open-prs/data/pr7/certificates/complex-network.json", + "mode": "100644", + "type": "blob", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62a6091887a3894535c1d059e1b0c527d556eb76" + }, + { + "path": "formal/open-prs/data/pr7/certificates/fast-gaussian.json", + "mode": "100644", + "type": "blob", + "sha": "23190c54a060cf4bc4c3ec35e72a74af3d2ca500", + "size": 4231, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/23190c54a060cf4bc4c3ec35e72a74af3d2ca500" + }, + { + "path": "formal/open-prs/data/pr7/certificates/prime-field28.json", + "mode": "100644", + "type": "blob", + "sha": "0c505954e25362226d116c2c2e5299d02005f85f", + "size": 7770, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c505954e25362226d116c2c2e5299d02005f85f" + }, + { + "path": "formal/open-prs/data/pr8", + "mode": "040000", + "type": "tree", + "sha": "f8e3094e80248c43750f0cd85f8e896045db051e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f8e3094e80248c43750f0cd85f8e896045db051e" + }, + { + "path": "formal/open-prs/data/pr8/certificates", + "mode": "040000", + "type": "tree", + "sha": "d15b5f90de98c77856e328a7466d34f02058083d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/d15b5f90de98c77856e328a7466d34f02058083d" + }, + { + "path": "formal/open-prs/data/pr8/certificates/paired-network.json", + "mode": "100644", + "type": "blob", + "sha": "2c778d2d6460be7e49dc156426394ba986bf49a1", + "size": 7626, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c778d2d6460be7e49dc156426394ba986bf49a1" + }, + { + "path": "formal/open-prs/data/pr8/notes", + "mode": "040000", + "type": "tree", + "sha": "e2c4aa434c356229bbb51fb06a2b9de933c17df1", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e2c4aa434c356229bbb51fb06a2b9de933c17df1" + }, + { + "path": "formal/open-prs/data/pr8/notes/compact-control-note.tex", + "mode": "100644", + "type": "blob", + "sha": "0d837f6242a3dcff2c434b863987ff39f875746e", + "size": 8406, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d837f6242a3dcff2c434b863987ff39f875746e" + }, + { + "path": "formal/open-prs/data/pr8/research", + "mode": "040000", + "type": "tree", + "sha": "5416d993a68871dac91cdbf5ddf788375dea52ee", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5416d993a68871dac91cdbf5ddf788375dea52ee" + }, + { + "path": "formal/open-prs/data/pr8/research/geometric-complex", + "mode": "040000", + "type": "tree", + "sha": "802e5216e29698e57aadd77d30a0e8244b318443", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/802e5216e29698e57aadd77d30a0e8244b318443" + }, + { + "path": "formal/open-prs/data/pr8/research/geometric-complex/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "7159eab8873a48172de5faa4903667f113563abd", + "size": 10730, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7159eab8873a48172de5faa4903667f113563abd" + }, + { + "path": "formal/open-prs/data/pr8/research/geometric-complex/geometric-note.tex", + "mode": "100644", + "type": "blob", + "sha": "13013211abcebd9a3613a8b9954aca0e80e295b6", + "size": 20451, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13013211abcebd9a3613a8b9954aca0e80e295b6" + }, + { + "path": "formal/open-prs/data/pr9", + "mode": "040000", + "type": "tree", + "sha": "8b0720def843327d7383cbd5434d7ccb68494e64", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8b0720def843327d7383cbd5434d7ccb68494e64" + }, + { + "path": "formal/open-prs/data/pr9/research", + "mode": "040000", + "type": "tree", + "sha": "81bf7977ef7678ee93bd39d5770dab99b567fffb", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/81bf7977ef7678ee93bd39d5770dab99b567fffb" + }, + { + "path": "formal/open-prs/data/pr9/research/prime-field-followup", + "mode": "040000", + "type": "tree", + "sha": "1333ea678e7c179bbb5687bdd14941ca40e327ef", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1333ea678e7c179bbb5687bdd14941ca40e327ef" + }, + { + "path": "formal/open-prs/data/pr9/research/prime-field-followup/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "eeb43d43b0865c8960a7107f0f3862d6ab27b9c9", + "size": 224595, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eeb43d43b0865c8960a7107f0f3862d6ab27b9c9" + }, + { + "path": "formal/open-prs/data/pr9/research/prime-field-followup/vendor", + "mode": "040000", + "type": "tree", + "sha": "81325025f2f0872f26edcbe789ad970657c18f16", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/81325025f2f0872f26edcbe789ad970657c18f16" + }, + { + "path": "formal/open-prs/data/pr9/research/prime-field-followup/vendor/prime-field28.json", + "mode": "100644", + "type": "blob", + "sha": "0c505954e25362226d116c2c2e5299d02005f85f", + "size": 7770, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c505954e25362226d116c2c2e5299d02005f85f" + }, + { + "path": "formal/open-prs/drift_A.py", + "mode": "100644", + "type": "blob", + "sha": "63b00331b4ed11a2188afee3d4ebdbd86a2aebe9", + "size": 30076, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/63b00331b4ed11a2188afee3d4ebdbd86a2aebe9" + }, + { + "path": "formal/open-prs/drift_B.py", + "mode": "100644", + "type": "blob", + "sha": "1c5d85f0d27a50c806fb573de416e4688ca2e32e", + "size": 10490, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1c5d85f0d27a50c806fb573de416e4688ca2e32e" + }, + { + "path": "formal/open-prs/drift_C.py", + "mode": "100644", + "type": "blob", + "sha": "dc705856dab62450a908eb73a2e86149f680f3bd", + "size": 21388, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dc705856dab62450a908eb73a2e86149f680f3bd" + }, + { + "path": "notes", + "mode": "040000", + "type": "tree", + "sha": "59f5fb33698a45d7c8eeded971f24f4d593933be", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/59f5fb33698a45d7c8eeded971f24f4d593933be" + }, + { + "path": "notes/batched-23-note.tex", + "mode": "100644", + "type": "blob", + "sha": "14b4c401607ae9be235dd7d14bf97a0306860452", + "size": 5673, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/14b4c401607ae9be235dd7d14bf97a0306860452" + }, + { + "path": "notes/batched-algorithms.tex", + "mode": "100644", + "type": "blob", + "sha": "557cf12d7c430bdde22dd3fd6df44ffa95d6a6e0", + "size": 11705, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/557cf12d7c430bdde22dd3fd6df44ffa95d6a6e0" + }, + { + "path": "notes/batched-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "c92598b1f5b42918c23ec2988a7223bbbba5a08a", + "size": 4914, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c92598b1f5b42918c23ec2988a7223bbbba5a08a" + }, + { + "path": "notes/batched-bit-rank-accounting.tex", + "mode": "100644", + "type": "blob", + "sha": "311f6055b51a0c8bd7f6ab6d89966ee4efdf954e", + "size": 5395, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/311f6055b51a0c8bd7f6ab6d89966ee4efdf954e" + }, + { + "path": "notes/batched-bit-rows.tex", + "mode": "100644", + "type": "blob", + "sha": "cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9", + "size": 6092, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9" + }, + { + "path": "notes/batched-complex-rows.tex", + "mode": "100644", + "type": "blob", + "sha": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4", + "size": 6085, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e13bd96eb29bdc6526f10dc32e0a146bc17848a4" + }, + { + "path": "notes/batched-path-budget.tex", + "mode": "100644", + "type": "blob", + "sha": "be338f96e83e769de090d5e9dee802bea645c72c", + "size": 3601, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/be338f96e83e769de090d5e9dee802bea645c72c" + }, + { + "path": "notes/bulk-complex-guard.tex", + "mode": "100644", + "type": "blob", + "sha": "a37613f05f8301156dca00e202e275e4bb42ddcf", + "size": 6982, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a37613f05f8301156dca00e202e275e4bb42ddcf" + }, + { + "path": "notes/chirp-scaling-correction.tex", + "mode": "100644", + "type": "blob", + "sha": "a7917c55348fb4da5b095c227839c055349e6daa", + "size": 1507, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a7917c55348fb4da5b095c227839c055349e6daa" + }, + { + "path": "notes/compact-control-guard.tex", + "mode": "100644", + "type": "blob", + "sha": "bfc3b3bf9affd15c971a9fa9e7b406e08faec1e2", + "size": 1924, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bfc3b3bf9affd15c971a9fa9e7b406e08faec1e2" + }, + { + "path": "notes/compact-control-layout.tex", + "mode": "100644", + "type": "blob", + "sha": "16f4d233471a7d189163ae7e7902becadecbba64", + "size": 6075, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/16f4d233471a7d189163ae7e7902becadecbba64" + }, + { + "path": "notes/compact-control-movement.tex", + "mode": "100644", + "type": "blob", + "sha": "06b6a9ef24245ac7b724c53a204635415b402357", + "size": 9009, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/06b6a9ef24245ac7b724c53a204635415b402357" + }, + { + "path": "notes/compact-control-note.tex", + "mode": "100644", + "type": "blob", + "sha": "0d837f6242a3dcff2c434b863987ff39f875746e", + "size": 8406, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d837f6242a3dcff2c434b863987ff39f875746e" + }, + { + "path": "notes/complex-circuit-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "a5887b38d4c397fe8d7426bf4d6da8b9ea8e2ea2", + "size": 12029, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5887b38d4c397fe8d7426bf4d6da8b9ea8e2ea2" + }, + { + "path": "notes/complex-compression-note.tex", + "mode": "100644", + "type": "blob", + "sha": "878314338a4f1142eed0f8b7f88614cce0373e76", + "size": 2578, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/878314338a4f1142eed0f8b7f88614cce0373e76" + }, + { + "path": "notes/complex-compression.tex", + "mode": "100644", + "type": "blob", + "sha": "186328572907c63735a9ccb403326ffb747773bf", + "size": 12988, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/186328572907c63735a9ccb403326ffb747773bf" + }, + { + "path": "notes/controlled-projector-basis.tex", + "mode": "100644", + "type": "blob", + "sha": "7328e12957f8cef39e7425ee90d8aed4f8bb9991", + "size": 9758, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7328e12957f8cef39e7425ee90d8aed4f8bb9991" + }, + { + "path": "notes/copied-centers-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "b0c69166c3048d27518355995e3e5b622722c696", + "size": 4869, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0c69166c3048d27518355995e3e5b622722c696" + }, + { + "path": "notes/copied-centers-bit.tex", + "mode": "100644", + "type": "blob", + "sha": "1b7a2a88a49fb6d61238cde777051424d79b724d", + "size": 8711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b7a2a88a49fb6d61238cde777051424d79b724d" + }, + { + "path": "notes/copied-centers-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "fddd7bc7f2a2f749ba6eada19d153bf9243ee31c", + "size": 4732, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fddd7bc7f2a2f749ba6eada19d153bf9243ee31c" + }, + { + "path": "notes/copied-centers-lemma.tex", + "mode": "100644", + "type": "blob", + "sha": "8933aaf508aa9d4c75ba1290913e02f6868d351d", + "size": 5328, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8933aaf508aa9d4c75ba1290913e02f6868d351d" + }, + { + "path": "notes/copied-centers-note.tex", + "mode": "100644", + "type": "blob", + "sha": "739c24a47d13e9b4c35977dedfef28876cdb313e", + "size": 6412, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/739c24a47d13e9b4c35977dedfef28876cdb313e" + }, + { + "path": "notes/dag-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "ca469ce0525f0cd118218479c6917f3bab3f22e8", + "size": 11076, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca469ce0525f0cd118218479c6917f3bab3f22e8" + }, + { + "path": "notes/dag-note.tex", + "mode": "100644", + "type": "blob", + "sha": "9919eea49bf83af1c6045a4549a8858187eb7d06", + "size": 3260, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9919eea49bf83af1c6045a4549a8858187eb7d06" + }, + { + "path": "notes/disjoint-tensor-compression.tex", + "mode": "100644", + "type": "blob", + "sha": "0e3cad1b933f532cd83d6a3e93114c4c9361e65c", + "size": 5830, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e3cad1b933f532cd83d6a3e93114c4c9361e65c" + }, + { + "path": "notes/dyadic-central-factor.tex", + "mode": "100644", + "type": "blob", + "sha": "ab92b9eaedbe5100367c25838674f30b8cdf45db", + "size": 3069, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ab92b9eaedbe5100367c25838674f30b8cdf45db" + }, + { + "path": "notes/endpoint-gauge-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "1904cae2a677f77d34e3bd4b47d665d924b8af4a", + "size": 3172, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1904cae2a677f77d34e3bd4b47d665d924b8af4a" + }, + { + "path": "notes/endpoint-gauge-basis.tex", + "mode": "100644", + "type": "blob", + "sha": "8bba0203b0f59cb0c2e9e29850a4268f44d78721", + "size": 8459, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8bba0203b0f59cb0c2e9e29850a4268f44d78721" + }, + { + "path": "notes/endpoint-gauge-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "907a0ceda8df0317ddc7f2b71df5af2aa4d47dfc", + "size": 9978, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/907a0ceda8df0317ddc7f2b71df5af2aa4d47dfc" + }, + { + "path": "notes/endpoint-gauge-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "9830974a2595121aba1f477159dd6ae1ff88622a", + "size": 9722, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9830974a2595121aba1f477159dd6ae1ff88622a" + }, + { + "path": "notes/endpoint-gauge-note.tex", + "mode": "100644", + "type": "blob", + "sha": "0b8155c6a05a3ed79480edf2848db0a7b33fe632", + "size": 4790, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b8155c6a05a3ed79480edf2848db0a7b33fe632" + }, + { + "path": "notes/fast-gaussian-resampling.tex", + "mode": "100644", + "type": "blob", + "sha": "a102d214280181fe10fdbcd6343326e40b7849fa", + "size": 10523, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a102d214280181fe10fdbcd6343326e40b7849fa" + }, + { + "path": "notes/finite-alphabet-transfer.tex", + "mode": "100644", + "type": "blob", + "sha": "bc9540b3c576cf0e3fee949030d2a7faaa2879cb", + "size": 4036, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc9540b3c576cf0e3fee949030d2a7faaa2879cb" + }, + { + "path": "notes/general-network-guard.tex", + "mode": "100644", + "type": "blob", + "sha": "bc5b83610d47c82edf19aa42891428429ed14cc0", + "size": 2882, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc5b83610d47c82edf19aa42891428429ed14cc0" + }, + { + "path": "notes/incidence-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "e1c25ee51187c0dfb1bda705793cad281348cb51", + "size": 10393, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e1c25ee51187c0dfb1bda705793cad281348cb51" + }, + { + "path": "notes/incidence-note.tex", + "mode": "100644", + "type": "blob", + "sha": "e9e8a99db927a3c40ffbc8c98722fa3abb9afc71", + "size": 3583, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e9e8a99db927a3c40ffbc8c98722fa3abb9afc71" + }, + { + "path": "notes/independent-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "a4429e8ee6b05072fff2bd7697925e797b517c10", + "size": 3134, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a4429e8ee6b05072fff2bd7697925e797b517c10" + }, + { + "path": "notes/nonadjacent-axis-note.tex", + "mode": "100644", + "type": "blob", + "sha": "5b684f5cfb25bfa6e259e862544217c14c07542c", + "size": 11447, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5b684f5cfb25bfa6e259e862544217c14c07542c" + }, + { + "path": "notes/paired-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "7fd264d4bf48cb87d355bdab2bd92129857a7b77", + "size": 8791, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7fd264d4bf48cb87d355bdab2bd92129857a7b77" + }, + { + "path": "notes/paired-note.tex", + "mode": "100644", + "type": "blob", + "sha": "e23e5d215bd1ae8e9b8779fbba99e0eba81179da", + "size": 5841, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e23e5d215bd1ae8e9b8779fbba99e0eba81179da" + }, + { + "path": "notes/parameter-note.tex", + "mode": "100644", + "type": "blob", + "sha": "624c4f8fcfd9ad0675479ac06bc183e1a8ab2436", + "size": 16660, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/624c4f8fcfd9ad0675479ac06bc183e1a8ab2436" + }, + { + "path": "notes/partial-swap-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "7bf3bbe158992be7a15854071ee9f72769eb4d7e", + "size": 3143, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7bf3bbe158992be7a15854071ee9f72769eb4d7e" + }, + { + "path": "notes/partial-swap-basis.tex", + "mode": "100644", + "type": "blob", + "sha": "2c54b85c42bb9274af811851cb08a5357f561832", + "size": 9557, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c54b85c42bb9274af811851cb08a5357f561832" + }, + { + "path": "notes/partial-swap-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "98c343640af47cc3fec9a60f514652ae6b89abfc", + "size": 6321, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/98c343640af47cc3fec9a60f514652ae6b89abfc" + }, + { + "path": "notes/partial-swap-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "60c41a168e183f5797a275c39c468f5fc059ce5e", + "size": 9772, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/60c41a168e183f5797a275c39c468f5fc059ce5e" + }, + { + "path": "notes/partial-swap-note.tex", + "mode": "100644", + "type": "blob", + "sha": "5799f6a1fe7790b252d120e0c4f737c333a4773b", + "size": 4846, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5799f6a1fe7790b252d120e0c4f737c333a4773b" + }, + { + "path": "notes/prime-field28-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "21ce20f336281accc1097b20f0c7866bbd613404", + "size": 13670, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/21ce20f336281accc1097b20f0c7866bbd613404" + }, + { + "path": "notes/projector-batching.tex", + "mode": "100644", + "type": "blob", + "sha": "c4e3984390c2dbba1acc36d866e95850f3a5605e", + "size": 7105, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c4e3984390c2dbba1acc36d866e95850f3a5605e" + }, + { + "path": "notes/routing-tuned-note.tex", + "mode": "100644", + "type": "blob", + "sha": "c94c50151c9f21695f06bc6668faf71427a90a1b", + "size": 6653, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c94c50151c9f21695f06bc6668faf71427a90a1b" + }, + { + "path": "notes/shared-point-construction.tex", + "mode": "100644", + "type": "blob", + "sha": "3533740997428f893dc1abac2fa2e667a694c98e", + "size": 6689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3533740997428f893dc1abac2fa2e667a694c98e" + }, + { + "path": "notes/shared-point-note.tex", + "mode": "100644", + "type": "blob", + "sha": "2c342a4ee7eaf5e24bd33bfdd4eea41e76ea8dcb", + "size": 3322, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c342a4ee7eaf5e24bd33bfdd4eea41e76ea8dcb" + }, + { + "path": "notes/stage-reuse-note.tex", + "mode": "100644", + "type": "blob", + "sha": "ad90ac8779f847df3776b8b6a48d15d65bddfe0a", + "size": 7698, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad90ac8779f847df3776b8b6a48d15d65bddfe0a" + }, + { + "path": "notes/stopped-guard.tex", + "mode": "100644", + "type": "blob", + "sha": "da5ea40785aa98f627753038750c564220298d95", + "size": 3291, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/da5ea40785aa98f627753038750c564220298d95" + }, + { + "path": "notes/stopped-product-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "3932d3ade5ddeae127c246aed515e0346a40f067", + "size": 4844, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3932d3ade5ddeae127c246aed515e0346a40f067" + }, + { + "path": "notes/stopped-product-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "4a9037137cd3158dbeca6d9e3b1881a599ebfcb5", + "size": 6252, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a9037137cd3158dbeca6d9e3b1881a599ebfcb5" + }, + { + "path": "notes/stopped-product-factorization.tex", + "mode": "100644", + "type": "blob", + "sha": "94f7b81397e20406acba32231b7ef4bdc29c43a9", + "size": 5124, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94f7b81397e20406acba32231b7ef4bdc29c43a9" + }, + { + "path": "notes/stopped-product-interface.tex", + "mode": "100644", + "type": "blob", + "sha": "20c44ce4866fa972ce64365dcf365b1659a83050", + "size": 4684, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/20c44ce4866fa972ce64365dcf365b1659a83050" + }, + { + "path": "notes/stopped-product-note.tex", + "mode": "100644", + "type": "blob", + "sha": "a8b23254c8873d9c2480750a7d435b6cbab3b021", + "size": 4108, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8b23254c8873d9c2480750a7d435b6cbab3b021" + }, + { + "path": "notes/structured-bulk-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "9bd11d88d201d6aa7b110bc169648d928c3a9c14", + "size": 12950, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9bd11d88d201d6aa7b110bc169648d928c3a9c14" + }, + { + "path": "notes/structured-bulk-bit.tex", + "mode": "100644", + "type": "blob", + "sha": "fe13b87bf486582a8722cf881e271a31c69d422d", + "size": 10474, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fe13b87bf486582a8722cf881e271a31c69d422d" + }, + { + "path": "notes/structured-bulk-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "53868b41b2fe979cae9dae242ea0e0aef5681257", + "size": 5806, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/53868b41b2fe979cae9dae242ea0e0aef5681257" + }, + { + "path": "notes/structured-bulk-crt.tex", + "mode": "100644", + "type": "blob", + "sha": "385f2af8aab4884bd7bb42c89fb75c3b81d3e736", + "size": 5868, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/385f2af8aab4884bd7bb42c89fb75c3b81d3e736" + }, + { + "path": "notes/structured-bulk-note.tex", + "mode": "100644", + "type": "blob", + "sha": "def3d3c52f89cb6abb934414906299933833c3ac", + "size": 6456, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/def3d3c52f89cb6abb934414906299933833c3ac" + }, + { + "path": "notes/ternary-five-subsets.tex", + "mode": "100644", + "type": "blob", + "sha": "ddc08d1b1385d685611b9c3d6d8358e4269b70e0", + "size": 12096, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ddc08d1b1385d685611b9c3d6d8358e4269b70e0" + }, + { + "path": "notes/ternary-note.tex", + "mode": "100644", + "type": "blob", + "sha": "bbc1da178845876ecb370d6973b45e998f8a5810", + "size": 2687, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bbc1da178845876ecb370d6973b45e998f8a5810" + }, + { + "path": "patches", + "mode": "040000", + "type": "tree", + "sha": "94bffa5983fde98fe5d5e3f58c48c3ec61b2a44f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/94bffa5983fde98fe5d5e3f58c48c3ec61b2a44f" + }, + { + "path": "patches/balanced-153.patch", + "mode": "100644", + "type": "blob", + "sha": "3d15dd2b45490c6796850f945d3ca0542a916572", + "size": 2799, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3d15dd2b45490c6796850f945d3ca0542a916572" + }, + { + "path": "patches/batched-23.patch", + "mode": "100644", + "type": "blob", + "sha": "043c7475e638442a3b36f5b0447e1fa1c9962777", + "size": 196166, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/043c7475e638442a3b36f5b0447e1fa1c9962777" + }, + { + "path": "patches/compact-control-34.patch", + "mode": "100644", + "type": "blob", + "sha": "eb1af236eeae6c683dab6951b78e10f1fa8d7a15", + "size": 78539, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb1af236eeae6c683dab6951b78e10f1fa8d7a15" + }, + { + "path": "patches/complex-compression-31.patch", + "mode": "100644", + "type": "blob", + "sha": "bca06e2c1721a8dca048870c1f274b49af41b321", + "size": 88879, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bca06e2c1721a8dca048870c1f274b49af41b321" + }, + { + "path": "patches/copied-fixed-reversed.patch", + "mode": "100644", + "type": "blob", + "sha": "b14fbb887425a7f806950e0f8afed2b839f96c59", + "size": 349561, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b14fbb887425a7f806950e0f8afed2b839f96c59" + }, + { + "path": "patches/copied-reversed.patch", + "mode": "100644", + "type": "blob", + "sha": "a3b3c2275b17c0ae36be66fbd7cb5172c71adfc5", + "size": 176346, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a3b3c2275b17c0ae36be66fbd7cb5172c71adfc5" + }, + { + "path": "patches/frozen-154.patch", + "mode": "100644", + "type": "blob", + "sha": "ff9cd94c7f5c332d5b8d97d559f4b8803f548c7c", + "size": 2787, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff9cd94c7f5c332d5b8d97d559f4b8803f548c7c" + }, + { + "path": "patches/frozen-nonadjacent-107.patch", + "mode": "100644", + "type": "blob", + "sha": "48227b278e74e82d7ac8486d42f2d9eba023a9d2", + "size": 12555, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/48227b278e74e82d7ac8486d42f2d9eba023a9d2" + }, + { + "path": "patches/h46-108.patch", + "mode": "100644", + "type": "blob", + "sha": "eb721af310e98ec72f8ed92fc9459e8493167b32", + "size": 11231, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb721af310e98ec72f8ed92fc9459e8493167b32" + }, + { + "path": "patches/h46-109.patch", + "mode": "100644", + "type": "blob", + "sha": "e85984106a72f0bdb02a485fbce20b4518fffa66", + "size": 10294, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e85984106a72f0bdb02a485fbce20b4518fffa66" + }, + { + "path": "patches/h46-111.patch", + "mode": "100644", + "type": "blob", + "sha": "a032c6e0cf993cf33db3d8f64c6559e76820e526", + "size": 9021, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a032c6e0cf993cf33db3d8f64c6559e76820e526" + }, + { + "path": "patches/h46-dag-63.patch", + "mode": "100644", + "type": "blob", + "sha": "235168629804b6fb35aa322992e35fc02df10ede", + "size": 41740, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/235168629804b6fb35aa322992e35fc02df10ede" + }, + { + "path": "patches/h46-incidence-67.patch", + "mode": "100644", + "type": "blob", + "sha": "1b23ee18cc77622d26eec5d2f378751645408538", + "size": 31111, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b23ee18cc77622d26eec5d2f378751645408538" + }, + { + "path": "patches/h46-nonadjacent-76.patch", + "mode": "100644", + "type": "blob", + "sha": "4a6dfe11e8ec1a2d649afe4a0bf1810b07165087", + "size": 20134, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a6dfe11e8ec1a2d649afe4a0bf1810b07165087" + }, + { + "path": "patches/h46-nonadjacent-78.patch", + "mode": "100644", + "type": "blob", + "sha": "6c0ec5e061969a64d7df6d79b0852317ef0821f4", + "size": 18748, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c0ec5e061969a64d7df6d79b0852317ef0821f4" + }, + { + "path": "patches/h46-rational.patch", + "mode": "100644", + "type": "blob", + "sha": "fe01ae166669f367dc8c55168c1989532539996a", + "size": 11341, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fe01ae166669f367dc8c55168c1989532539996a" + }, + { + "path": "patches/h46-shared-point.patch", + "mode": "100644", + "type": "blob", + "sha": "1c8eab35b6310260a3a35e24de12f798fbc31fed", + "size": 47933, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1c8eab35b6310260a3a35e24de12f798fbc31fed" + }, + { + "path": "patches/h46-shared-side-75.patch", + "mode": "100644", + "type": "blob", + "sha": "9090b54738bf3e8500bcecaca4349d1493a0aeb9", + "size": 25962, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9090b54738bf3e8500bcecaca4349d1493a0aeb9" + }, + { + "path": "patches/h50-paired-59.patch", + "mode": "100644", + "type": "blob", + "sha": "7845742a9c5c33a6085e7abb1e56ed2b6fb4dc0c", + "size": 41216, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7845742a9c5c33a6085e7abb1e56ed2b6fb4dc0c" + }, + { + "path": "patches/nonadjacent-layout.patch", + "mode": "100644", + "type": "blob", + "sha": "2a2385502e584672ac45708e54b6dc9556bbea0a", + "size": 8935, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a2385502e584672ac45708e54b6dc9556bbea0a" + }, + { + "path": "patches/same-network-129.patch", + "mode": "100644", + "type": "blob", + "sha": "d7b67cf649fce615ecad72f8b0ee936ae138ddc7", + "size": 4705, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d7b67cf649fce615ecad72f8b0ee936ae138ddc7" + }, + { + "path": "patches/ternary-30.patch", + "mode": "100644", + "type": "blob", + "sha": "67ebd71749ebd365d964e4d39a3a16453fe24ccb", + "size": 106138, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/67ebd71749ebd365d964e4d39a3a16453fe24ccb" + }, + { + "path": "references", + "mode": "040000", + "type": "tree", + "sha": "9b006de4e1e7d18f9ab4118223ecb43983a45d84", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9b006de4e1e7d18f9ab4118223ecb43983a45d84" + }, + { + "path": "references/copied-centers", + "mode": "040000", + "type": "tree", + "sha": "0b6695ef66378c2ac6b34d8d8b7c77ce0eee4110", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0b6695ef66378c2ac6b34d8d8b7c77ce0eee4110" + }, + { + "path": "references/copied-centers/MANIFEST.json", + "mode": "100644", + "type": "blob", + "sha": "7c430d61a27db8aeb5fb631fed26926d95025260", + "size": 1141, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7c430d61a27db8aeb5fb631fed26926d95025260" + }, + { + "path": "references/copied-centers/PROVENANCE.json", + "mode": "100644", + "type": "blob", + "sha": "23bf52d541c00fc289959a07caf0fd5c893943d0", + "size": 1308, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/23bf52d541c00fc289959a07caf0fd5c893943d0" + }, + { + "path": "references/copied-centers/README.md", + "mode": "100644", + "type": "blob", + "sha": "9adb20300fbff3c7f5c072f28150e9cb43b52ed3", + "size": 1149, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9adb20300fbff3c7f5c072f28150e9cb43b52ed3" + }, + { + "path": "references/copied-centers/SOURCES.json", + "mode": "100644", + "type": "blob", + "sha": "99481f67ff79ea0871f99a5287c4b456f0721677", + "size": 1802, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/99481f67ff79ea0871f99a5287c4b456f0721677" + }, + { + "path": "references/copied-centers/pr29", + "mode": "040000", + "type": "tree", + "sha": "97b24b3906d00836f3997e90b3767c42212f7288", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/97b24b3906d00836f3997e90b3767c42212f7288" + }, + { + "path": "references/copied-centers/pr29/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "57bc88a15a0ee8266c259b2667e64608d3f7e292", + "size": 11358, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/57bc88a15a0ee8266c259b2667e64608d3f7e292" + }, + { + "path": "references/copied-centers/pr29/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "0fb470fb5abbd67fdc9541e0fa8d3e2cf566d8a2", + "size": 6907, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb470fb5abbd67fdc9541e0fa8d3e2cf566d8a2" + }, + { + "path": "references/copied-centers/pr29/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "617fde9fbe0aa82cb4699f7d0c0c382e22c8a7c5", + "size": 4546, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/617fde9fbe0aa82cb4699f7d0c0c382e22c8a7c5" + }, + { + "path": "references/copied-centers/pr29/paureel-direct-transfer.tex", + "mode": "100644", + "type": "blob", + "sha": "510699d65f8f9b2546b9b165c7099a6cdebdf669", + "size": 5288, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/510699d65f8f9b2546b9b165c7099a6cdebdf669" + }, + { + "path": "references/copied-centers/pr29/two-stage-16-note.tex", + "mode": "100644", + "type": "blob", + "sha": "d137605bdd869ed9c684f2721794ab6d82f1d511", + "size": 16871, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d137605bdd869ed9c684f2721794ab6d82f1d511" + }, + { + "path": "references/copied-centers/pr33", + "mode": "040000", + "type": "tree", + "sha": "cdfc6fac5cbfeb92c08dcde7468eb60f31adc604", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cdfc6fac5cbfeb92c08dcde7468eb60f31adc604" + }, + { + "path": "references/copied-centers/pr33/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "57bc88a15a0ee8266c259b2667e64608d3f7e292", + "size": 11358, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/57bc88a15a0ee8266c259b2667e64608d3f7e292" + }, + { + "path": "references/copied-centers/pr33/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "65f27fece6425830b52a2dc691803ad56f63856e", + "size": 8213, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65f27fece6425830b52a2dc691803ad56f63856e" + }, + { + "path": "references/copied-centers/pr33/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "93a04ab819bea1f2e5e57819f0f6c29302a6cd3d", + "size": 1648, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/93a04ab819bea1f2e5e57819f0f6c29302a6cd3d" + }, + { + "path": "references/copied-centers/pr33/two-stage-corners-47-45-note.tex", + "mode": "100644", + "type": "blob", + "sha": "1f8bcffeda67031af4edb705ee3812e83afb9e84", + "size": 9152, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f8bcffeda67031af4edb705ee3812e83afb9e84" + }, + { + "path": "references/copied-fixed", + "mode": "040000", + "type": "tree", + "sha": "5d23f6cb669f232ad13b76cad355d3398a772957", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5d23f6cb669f232ad13b76cad355d3398a772957" + }, + { + "path": "references/copied-fixed/pr34", + "mode": "040000", + "type": "tree", + "sha": "a66a37c02399cfa69da0c18914ab76048a6d906d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/a66a37c02399cfa69da0c18914ab76048a6d906d" + }, + { + "path": "references/copied-fixed/pr34/ASSEMBLY_PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "8f4451b67fae34ab540eb16ad836a5ab50a8921d", + "size": 19391, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8f4451b67fae34ab540eb16ad836a5ab50a8921d" + }, + { + "path": "references/copied-fixed/pr34/downstream-semantic-bulk-assembly.md", + "mode": "100644", + "type": "blob", + "sha": "c9262e908a0ef014699d175f7bf427aed6469577", + "size": 7031, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c9262e908a0ef014699d175f7bf427aed6469577" + }, + { + "path": "references/copied-fixed/pr34/review-arbitrary-routing.md", + "mode": "100644", + "type": "blob", + "sha": "b0818f69e68174de819692d68bb6edc69254d491", + "size": 7639, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0818f69e68174de819692d68bb6edc69254d491" + }, + { + "path": "references/copied-fixed/pr34/review-balanced-transform.md", + "mode": "100644", + "type": "blob", + "sha": "5a173f4e62ee4ec1ee39aa5d7eefdd63a652e411", + "size": 10501, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5a173f4e62ee4ec1ee39aa5d7eefdd63a652e411" + }, + { + "path": "references/copied-fixed/pr34/review-bulk-resampling.md", + "mode": "100644", + "type": "blob", + "sha": "9731a03fdb7a1cecaddab737545befa238cb9ad3", + "size": 13666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9731a03fdb7a1cecaddab737545befa238cb9ad3" + }, + { + "path": "references/copied-fixed/pr35", + "mode": "040000", + "type": "tree", + "sha": "8819e09d4bdac7405f46203515d5a0ce9adfbe13", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8819e09d4bdac7405f46203515d5a0ce9adfbe13" + }, + { + "path": "references/copied-fixed/pr35/README.md", + "mode": "100644", + "type": "blob", + "sha": "016cd24d33bc4828def6c6136be0553e093393db", + "size": 2859, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/016cd24d33bc4828def6c6136be0553e093393db" + }, + { + "path": "references/copied-fixed/pr35/fixed-basis-two-stage.tex", + "mode": "100644", + "type": "blob", + "sha": "2c6677c8006bf096591996102dffb3c80d0be3f0", + "size": 13235, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c6677c8006bf096591996102dffb3c80d0be3f0" + }, + { + "path": "references/copied-fixed/pr35/producer.py", + "mode": "100644", + "type": "blob", + "sha": "24f73dfb183a9e395cddf8f2cf245d2c9e0b5c9c", + "size": 3115, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/24f73dfb183a9e395cddf8f2cf245d2c9e0b5c9c" + }, + { + "path": "references/copied-fixed/pr35/rankone_profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "28c6cf8aa9db9bd576b1adef94c744613baa95ef", + "size": 10476, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/28c6cf8aa9db9bd576b1adef94c744613baa95ef" + }, + { + "path": "references/copied-fixed/pr41", + "mode": "040000", + "type": "tree", + "sha": "7ccee0e986b68ea43feba609e024c1535cfa76d6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/7ccee0e986b68ea43feba609e024c1535cfa76d6" + }, + { + "path": "references/copied-fixed/pr41/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "53a4a0a6addee53183c034150e5800951c7c4669", + "size": 232, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/53a4a0a6addee53183c034150e5800951c7c4669" + }, + { + "path": "references/copied-fixed/pr41/check_compiled_witness.py", + "mode": "100644", + "type": "blob", + "sha": "7d66882f14d2af7710ea5a2b4c6e581c3fe340f1", + "size": 15644, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d66882f14d2af7710ea5a2b4c6e581c3fe340f1" + }, + { + "path": "references/copied-fixed/pr41/point_order_search.py", + "mode": "100644", + "type": "blob", + "sha": "a47df953d275f86bf3fcb100cc425ca8854875ca", + "size": 3418, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a47df953d275f86bf3fcb100cc425ca8854875ca" + }, + { + "path": "references/copied-fixed/pr41/producer_search.py", + "mode": "100644", + "type": "blob", + "sha": "f28f1b66d82fb6a4547e116aa0bdd8b8467d746d", + "size": 15963, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f28f1b66d82fb6a4547e116aa0bdd8b8467d746d" + }, + { + "path": "references/copied-fixed/pr44", + "mode": "040000", + "type": "tree", + "sha": "5e869fa4a6d4eb0b919b99aabacf91b8fc542e5a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5e869fa4a6d4eb0b919b99aabacf91b8fc542e5a" + }, + { + "path": "references/copied-fixed/pr44/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "c9c3b51109e0dc8a8307cd3e629d2ccfe32596ae", + "size": 2301, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c9c3b51109e0dc8a8307cd3e629d2ccfe32596ae" + }, + { + "path": "references/copied-fixed/pr44/optimal_graph.py", + "mode": "100644", + "type": "blob", + "sha": "d62880b919a20718089914d38d084a853564bde3", + "size": 1748, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d62880b919a20718089914d38d084a853564bde3" + }, + { + "path": "references/copied-fixed/pr44/optimize_matching.py", + "mode": "100644", + "type": "blob", + "sha": "4f9d35bda812a8e2bd0b16c1acea3428264f58d6", + "size": 3286, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4f9d35bda812a8e2bd0b16c1acea3428264f58d6" + }, + { + "path": "references/copied-fixed/pr44/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "243f0dbc4417c8395ae67fac0842d6d5b88300bc", + "size": 15014, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/243f0dbc4417c8395ae67fac0842d6d5b88300bc" + }, + { + "path": "references/frame-compiler", + "mode": "040000", + "type": "tree", + "sha": "553ade6eb93171276c1cc947e0a316be625d6af1", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/553ade6eb93171276c1cc947e0a316be625d6af1" + }, + { + "path": "references/frame-compiler/pr48", + "mode": "040000", + "type": "tree", + "sha": "9c07d4a9829b3ce857db339beca78bda11e244d9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9c07d4a9829b3ce857db339beca78bda11e244d9" + }, + { + "path": "references/frame-compiler/pr48/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "references/frame-compiler/pr48/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "a8474f5c31dd4f0b24232ae1d4a274405b5bb677", + "size": 8538, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8474f5c31dd4f0b24232ae1d4a274405b5bb677" + }, + { + "path": "references/frame-compiler/pr48/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "4e38e34dc8ed5ed54c3e4b60a88c3dc47308001f", + "size": 1245, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e38e34dc8ed5ed54c3e4b60a88c3dc47308001f" + }, + { + "path": "references/frame-compiler/pr48/research", + "mode": "040000", + "type": "tree", + "sha": "f4894855634ac64e4f280e7c7d269224b2a88730", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f4894855634ac64e4f280e7c7d269224b2a88730" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed", + "mode": "040000", + "type": "tree", + "sha": "731e9f7a858be7ce0519e3d187c2cb7a7797042b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/731e9f7a858be7ce0519e3d187c2cb7a7797042b" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "fa4b29c06df8e317c4074db4b8385622e9e27261", + "size": 308516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fa4b29c06df8e317c4074db4b8385622e9e27261" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed/changed_graph.py", + "mode": "100644", + "type": "blob", + "sha": "24070a7d858217c0e8b30a8102ecf6b84d0e1df9", + "size": 2457, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/24070a7d858217c0e8b30a8102ecf6b84d0e1df9" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "references/frame-compiler/pr48/research/copied-fixed/verify.py", + "mode": "100644", + "type": "blob", + "sha": "353de0374c868501f441e1c653b2c96b3bbfd2d2", + "size": 17580, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/353de0374c868501f441e1c653b2c96b3bbfd2d2" + }, + { + "path": "references/frame-compiler/pr48/scripts", + "mode": "040000", + "type": "tree", + "sha": "84db6ec1551b23e60d97dfb5205c4cc9dba85451", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/84db6ec1551b23e60d97dfb5205c4cc9dba85451" + }, + { + "path": "references/frame-compiler/pr48/scripts/exclusion_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "aaa99986c4b81c5d4fbe016fd216a4818940bb95", + "size": 8658, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aaa99986c4b81c5d4fbe016fd216a4818940bb95" + }, + { + "path": "references/frame-compiler/pr48/scripts/partial_swap", + "mode": "040000", + "type": "tree", + "sha": "5781bac819b02934597e367313b5fed789198768", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5781bac819b02934597e367313b5fed789198768" + }, + { + "path": "references/frame-compiler/pr48/scripts/partial_swap/binary_io.hpp", + "mode": "100644", + "type": "blob", + "sha": "9ec72c629aba3f62cecca996d91f09f859d987ba", + "size": 1678, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9ec72c629aba3f62cecca996d91f09f859d987ba" + }, + { + "path": "references/frame-compiler/pr48/scripts/partial_swap/paired.py", + "mode": "100644", + "type": "blob", + "sha": "b879293977c4705fdc47905cd6c58906161da3e7", + "size": 2608, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b879293977c4705fdc47905cd6c58906161da3e7" + }, + { + "path": "references/frame-compiler/pr48/scripts/partial_swap/shared.py", + "mode": "100644", + "type": "blob", + "sha": "a2f0190704db83bd8ef48e46e723c49b925804fe", + "size": 8442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a2f0190704db83bd8ef48e46e723c49b925804fe" + }, + { + "path": "references/frame-compiler/pr53", + "mode": "040000", + "type": "tree", + "sha": "1eb986eaaf6586b574e35266226220e4143c2cb2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1eb986eaaf6586b574e35266226220e4143c2cb2" + }, + { + "path": "references/frame-compiler/pr53/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "references/frame-compiler/pr53/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "0de764389c2dc4810e8ce2dcf17928ba6389d1f3", + "size": 9227, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0de764389c2dc4810e8ce2dcf17928ba6389d1f3" + }, + { + "path": "references/frame-compiler/pr53/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "1f439bee0e4d78228d74d610d8b177275f72f093", + "size": 1007, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f439bee0e4d78228d74d610d8b177275f72f093" + }, + { + "path": "references/frame-compiler/pr53/research", + "mode": "040000", + "type": "tree", + "sha": "e5b5c0eb6030b71241938791cb220e6f212a69c9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e5b5c0eb6030b71241938791cb220e6f212a69c9" + }, + { + "path": "references/frame-compiler/pr53/research/skip-strips", + "mode": "040000", + "type": "tree", + "sha": "2da2dfacb8ed84e60d45da0b3c2b14897e2d1908", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2da2dfacb8ed84e60d45da0b3c2b14897e2d1908" + }, + { + "path": "references/frame-compiler/pr53/research/skip-strips/skip_graph.py", + "mode": "100644", + "type": "blob", + "sha": "e3ff56e33d5af7bd30878a538a77f6a0821192c5", + "size": 7644, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e3ff56e33d5af7bd30878a538a77f6a0821192c5" + }, + { + "path": "references/frame-compiler/pr55", + "mode": "040000", + "type": "tree", + "sha": "2f7deaacd5673bd646f73b112e8be790cc58c504", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2f7deaacd5673bd646f73b112e8be790cc58c504" + }, + { + "path": "references/frame-compiler/pr55/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "references/frame-compiler/pr55/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "0de764389c2dc4810e8ce2dcf17928ba6389d1f3", + "size": 9227, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0de764389c2dc4810e8ce2dcf17928ba6389d1f3" + }, + { + "path": "references/frame-compiler/pr55/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "df428041138a24f83443f461d73e256425775959", + "size": 657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/df428041138a24f83443f461d73e256425775959" + }, + { + "path": "references/frame-compiler/pr55/research", + "mode": "040000", + "type": "tree", + "sha": "8ef2dcc6480f780eeebf196a693efbba87cd0430", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8ef2dcc6480f780eeebf196a693efbba87cd0430" + }, + { + "path": "references/frame-compiler/pr55/research/skip-suffix", + "mode": "040000", + "type": "tree", + "sha": "6333a5a7d6696651e54adc89feec7210783594d7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6333a5a7d6696651e54adc89feec7210783594d7" + }, + { + "path": "references/frame-compiler/pr55/research/skip-suffix/skip_graph.py", + "mode": "100644", + "type": "blob", + "sha": "6cdd455ee9a49c0309f1924d26440c6a0b0bdeb6", + "size": 8159, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6cdd455ee9a49c0309f1924d26440c6a0b0bdeb6" + }, + { + "path": "references/frame-compiler/pr58", + "mode": "040000", + "type": "tree", + "sha": "15d52af6c0ab4296d7df0e4f057fb7ad1084d75e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/15d52af6c0ab4296d7df0e4f057fb7ad1084d75e" + }, + { + "path": "references/frame-compiler/pr58/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "references/frame-compiler/pr58/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "52603d713fe0b407d461b959e10aa8b6736926e5", + "size": 13701, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/52603d713fe0b407d461b959e10aa8b6736926e5" + }, + { + "path": "references/frame-compiler/pr58/README.md", + "mode": "100644", + "type": "blob", + "sha": "68886ac104198219acaa839c790192c42b27acf0", + "size": 11131, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68886ac104198219acaa839c790192c42b27acf0" + }, + { + "path": "references/frame-compiler/pr58/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "675441039201c522cb4f60142041c1887eb6a7c3", + "size": 1394, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/675441039201c522cb4f60142041c1887eb6a7c3" + }, + { + "path": "references/frame-compiler/pr58/certificates", + "mode": "040000", + "type": "tree", + "sha": "701c39c0806bc392ad51156f0c4225f1d560e1af", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/701c39c0806bc392ad51156f0c4225f1d560e1af" + }, + { + "path": "references/frame-compiler/pr58/certificates/joint-dual-kappa.json", + "mode": "100644", + "type": "blob", + "sha": "c095bb93ad34a4f2a9391691a4b13684c4e97ee8", + "size": 35627, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c095bb93ad34a4f2a9391691a4b13684c4e97ee8" + }, + { + "path": "references/frame-compiler/pr58/certificates/joint-dual-repository-validation.json", + "mode": "100644", + "type": "blob", + "sha": "ce691032fee82a377d01b42fc1780817ec05cfda", + "size": 7277, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ce691032fee82a377d01b42fc1780817ec05cfda" + }, + { + "path": "references/frame-compiler/pr58/research", + "mode": "040000", + "type": "tree", + "sha": "c4d4ddcdf2f9b33d8f6d794670252cd1fe42800e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c4d4ddcdf2f9b33d8f6d794670252cd1fe42800e" + }, + { + "path": "references/frame-compiler/pr58/research/joint-dual", + "mode": "040000", + "type": "tree", + "sha": "e8f9bef2415589f81af021c5cbbd3d511ebe9709", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e8f9bef2415589f81af021c5cbbd3d511ebe9709" + }, + { + "path": "references/frame-compiler/pr58/research/joint-dual/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "c7ad3db4a8af95dfeb6e322b91aa3eb49a63ef17", + "size": 12950, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7ad3db4a8af95dfeb6e322b91aa3eb49a63ef17" + }, + { + "path": "references/frame-compiler/pr58/research/joint-dual/README.md", + "mode": "100644", + "type": "blob", + "sha": "02406b0b503acbe5df063e372dd03782ab51d40b", + "size": 2492, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/02406b0b503acbe5df063e372dd03782ab51d40b" + }, + { + "path": "references/frame-compiler/pr58/research/joint-dual/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "6102a46f5c8aed4123c035626df3f34585e85e74", + "size": 5157, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6102a46f5c8aed4123c035626df3f34585e85e74" + }, + { + "path": "references/semantic-bulk", + "mode": "040000", + "type": "tree", + "sha": "e0094004f80f506f74e611dc68c0fc4e7e2150af", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e0094004f80f506f74e611dc68c0fc4e7e2150af" + }, + { + "path": "references/semantic-bulk/MANIFEST.json", + "mode": "100644", + "type": "blob", + "sha": "983e06d3e2badc3bfcfd54875054f935e344e416", + "size": 2193, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/983e06d3e2badc3bfcfd54875054f935e344e416" + }, + { + "path": "references/semantic-bulk/README.md", + "mode": "100644", + "type": "blob", + "sha": "528a9d85a751f273391ff5bb1e3a0b72f42e7dbe", + "size": 1638, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/528a9d85a751f273391ff5bb1e3a0b72f42e7dbe" + }, + { + "path": "references/semantic-bulk/pr21", + "mode": "040000", + "type": "tree", + "sha": "41a5d77265d7af867540c7d017fe3839522691d2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/41a5d77265d7af867540c7d017fe3839522691d2" + }, + { + "path": "references/semantic-bulk/pr21/translated-partial-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "1b8fb4196372c5322da8fd8d907209b248795d7b", + "size": 11229, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b8fb4196372c5322da8fd8d907209b248795d7b" + }, + { + "path": "references/semantic-bulk/pr23", + "mode": "040000", + "type": "tree", + "sha": "a790a9fbb81e5dea80b8a2e91538694e5957dc50", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/a790a9fbb81e5dea80b8a2e91538694e5957dc50" + }, + { + "path": "references/semantic-bulk/pr23/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "references/semantic-bulk/pr23/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "3b3d519cac5fc7e0ddc0383619940e968a69fb25", + "size": 6030, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3b3d519cac5fc7e0ddc0383619940e968a69fb25" + }, + { + "path": "references/semantic-bulk/pr23/SOURCES.json", + "mode": "100644", + "type": "blob", + "sha": "815d784be5c30224f9fd3791b567066b7d074cd9", + "size": 6259, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/815d784be5c30224f9fd3791b567066b7d074cd9" + }, + { + "path": "references/semantic-bulk/pr23/semantic-bulk-17-note.tex", + "mode": "100644", + "type": "blob", + "sha": "abd5e0f2cea9de2a09bc0bfee844224ab3155520", + "size": 18648, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/abd5e0f2cea9de2a09bc0bfee844224ab3155520" + }, + { + "path": "references/semantic-bulk/rad20", + "mode": "040000", + "type": "tree", + "sha": "db1289b7df20e1f4207136a4743b9c35d306ba1e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/db1289b7df20e1f4207136a4743b9c35d306ba1e" + }, + { + "path": "references/semantic-bulk/rad20/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "0e259d42c996742e9e3cba14c677129b2c1b6311", + "size": 7048, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e259d42c996742e9e3cba14c677129b2c1b6311" + }, + { + "path": "references/semantic-bulk/rad20/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "544634f5f3001c50330413f22dc0070e07c46738", + "size": 1470, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/544634f5f3001c50330413f22dc0070e07c46738" + }, + { + "path": "references/semantic-bulk/rad20/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "f19aa02a1d430ab30133727ddee5f6686b49ac37", + "size": 3994, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f19aa02a1d430ab30133727ddee5f6686b49ac37" + }, + { + "path": "references/semantic-bulk/rad20/code", + "mode": "040000", + "type": "tree", + "sha": "9656bb66f437f31d047e2485ed2d3314b85e5971", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9656bb66f437f31d047e2485ed2d3314b85e5971" + }, + { + "path": "references/semantic-bulk/rad20/code/compact_arbitrary_source_routing.py", + "mode": "100644", + "type": "blob", + "sha": "3cfd5b0041ffdf8ccdcf4b35080d1807503e6a1c", + "size": 14169, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3cfd5b0041ffdf8ccdcf4b35080d1807503e6a1c" + }, + { + "path": "references/semantic-bulk/rad20/code/downstream_banded_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "b1796a5b814300457e5bd752d673ec3631dc4131", + "size": 16936, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b1796a5b814300457e5bd752d673ec3631dc4131" + }, + { + "path": "references/semantic-bulk/rad20/code/downstream_blocked_gaussian.py", + "mode": "100644", + "type": "blob", + "sha": "4e1066f40ab6fb8c40a397f197749b6c41118429", + "size": 13659, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e1066f40ab6fb8c40a397f197749b6c41118429" + }, + { + "path": "references/semantic-bulk/rad20/code/downstream_gaussian.py", + "mode": "100644", + "type": "blob", + "sha": "47cde303f319d24a08a7a226aee13a3eb2347ea5", + "size": 12665, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/47cde303f319d24a08a7a226aee13a3eb2347ea5" + }, + { + "path": "references/semantic-bulk/rad20/code/downstream_phase_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "10a00978537d4eab0280eb61d2592fcefbd3f170", + "size": 15139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/10a00978537d4eab0280eb61d2592fcefbd3f170" + }, + { + "path": "references/semantic-bulk/rad20/code/review_arbitrary_routing.py", + "mode": "100644", + "type": "blob", + "sha": "901392cc204f48d9704bfe9be7a2049a44b5226f", + "size": 15346, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/901392cc204f48d9704bfe9be7a2049a44b5226f" + }, + { + "path": "references/semantic-bulk/rad20/code/review_balanced_transform.py", + "mode": "100644", + "type": "blob", + "sha": "5b37d2770fa716250892b162eaaa860933511128", + "size": 5788, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5b37d2770fa716250892b162eaaa860933511128" + }, + { + "path": "references/semantic-bulk/rad20/code/review_banded_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "b470d17592d7fc2edff0f476171b0e0e5003a0f4", + "size": 8310, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b470d17592d7fc2edff0f476171b0e0e5003a0f4" + }, + { + "path": "references/semantic-bulk/rad20/code/review_bulk_boundary_negatives.py", + "mode": "100644", + "type": "blob", + "sha": "32d94251f808f0e7a94d757d70671c3d91fb15ff", + "size": 4391, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32d94251f808f0e7a94d757d70671c3d91fb15ff" + }, + { + "path": "references/semantic-bulk/rad20/code/review_bulk_resampling.py", + "mode": "100644", + "type": "blob", + "sha": "b85caf1ed8d74da0508d83fe4ec4fa09857585d8", + "size": 20921, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b85caf1ed8d74da0508d83fe4ec4fa09857585d8" + }, + { + "path": "references/semantic-bulk/rad20/code/review_phase_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "3140a7ba56385bd95a137087ab95c697f825aa6a", + "size": 11959, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3140a7ba56385bd95a137087ab95c697f825aa6a" + }, + { + "path": "references/semantic-bulk/rad20/code/review_semantic_guard.py", + "mode": "100644", + "type": "blob", + "sha": "31c6a46a52df4d379bea582b935b2e7214d82491", + "size": 12680, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31c6a46a52df4d379bea582b935b2e7214d82491" + }, + { + "path": "references/semantic-bulk/rad20/code/review_whole_complex_transfer.py", + "mode": "100644", + "type": "blob", + "sha": "444f70cfbae45fc0d73d2c9f933bf1ed91bf603d", + "size": 6243, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/444f70cfbae45fc0d73d2c9f933bf1ed91bf603d" + }, + { + "path": "references/semantic-bulk/rad20/reports", + "mode": "040000", + "type": "tree", + "sha": "bb8f026697634957cd747a72c034a2fcc447f78f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/bb8f026697634957cd747a72c034a2fcc447f78f" + }, + { + "path": "references/semantic-bulk/rad20/reports/bulk-resampling-tape-transfer.md", + "mode": "100644", + "type": "blob", + "sha": "7141f84808633e22760e6ca760302ec153f3770a", + "size": 11364, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7141f84808633e22760e6ca760302ec153f3770a" + }, + { + "path": "references/semantic-bulk/rad20/reports/compact-arbitrary-source-routing.md", + "mode": "100644", + "type": "blob", + "sha": "366f97407b6c8c46f1263c2bbcf2a46be5f40de7", + "size": 10684, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/366f97407b6c8c46f1263c2bbcf2a46be5f40de7" + }, + { + "path": "references/semantic-bulk/rad20/reports/downstream-microbox-resampling.md", + "mode": "100644", + "type": "blob", + "sha": "27f962de34b6943aee33cc0d40b8c7883ccf56f2", + "size": 15468, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/27f962de34b6943aee33cc0d40b8c7883ccf56f2" + }, + { + "path": "references/semantic-bulk/rad20/reports/downstream-phase-cell-inverse.md", + "mode": "100644", + "type": "blob", + "sha": "d72345a0aa748443c4efcddf87aa10d524664841", + "size": 23129, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d72345a0aa748443c4efcddf87aa10d524664841" + }, + { + "path": "references/semantic-bulk/rad20/reports/downstream-semantic-bulk-assembly.md", + "mode": "100644", + "type": "blob", + "sha": "c9262e908a0ef014699d175f7bf427aed6469577", + "size": 7031, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c9262e908a0ef014699d175f7bf427aed6469577" + }, + { + "path": "references/semantic-bulk/rad20/reports/downstream-semantic-child-guard.md", + "mode": "100644", + "type": "blob", + "sha": "970927dcf8e26447fe95be2edda6f20087dcba15", + "size": 8245, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/970927dcf8e26447fe95be2edda6f20087dcba15" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-arbitrary-routing.md", + "mode": "100644", + "type": "blob", + "sha": "b0818f69e68174de819692d68bb6edc69254d491", + "size": 7639, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0818f69e68174de819692d68bb6edc69254d491" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-balanced-transform.md", + "mode": "100644", + "type": "blob", + "sha": "5a173f4e62ee4ec1ee39aa5d7eefdd63a652e411", + "size": 10501, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5a173f4e62ee4ec1ee39aa5d7eefdd63a652e411" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-bulk-resampling.md", + "mode": "100644", + "type": "blob", + "sha": "9731a03fdb7a1cecaddab737545befa238cb9ad3", + "size": 13666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9731a03fdb7a1cecaddab737545befa238cb9ad3" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-closing-handoff.md", + "mode": "100644", + "type": "blob", + "sha": "bfdb58b76fc38fb468ae8240d5d298f69331f40e", + "size": 4239, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bfdb58b76fc38fb468ae8240d5d298f69331f40e" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-compact-controls.md", + "mode": "100644", + "type": "blob", + "sha": "78b50c3fd1d3f45c2854cca2a4f2431627ff7be5", + "size": 12023, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/78b50c3fd1d3f45c2854cca2a4f2431627ff7be5" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-phase-cell-inverse.md", + "mode": "100644", + "type": "blob", + "sha": "395eab8ee1d58e84353f554dcfe9473b5913dda5", + "size": 16576, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/395eab8ee1d58e84353f554dcfe9473b5913dda5" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-reusable-banded-inverse.md", + "mode": "100644", + "type": "blob", + "sha": "de7a916369cc36737fd96b9b0172e2ef453c6b03", + "size": 11235, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de7a916369cc36737fd96b9b0172e2ef453c6b03" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-semantic-child-guard.md", + "mode": "100644", + "type": "blob", + "sha": "a12a6dca1758bee3855834c0c60b17e1d00ec718", + "size": 8344, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a12a6dca1758bee3855834c0c60b17e1d00ec718" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-whole-complex-transfer.md", + "mode": "100644", + "type": "blob", + "sha": "1d2ee312bc6618c7eb2479ae27544edf64e31c20", + "size": 18800, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d2ee312bc6618c7eb2479ae27544edf64e31c20" + }, + { + "path": "references/semantic-bulk/rad20/reports/whole-complex-concatenation.md", + "mode": "100644", + "type": "blob", + "sha": "5d5af6796ad3cb1367da1aae52becfa4f580bf80", + "size": 11385, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d5af6796ad3cb1367da1aae52becfa4f580bf80" + }, + { + "path": "references/semantic-bulk/rad20/reports/whole-complex-prefix-and-wrapper-qualification.md", + "mode": "100644", + "type": "blob", + "sha": "b2702b6fc0624ab276b27be3db2a32d30e26478d", + "size": 3815, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b2702b6fc0624ab276b27be3db2a32d30e26478d" + }, + { + "path": "research", + "mode": "040000", + "type": "tree", + "sha": "6ff463e2bb12fd006d0084d4ec926fed1cc75c46", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6ff463e2bb12fd006d0084d4ec926fed1cc75c46" + }, + { + "path": "research/climbed-48", + "mode": "040000", + "type": "tree", + "sha": "210e7a0857c9ba4183511b72f8b3ccbce5e0f2f6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/210e7a0857c9ba4183511b72f8b3ccbce5e0f2f6" + }, + { + "path": "research/climbed-48/README.md", + "mode": "100644", + "type": "blob", + "sha": "0a73d50f3a2340e266b351bbe24aa67d80ac7c10", + "size": 3212, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0a73d50f3a2340e266b351bbe24aa67d80ac7c10" + }, + { + "path": "research/climbed-48/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "828b07431b3e000e5b4dc956dc189e1d4444d65c", + "size": 2488, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/828b07431b3e000e5b4dc956dc189e1d4444d65c" + }, + { + "path": "research/climbed-48/bits-23.json", + "mode": "100644", + "type": "blob", + "sha": "96529e3e008aef45563273a34d99e583ef854573", + "size": 5010, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/96529e3e008aef45563273a34d99e583ef854573" + }, + { + "path": "research/climbed-48/bits-25.json", + "mode": "100644", + "type": "blob", + "sha": "45c54149be9a924679f293746f369b1f26985fc7", + "size": 5959, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/45c54149be9a924679f293746f369b1f26985fc7" + }, + { + "path": "research/climbed-48/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "92dc457a500c3e3df1910012436bf2d0f0ba6dc3", + "size": 39540, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/92dc457a500c3e3df1910012436bf2d0f0ba6dc3" + }, + { + "path": "research/climbed-48/climbed_graph.py", + "mode": "100644", + "type": "blob", + "sha": "3a5bc3ed255f8852e0f962b85e7110e1bd324e58", + "size": 3339, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a5bc3ed255f8852e0f962b85e7110e1bd324e58" + }, + { + "path": "research/climbed-48/comparison-pr48.json", + "mode": "100644", + "type": "blob", + "sha": "afd9b5bdac4dbc2d6759f06073e583d874c87c72", + "size": 687, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/afd9b5bdac4dbc2d6759f06073e583d874c87c72" + }, + { + "path": "research/climbed-48/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "1d3cfe2d9d872ec7b45d179ad12a3bad651b5186", + "size": 48624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d3cfe2d9d872ec7b45d179ad12a3bad651b5186" + }, + { + "path": "research/climbed-48/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "806faddc50d44142f5d249641c4ec5a8b89102fc", + "size": 62480, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/806faddc50d44142f5d249641c4ec5a8b89102fc" + }, + { + "path": "research/climbed-48/optimize_matching.py", + "mode": "100644", + "type": "blob", + "sha": "9f791957d2a2e4be8d9305db22fd67dc14115199", + "size": 3319, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9f791957d2a2e4be8d9305db22fd67dc14115199" + }, + { + "path": "research/climbed-48/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "c5df4bebef9b8e0ecfcf1b12103adb8bf6005acc", + "size": 431, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c5df4bebef9b8e0ecfcf1b12103adb8bf6005acc" + }, + { + "path": "research/climbed-48/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "3ff68d6ad02d72da7809ae719850e8cbfe1bde8c", + "size": 456, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3ff68d6ad02d72da7809ae719850e8cbfe1bde8c" + }, + { + "path": "research/climbed-48/producer.py", + "mode": "100644", + "type": "blob", + "sha": "6d82b18bb82ed3709a6c40a674cf4d7c2fd09ffd", + "size": 5324, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6d82b18bb82ed3709a6c40a674cf4d7c2fd09ffd" + }, + { + "path": "research/climbed-48/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "d599a5a12493c80d6eb9c324593c4d30a213047c", + "size": 459, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d599a5a12493c80d6eb9c324593c4d30a213047c" + }, + { + "path": "research/climbed-48/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "3a7f995812a2f821433784c4ccf959ea7c2c6ddb", + "size": 484, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a7f995812a2f821433784c4ccf959ea7c2c6ddb" + }, + { + "path": "research/climbed-48/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "243f0dbc4417c8395ae67fac0842d6d5b88300bc", + "size": 15014, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/243f0dbc4417c8395ae67fac0842d6d5b88300bc" + }, + { + "path": "research/climbed-48/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "e551b7db6cc46b29b87913bfbac7ed6dd60d8637", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e551b7db6cc46b29b87913bfbac7ed6dd60d8637" + }, + { + "path": "research/climbed-48/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "9405ff429c2c31c3843f79ce6b0dd46b75754636", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9405ff429c2c31c3843f79ce6b0dd46b75754636" + }, + { + "path": "research/climbed-48/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "c444dc2c31d96705a3b49bacccd475b085ba43fd", + "size": 1311, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c444dc2c31d96705a3b49bacccd475b085ba43fd" + }, + { + "path": "research/climbed-48/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "50339e06f305979a12f150dd08cdfdca39710a3a", + "size": 1336, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50339e06f305979a12f150dd08cdfdca39710a3a" + }, + { + "path": "research/climbed-48/validation.json", + "mode": "100644", + "type": "blob", + "sha": "a93594b1c728216910f9d379e0a9f32158ff1035", + "size": 1229, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a93594b1c728216910f9d379e0a9f32158ff1035" + }, + { + "path": "research/climbed-48/witness.py", + "mode": "100644", + "type": "blob", + "sha": "85bef6467e464b23301c6c97ddd80afc890d3ffc", + "size": 7160, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/85bef6467e464b23301c6c97ddd80afc890d3ffc" + }, + { + "path": "research/copied-fixed-reversed", + "mode": "040000", + "type": "tree", + "sha": "719a4e7ba499fdf4e2b33bab0f0448871ea45c84", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/719a4e7ba499fdf4e2b33bab0f0448871ea45c84" + }, + { + "path": "research/copied-fixed-reversed/README.md", + "mode": "100644", + "type": "blob", + "sha": "f91f7874092cda89edda9e8ae961f342eb07db76", + "size": 6640, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f91f7874092cda89edda9e8ae961f342eb07db76" + }, + { + "path": "research/copied-fixed-reversed/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "c8054ee11a4641dea3a0b47ed5bf03ca0468843d", + "size": 3041, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8054ee11a4641dea3a0b47ed5bf03ca0468843d" + }, + { + "path": "research/copied-fixed-reversed/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/copied-fixed-reversed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "fb77d6d7ce346710caceb5d53c353fe0438159de", + "size": 46318, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fb77d6d7ce346710caceb5d53c353fe0438159de" + }, + { + "path": "research/copied-fixed-reversed/full_profiles25.cpp", + "mode": "100644", + "type": "blob", + "sha": "108dfe4344eee8b143c611a5f1528e890342fbed", + "size": 10570, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/108dfe4344eee8b143c611a5f1528e890342fbed" + }, + { + "path": "research/copied-fixed-reversed/geometry-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "c54d6b70c4babad90abfedcc3e49c228c3cf35ad", + "size": 179470, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c54d6b70c4babad90abfedcc3e49c228c3cf35ad" + }, + { + "path": "research/copied-fixed-reversed/geometry-proof.txt", + "mode": "100644", + "type": "blob", + "sha": "3fa4735a90b0255a3135d2f1d8f61961d09cc002", + "size": 9103, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3fa4735a90b0255a3135d2f1d8f61961d09cc002" + }, + { + "path": "research/copied-fixed-reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "5834c1f5b8e125c671eb402ca0d5b5cbfd216a51", + "size": 1483, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5834c1f5b8e125c671eb402ca0d5b5cbfd216a51" + }, + { + "path": "research/copied-fixed-reversed/geometry.cpp", + "mode": "100644", + "type": "blob", + "sha": "b705afe00a489a54c5b9aec71841b1479ef28633", + "size": 2192, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b705afe00a489a54c5b9aec71841b1479ef28633" + }, + { + "path": "research/copied-fixed-reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "560a51737fa827f48599677386e35f1bb9b0f85c", + "size": 6195, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/560a51737fa827f48599677386e35f1bb9b0f85c" + }, + { + "path": "research/copied-fixed-reversed/label-input-25.json", + "mode": "100644", + "type": "blob", + "sha": "0dd939fdb2bac78266b1821ab4646013338826d1", + "size": 158, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0dd939fdb2bac78266b1821ab4646013338826d1" + }, + { + "path": "research/copied-fixed-reversed/label_audit.cpp", + "mode": "100644", + "type": "blob", + "sha": "26c659797cf76cdfd343ac344b107e4a7c4a46f1", + "size": 2850, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/26c659797cf76cdfd343ac344b107e4a7c4a46f1" + }, + { + "path": "research/copied-fixed-reversed/producer-input-25.json", + "mode": "100644", + "type": "blob", + "sha": "c4ab396624ff7191ec7cf3a784bd1b243308e3a0", + "size": 1577, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c4ab396624ff7191ec7cf3a784bd1b243308e3a0" + }, + { + "path": "research/copied-fixed-reversed/producer-source.json", + "mode": "100644", + "type": "blob", + "sha": "2533b07dcfb1832b1c09076ee26eba4270da5667", + "size": 1991, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2533b07dcfb1832b1c09076ee26eba4270da5667" + }, + { + "path": "research/copied-fixed-reversed/producer.py", + "mode": "100644", + "type": "blob", + "sha": "f891bb2f7ba1363fc5b46ce02aedeeb5f858425e", + "size": 4117, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f891bb2f7ba1363fc5b46ce02aedeeb5f858425e" + }, + { + "path": "research/copied-fixed-reversed/profile-25.json", + "mode": "100644", + "type": "blob", + "sha": "f5c4d92198a50e6cc6df7e977af48d768c4a0185", + "size": 310, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f5c4d92198a50e6cc6df7e977af48d768c4a0185" + }, + { + "path": "research/copied-fixed-reversed/review", + "mode": "040000", + "type": "tree", + "sha": "d8d83475b9342e07dbc55baa02a3000693c20992", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/d8d83475b9342e07dbc55baa02a3000693c20992" + }, + { + "path": "research/copied-fixed-reversed/review/fixed25-copied-crt-audit.json", + "mode": "100644", + "type": "blob", + "sha": "f2f481e56fd46cef6fef4afe9f62c11bd31ab3ee", + "size": 2999, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2f481e56fd46cef6fef4afe9f62c11bd31ab3ee" + }, + { + "path": "research/copied-fixed-reversed/review/fixed25-copied-crt-audit.txt", + "mode": "100644", + "type": "blob", + "sha": "fbbdfb3b97a3aab0509450afca76c8f25d200bf4", + "size": 11966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fbbdfb3b97a3aab0509450afca76c8f25d200bf4" + }, + { + "path": "research/copied-fixed-reversed/review/fixed25-copied-crt-portable-replay.json", + "mode": "100644", + "type": "blob", + "sha": "9596a8535fa461e6304984d3f74d2baa6df8d762", + "size": 2643, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9596a8535fa461e6304984d3f74d2baa6df8d762" + }, + { + "path": "research/copied-fixed-reversed/review/fixed25_copied_crt_audit.py", + "mode": "100644", + "type": "blob", + "sha": "dafe0ea1dbadab8452b11122ee783975d034a4fb", + "size": 7942, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dafe0ea1dbadab8452b11122ee783975d034a4fb" + }, + { + "path": "research/copied-fixed-reversed/validation.json", + "mode": "100644", + "type": "blob", + "sha": "add611df30b409c7d5adb532ff78455d54218ee9", + "size": 1393, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/add611df30b409c7d5adb532ff78455d54218ee9" + }, + { + "path": "research/copied-fixed-reversed/witness.py", + "mode": "100644", + "type": "blob", + "sha": "c5ac74fcec8ae5b9c4d03a1f24513cfcb3ac84ef", + "size": 6060, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c5ac74fcec8ae5b9c4d03a1f24513cfcb3ac84ef" + }, + { + "path": "research/copied-fixed", + "mode": "040000", + "type": "tree", + "sha": "e82f93b7b144f515d52b00a8d4dacda26929b5eb", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e82f93b7b144f515d52b00a8d4dacda26929b5eb" + }, + { + "path": "research/copied-fixed/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "ffbde841bd0f0c10945125137c3eb53cedc240df", + "size": 23111, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ffbde841bd0f0c10945125137c3eb53cedc240df" + }, + { + "path": "research/copied-fixed/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "b77220424f366a4bda2103c193e426e3877ffc5f", + "size": 9426, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b77220424f366a4bda2103c193e426e3877ffc5f" + }, + { + "path": "research/copied-fixed/audit.py", + "mode": "100644", + "type": "blob", + "sha": "34d4990f66af048a3092af24b1b9dd2fef60fd9f", + "size": 3826, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34d4990f66af048a3092af24b1b9dd2fef60fd9f" + }, + { + "path": "research/copied-fixed/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/copied-fixed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "28e29d9982b0c67a34976df17f6c403be264d7e3", + "size": 308516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/28e29d9982b0c67a34976df17f6c403be264d7e3" + }, + { + "path": "research/copied-fixed/changed_graph.py", + "mode": "100644", + "type": "blob", + "sha": "24070a7d858217c0e8b30a8102ecf6b84d0e1df9", + "size": 2457, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/24070a7d858217c0e8b30a8102ecf6b84d0e1df9" + }, + { + "path": "research/copied-fixed/comparison-pr40.json", + "mode": "100644", + "type": "blob", + "sha": "e0b14fb24396c741a3bf2f183db4c6f2cb0acab3", + "size": 786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0b14fb24396c741a3bf2f183db4c6f2cb0acab3" + }, + { + "path": "research/copied-fixed/comparison-pr41.json", + "mode": "100644", + "type": "blob", + "sha": "f2968fb1dda682090d1a3d2bc9ad86ad13aac71f", + "size": 718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2968fb1dda682090d1a3d2bc9ad86ad13aac71f" + }, + { + "path": "research/copied-fixed/comparison-pr42.json", + "mode": "100644", + "type": "blob", + "sha": "3f4378580e90fdd1e9b92b847dd60ba22afc288e", + "size": 796, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f4378580e90fdd1e9b92b847dd60ba22afc288e" + }, + { + "path": "research/copied-fixed/comparison-pr43.json", + "mode": "100644", + "type": "blob", + "sha": "503e4a74ce26a3af808f629fd5fe6b82746e8ee8", + "size": 848, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/503e4a74ce26a3af808f629fd5fe6b82746e8ee8" + }, + { + "path": "research/copied-fixed/comparison-pr44.json", + "mode": "100644", + "type": "blob", + "sha": "9c0c416158790e5d417e4d9c93e13bcf3f120e07", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c0c416158790e5d417e4d9c93e13bcf3f120e07" + }, + { + "path": "research/copied-fixed/comparison-pr46.json", + "mode": "100644", + "type": "blob", + "sha": "427983e2e07e13a44977b043973b2d4ec93ddf72", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/427983e2e07e13a44977b043973b2d4ec93ddf72" + }, + { + "path": "research/copied-fixed/comparison-pr47.json", + "mode": "100644", + "type": "blob", + "sha": "bc387e8d37e34152043a9f79192c8e35a4d67728", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc387e8d37e34152043a9f79192c8e35a4d67728" + }, + { + "path": "research/copied-fixed/data-corners.json", + "mode": "100644", + "type": "blob", + "sha": "4cb7a2b26fc48afd020b7966c43fd30cf2321514", + "size": 40579, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cb7a2b26fc48afd020b7966c43fd30cf2321514" + }, + { + "path": "research/copied-fixed/data_corners.cpp", + "mode": "100644", + "type": "blob", + "sha": "251f6c87cca42619a0c1b6d83705df5cad0e9c33", + "size": 3295, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/251f6c87cca42619a0c1b6d83705df5cad0e9c33" + }, + { + "path": "research/copied-fixed/data_recovery.py", + "mode": "100644", + "type": "blob", + "sha": "38972cab7e1fda608c3898fc9f2f578bf253211a", + "size": 2272, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38972cab7e1fda608c3898fc9f2f578bf253211a" + }, + { + "path": "research/copied-fixed/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "93549c5a3cd5d0191ff19cf230a6dcbef6f0913c", + "size": 48024, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/93549c5a3cd5d0191ff19cf230a6dcbef6f0913c" + }, + { + "path": "research/copied-fixed/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "32b2a746185b155c9d929974b5b64c6b9066bd94", + "size": 61728, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32b2a746185b155c9d929974b5b64c6b9066bd94" + }, + { + "path": "research/copied-fixed/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "5c4298a2682cb61919774563af4b3b55279eda07", + "size": 431, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5c4298a2682cb61919774563af4b3b55279eda07" + }, + { + "path": "research/copied-fixed/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "6c57f1647d55391a3dd1e4ab1e95baa804ffdc3b", + "size": 456, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c57f1647d55391a3dd1e4ab1e95baa804ffdc3b" + }, + { + "path": "research/copied-fixed/original_timeline.py", + "mode": "100644", + "type": "blob", + "sha": "0fb348896edac82a6ac3e682d611049cb8488ff1", + "size": 14542, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb348896edac82a6ac3e682d611049cb8488ff1" + }, + { + "path": "research/copied-fixed/producer.py", + "mode": "100644", + "type": "blob", + "sha": "a37b78a5fcb165a0cd78be896d4970b104cfda51", + "size": 9443, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a37b78a5fcb165a0cd78be896d4970b104cfda51" + }, + { + "path": "research/copied-fixed/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "0f8eef34a8e719ff19a2504dd3e988780ff26e54", + "size": 459, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0f8eef34a8e719ff19a2504dd3e988780ff26e54" + }, + { + "path": "research/copied-fixed/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "7adbd345d898d603b7dcd6012a853db122677f68", + "size": 484, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7adbd345d898d603b7dcd6012a853db122677f68" + }, + { + "path": "research/copied-fixed/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/copied-fixed/reversed", + "mode": "040000", + "type": "tree", + "sha": "850c2bf5dbc76dde06b74712be69ecbc72059b33", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/850c2bf5dbc76dde06b74712be69ecbc72059b33" + }, + { + "path": "research/copied-fixed/reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "618912ee497c053e7d891c6b7f07c5517edeae71", + "size": 805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/618912ee497c053e7d891c6b7f07c5517edeae71" + }, + { + "path": "research/copied-fixed/reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "7ad54118609fb8eebbb329d8862c8c899039a93b", + "size": 4689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ad54118609fb8eebbb329d8862c8c899039a93b" + }, + { + "path": "research/copied-fixed/reversed/pr34", + "mode": "040000", + "type": "tree", + "sha": "80c5b3126c18d39bb78836a93317f97869427acf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/80c5b3126c18d39bb78836a93317f97869427acf" + }, + { + "path": "research/copied-fixed/reversed/pr34/certify_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "e7367cb24862b7f416c4f36181b6d383ba53bb7c", + "size": 5526, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7367cb24862b7f416c4f36181b6d383ba53bb7c" + }, + { + "path": "research/copied-fixed/reversed/pr34/independent_controls.py", + "mode": "100644", + "type": "blob", + "sha": "d5578d5c51081ca922c1a4f3dc320253c011afe6", + "size": 5610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d5578d5c51081ca922c1a4f3dc320253c011afe6" + }, + { + "path": "research/copied-fixed/review", + "mode": "040000", + "type": "tree", + "sha": "f147869cd25c1b6c2f75308c69c4b74be0268c63", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f147869cd25c1b6c2f75308c69c4b74be0268c63" + }, + { + "path": "research/copied-fixed/review/pr34-balanced-assembly-audit.txt", + "mode": "100644", + "type": "blob", + "sha": "898ca600ef369f561b22eabeaa897758844ad4fe", + "size": 6765, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/898ca600ef369f561b22eabeaa897758844ad4fe" + }, + { + "path": "research/copied-fixed/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "de799c77257a2144e18692436fde972216b44e78", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de799c77257a2144e18692436fde972216b44e78" + }, + { + "path": "research/copied-fixed/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "2760f3332ecacf0650fa053e2fc25828b0aa226a", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2760f3332ecacf0650fa053e2fc25828b0aa226a" + }, + { + "path": "research/copied-fixed/search-record.json", + "mode": "100644", + "type": "blob", + "sha": "35a6a27f6c970079012c36173ac4fd1997bfa0f8", + "size": 427492, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/35a6a27f6c970079012c36173ac4fd1997bfa0f8" + }, + { + "path": "research/copied-fixed/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "6eecb7a8854a24e508b68a92da722aefb5e23811", + "size": 1511, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6eecb7a8854a24e508b68a92da722aefb5e23811" + }, + { + "path": "research/copied-fixed/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "665458d3626af0874cfe882d781829a8b4ff45ee", + "size": 1538, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/665458d3626af0874cfe882d781829a8b4ff45ee" + }, + { + "path": "research/copied-fixed/validation.json", + "mode": "100644", + "type": "blob", + "sha": "8f65f988b9307e3a3079b413e24da64f571256f4", + "size": 2747, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8f65f988b9307e3a3079b413e24da64f571256f4" + }, + { + "path": "research/copied-fixed/verify.py", + "mode": "100644", + "type": "blob", + "sha": "353de0374c868501f441e1c653b2c96b3bbfd2d2", + "size": 17580, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/353de0374c868501f441e1c653b2c96b3bbfd2d2" + }, + { + "path": "research/copied-reversed", + "mode": "040000", + "type": "tree", + "sha": "93810eaac64416b497d68bcb8f57c82da49f4225", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/93810eaac64416b497d68bcb8f57c82da49f4225" + }, + { + "path": "research/copied-reversed/README.md", + "mode": "100644", + "type": "blob", + "sha": "aaf71dc7fe72a936f64c6dfc75e8bee99c1ec472", + "size": 7997, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aaf71dc7fe72a936f64c6dfc75e8bee99c1ec472" + }, + { + "path": "research/copied-reversed/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "9c6510d2de04d9f5d2ecdf9d77d93270933e89f5", + "size": 1619, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c6510d2de04d9f5d2ecdf9d77d93270933e89f5" + }, + { + "path": "research/copied-reversed/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/copied-reversed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "f3718b455af963ea3f6f9906bd56f7d7a8ebf963", + "size": 33811, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f3718b455af963ea3f6f9906bd56f7d7a8ebf963" + }, + { + "path": "research/copied-reversed/geometry-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "da205503f6f32cc1b089716658e6a130769eaaa2", + "size": 50497, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/da205503f6f32cc1b089716658e6a130769eaaa2" + }, + { + "path": "research/copied-reversed/geometry-proof.txt", + "mode": "100644", + "type": "blob", + "sha": "f33374fd85f807fcdab2c332e139f54b38c36ac0", + "size": 8974, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f33374fd85f807fcdab2c332e139f54b38c36ac0" + }, + { + "path": "research/copied-reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "618912ee497c053e7d891c6b7f07c5517edeae71", + "size": 805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/618912ee497c053e7d891c6b7f07c5517edeae71" + }, + { + "path": "research/copied-reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "7ad54118609fb8eebbb329d8862c8c899039a93b", + "size": 4689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ad54118609fb8eebbb329d8862c8c899039a93b" + }, + { + "path": "research/copied-reversed/pr34", + "mode": "040000", + "type": "tree", + "sha": "80c5b3126c18d39bb78836a93317f97869427acf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/80c5b3126c18d39bb78836a93317f97869427acf" + }, + { + "path": "research/copied-reversed/pr34/certify_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "e7367cb24862b7f416c4f36181b6d383ba53bb7c", + "size": 5526, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7367cb24862b7f416c4f36181b6d383ba53bb7c" + }, + { + "path": "research/copied-reversed/pr34/independent_controls.py", + "mode": "100644", + "type": "blob", + "sha": "d5578d5c51081ca922c1a4f3dc320253c011afe6", + "size": 5610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d5578d5c51081ca922c1a4f3dc320253c011afe6" + }, + { + "path": "research/copied-reversed/review", + "mode": "040000", + "type": "tree", + "sha": "2201c752506408003ae669fc6459e3b2a3a735b2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2201c752506408003ae669fc6459e3b2a3a735b2" + }, + { + "path": "research/copied-reversed/review/copied_center_operator_audit.json", + "mode": "100644", + "type": "blob", + "sha": "440a3e64fb9be697c9a05b7b951833d80a09ad75", + "size": 627, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/440a3e64fb9be697c9a05b7b951833d80a09ad75" + }, + { + "path": "research/copied-reversed/review/copied_center_operator_audit.py", + "mode": "100644", + "type": "blob", + "sha": "14390c1340a4102cd5769fd4b64b58dfa341c225", + "size": 5308, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/14390c1340a4102cd5769fd4b64b58dfa341c225" + }, + { + "path": "research/copied-reversed/review/copied_center_schedule_audit.txt", + "mode": "100644", + "type": "blob", + "sha": "641947f02cc8b3dd99b993724e3f94eee2788784", + "size": 7052, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/641947f02cc8b3dd99b993724e3f94eee2788784" + }, + { + "path": "research/copied-reversed/review/pr34-balanced-assembly-audit.txt", + "mode": "100644", + "type": "blob", + "sha": "898ca600ef369f561b22eabeaa897758844ad4fe", + "size": 6765, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/898ca600ef369f561b22eabeaa897758844ad4fe" + }, + { + "path": "research/copied-reversed/validation.json", + "mode": "100644", + "type": "blob", + "sha": "ad843830ad8c6f5b5bae6ceb63a4218809aaacaf", + "size": 1360, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad843830ad8c6f5b5bae6ceb63a4218809aaacaf" + }, + { + "path": "research/copied-reversed/witness.py", + "mode": "100644", + "type": "blob", + "sha": "be459d6f5c6d52ea1fde8f25100c7d2be000d497", + "size": 8120, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/be459d6f5c6d52ea1fde8f25100c7d2be000d497" + }, + { + "path": "research/deferred-product", + "mode": "040000", + "type": "tree", + "sha": "2cd439a21a53b4911ba1fbfb9844c7a742fd9f92", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2cd439a21a53b4911ba1fbfb9844c7a742fd9f92" + }, + { + "path": "research/deferred-product/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "a9d3b9856ab18cfdc73d536bb93f97c28c8ec26f", + "size": 5160, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a9d3b9856ab18cfdc73d536bb93f97c28c8ec26f" + }, + { + "path": "research/deferred-product/README.md", + "mode": "100644", + "type": "blob", + "sha": "5bb63d08557484e442e059c2b0832aeffe407e60", + "size": 1889, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5bb63d08557484e442e059c2b0832aeffe407e60" + }, + { + "path": "research/deferred-signed", + "mode": "040000", + "type": "tree", + "sha": "3e6db5708db568219edc8cf572bcc05f597da4aa", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3e6db5708db568219edc8cf572bcc05f597da4aa" + }, + { + "path": "research/deferred-signed/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "d96717353e80003b5c43c45e966c3afb87c17387", + "size": 13881, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d96717353e80003b5c43c45e966c3afb87c17387" + }, + { + "path": "research/deferred-signed/README.md", + "mode": "100644", + "type": "blob", + "sha": "58791689052f575743783a830ce7a2638968bd91", + "size": 3076, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/58791689052f575743783a830ce7a2638968bd91" + }, + { + "path": "research/deferred-signed/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "3521d3c5cdba3a93b29cd7e9b2603caa37f4b705", + "size": 19758, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3521d3c5cdba3a93b29cd7e9b2603caa37f4b705" + }, + { + "path": "research/deferred-signed/VALIDATION.json", + "mode": "100644", + "type": "blob", + "sha": "a221c78912e406d2535f5a9ceee58f94999c7eb8", + "size": 18672, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a221c78912e406d2535f5a9ceee58f94999c7eb8" + }, + { + "path": "research/deferred-signed/check_complex_identity.py", + "mode": "100644", + "type": "blob", + "sha": "833fbded74951c775043573f19f5288e8f7c2de3", + "size": 1564, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/833fbded74951c775043573f19f5288e8f7c2de3" + }, + { + "path": "research/deferred-signed/round6-complex-interface-controls.json", + "mode": "100644", + "type": "blob", + "sha": "bda184640fd3c74440262da306ba9b91bdf5c57c", + "size": 935, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bda184640fd3c74440262da306ba9b91bdf5c57c" + }, + { + "path": "research/deferred-signed/round6-complex-literal-ledger", + "mode": "040000", + "type": "tree", + "sha": "3e7753d58c20fdd3b8a5a87dd8d218080f568b5a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3e7753d58c20fdd3b8a5a87dd8d218080f568b5a" + }, + { + "path": "research/deferred-signed/round6-complex-literal-ledger/result.json", + "mode": "100644", + "type": "blob", + "sha": "b52fceb9147dad059cf8db5888b2a98035f8e33c", + "size": 1938, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b52fceb9147dad059cf8db5888b2a98035f8e33c" + }, + { + "path": "research/deferred-signed/round6_complex_interface_controls.py", + "mode": "100644", + "type": "blob", + "sha": "7a84af93ed875da010ad7c8dc89c0e78d9e0873c", + "size": 5278, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7a84af93ed875da010ad7c8dc89c0e78d9e0873c" + }, + { + "path": "research/deferred-signed/round6_complex_literal_ledger.py", + "mode": "100644", + "type": "blob", + "sha": "9f1b5b3e3a4daa1f42ae29af073fc07661880095", + "size": 7175, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9f1b5b3e3a4daa1f42ae29af073fc07661880095" + }, + { + "path": "research/deferred-signed/round7-balanced-assembly-candidate.json", + "mode": "100644", + "type": "blob", + "sha": "b34f25ad511f42a43038a2917223a5b2edab19b9", + "size": 6439, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b34f25ad511f42a43038a2917223a5b2edab19b9" + }, + { + "path": "research/deferred-signed/round7-literal-ledger", + "mode": "040000", + "type": "tree", + "sha": "74d95bba9ad15a544b8cd8f31ecf0a939adfc2bc", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/74d95bba9ad15a544b8cd8f31ecf0a939adfc2bc" + }, + { + "path": "research/deferred-signed/round7-literal-ledger/result.json", + "mode": "100644", + "type": "blob", + "sha": "b6449a74d8689a0ed294b14713e0e78ce577e24f", + "size": 4223, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b6449a74d8689a0ed294b14713e0e78ce577e24f" + }, + { + "path": "research/deferred-signed/round7-tensor-endpoint-controls.json", + "mode": "100644", + "type": "blob", + "sha": "a121d26ca3d51d231b73cc7bde67a277ff29cc22", + "size": 1577, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a121d26ca3d51d231b73cc7bde67a277ff29cc22" + }, + { + "path": "research/deferred-signed/round7_balanced_assembly_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "f0230cc0a436be82cb66b80624677b6b5be211eb", + "size": 3149, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0230cc0a436be82cb66b80624677b6b5be211eb" + }, + { + "path": "research/deferred-signed/round7_literal_frame_ledger.py", + "mode": "100644", + "type": "blob", + "sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "size": 8657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa0de9ed8a4467008200617e74dd7c8a5b1d370a" + }, + { + "path": "research/deferred-signed/round7_tensor_endpoint_controls.py", + "mode": "100644", + "type": "blob", + "sha": "2db779468c4f67a72b2ecf2d715fd6bea81ef946", + "size": 2265, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2db779468c4f67a72b2ecf2d715fd6bea81ef946" + }, + { + "path": "research/deferred-signed/swapnil-round7", + "mode": "040000", + "type": "tree", + "sha": "3a262e4480c5b9dcc8d2f160dd1e880147c6f3d7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3a262e4480c5b9dcc8d2f160dd1e880147c6f3d7" + }, + { + "path": "research/deferred-signed/swapnil-round7/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "fcaeafddb14b5916950724f02f3be328f0c36ddf", + "size": 23, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fcaeafddb14b5916950724f02f3be328f0c36ddf" + }, + { + "path": "research/deferred-signed/swapnil-round7/IMPORT.json", + "mode": "100644", + "type": "blob", + "sha": "0167c6fda13daee13d1bbf9b885e13bb09d90aaa", + "size": 11154, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0167c6fda13daee13d1bbf9b885e13bb09d90aaa" + }, + { + "path": "research/deferred-signed/swapnil-round7/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "research/deferred-signed/swapnil-round7/Makefile", + "mode": "100644", + "type": "blob", + "sha": "fdff0234e8d7adbc975c8487e7fb6a17820518df", + "size": 2026, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fdff0234e8d7adbc975c8487e7fb6a17820518df" + }, + { + "path": "research/deferred-signed/swapnil-round7/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "be2e7e5a9838fe7e284aff3babc864455c2281d2", + "size": 2543, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/be2e7e5a9838fe7e284aff3babc864455c2281d2" + }, + { + "path": "research/deferred-signed/swapnil-round7/README.md", + "mode": "100644", + "type": "blob", + "sha": "09708066640450a0aea89976579b5aba82098ac1", + "size": 17023, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/09708066640450a0aea89976579b5aba82098ac1" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts", + "mode": "040000", + "type": "tree", + "sha": "ca961eefb2f723f66dbc2ae5e52ea3264e6318eb", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ca961eefb2f723f66dbc2ae5e52ea3264e6318eb" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/complex-source-frames.pdf", + "mode": "100644", + "type": "blob", + "sha": "68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0", + "size": 53103, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/copied-centres.pdf", + "mode": "100644", + "type": "blob", + "sha": "c290bc5431382e6af840895e6892fba1dc165c7a", + "size": 43970, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c290bc5431382e6af840895e6892fba1dc165c7a" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/data-edge-batching.pdf", + "mode": "100644", + "type": "blob", + "sha": "cb94268721cc71fe42eb54c76b43fff566492d37", + "size": 39141, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb94268721cc71fe42eb54c76b43fff566492d37" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/deferred-readout.pdf", + "mode": "100644", + "type": "blob", + "sha": "7aa9fb30817c371cc2b9a717965925168bf18e96", + "size": 66148, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7aa9fb30817c371cc2b9a717965925168bf18e96" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/fine-field-lemma.pdf", + "mode": "100644", + "type": "blob", + "sha": "ff5bd622016110694ff79aa283e25b52953d8832", + "size": 95968, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff5bd622016110694ff79aa283e25b52953d8832" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/flag-basis.pdf", + "mode": "100644", + "type": "blob", + "sha": "39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5", + "size": 54385, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/partial-swap-batching.pdf", + "mode": "100644", + "type": "blob", + "sha": "a03f30c451a2baf59a69f8d5b30d12687f9ffdfc", + "size": 60416, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a03f30c451a2baf59a69f8d5b30d12687f9ffdfc" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/round3-combination.pdf", + "mode": "100644", + "type": "blob", + "sha": "0706f9d115468ca9314c47503b190346be67a0c9", + "size": 45026, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0706f9d115468ca9314c47503b190346be67a0c9" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/segmented-inverse.pdf", + "mode": "100644", + "type": "blob", + "sha": "65a2e177778547c4029570aee05237d1e69dcf3d", + "size": 104153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65a2e177778547c4029570aee05237d1e69dcf3d" + }, + { + "path": "research/deferred-signed/swapnil-round7/artifacts/stack-notes.pdf", + "mode": "100644", + "type": "blob", + "sha": "827f07e6b5be63d903f8f5becc1a57cf99355db0", + "size": 94315, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/827f07e6b5be63d903f8f5becc1a57cf99355db0" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates", + "mode": "040000", + "type": "tree", + "sha": "87d303237fb2c2a7b604ec5527026b089037b676", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/87d303237fb2c2a7b604ec5527026b089037b676" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/external", + "mode": "040000", + "type": "tree", + "sha": "b779d664d6cf75884e59cfd04f75ac59ba78f2d7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/b779d664d6cf75884e59cfd04f75ac59ba78f2d7" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/external/pr24-bit-network.json", + "mode": "100644", + "type": "blob", + "sha": "4e212f628196ee434aa67b09a1cedcd8d4d72e85", + "size": 1634, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e212f628196ee434aa67b09a1cedcd8d4d72e85" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/identities.json", + "mode": "100644", + "type": "blob", + "sha": "a87f969d341e04fa60fd48eff7cbd639bda955b1", + "size": 982, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a87f969d341e04fa60fd48eff7cbd639bda955b1" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/round7", + "mode": "040000", + "type": "tree", + "sha": "de3fce68d8ca5c2985e3afea9b477482462596d6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/de3fce68d8ca5c2985e3afea9b477482462596d6" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/round7/deferred_23.json.gz", + "mode": "100644", + "type": "blob", + "sha": "4a4431bd425aa4499f25e67df4e0d2cddd7df15c", + "size": 1524681, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a4431bd425aa4499f25e67df4e0d2cddd7df15c" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/round7/witness_23.json.gz", + "mode": "100644", + "type": "blob", + "sha": "3d86f83b871ba07c3b1562aa6d953ae86b9750ba", + "size": 771258, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3d86f83b871ba07c3b1562aa6d953ae86b9750ba" + }, + { + "path": "research/deferred-signed/swapnil-round7/certificates/witness.json", + "mode": "100644", + "type": "blob", + "sha": "94339ac381b3a3eea3f5edfb0638bbd06d617282", + "size": 1307, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94339ac381b3a3eea3f5edfb0638bbd06d617282" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent", + "mode": "040000", + "type": "tree", + "sha": "ce3ed9bba12af1229a7d52a96b8d6b9d6be274b2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ce3ed9bba12af1229a7d52a96b8d6b9d6be274b2" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network", + "mode": "040000", + "type": "tree", + "sha": "cc366a4b63922a8ff6633e15af4a5af51b37f97c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cc366a4b63922a8ff6633e15af4a5af51b37f97c" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/README.md", + "mode": "100644", + "type": "blob", + "sha": "95a5da44ed26c34d3cb8dec581894a873ab5ade3", + "size": 1374, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/95a5da44ed26c34d3cb8dec581894a873ab5ade3" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/bc.py", + "mode": "100644", + "type": "blob", + "sha": "53e00de297d6f693c19c88425292647f594dac63", + "size": 778, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/53e00de297d6f693c19c88425292647f594dac63" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_cert.py", + "mode": "100644", + "type": "blob", + "sha": "103bbb7d271c2bfd05206a35aabd14986eaf9c0e", + "size": 1754, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/103bbb7d271c2bfd05206a35aabd14986eaf9c0e" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/fullbatch_hist.py", + "mode": "100644", + "type": "blob", + "sha": "5b04ed68ec9fb3c66bdd96025d14ed3dcb2a1458", + "size": 3955, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5b04ed68ec9fb3c66bdd96025d14ed3dcb2a1458" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/labels.py", + "mode": "100644", + "type": "blob", + "sha": "ec70ed13a59851c16202665dd34f667fde54708d", + "size": 3259, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ec70ed13a59851c16202665dd34f667fde54708d" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/roles.py", + "mode": "100644", + "type": "blob", + "sha": "d0d0594e2dee738f64401face0007501c9ccb4b9", + "size": 1070, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d0d0594e2dee738f64401face0007501c9ccb4b9" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/side.py", + "mode": "100644", + "type": "blob", + "sha": "2a625732bb10238aeb2d0f256dabd794b276262b", + "size": 8238, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a625732bb10238aeb2d0f256dabd794b276262b" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_labels.py", + "mode": "100644", + "type": "blob", + "sha": "ae6a68014ad822a09a729fc06f89a2375730a65e", + "size": 4296, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ae6a68014ad822a09a729fc06f89a2375730a65e" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_sim.py", + "mode": "100644", + "type": "blob", + "sha": "ca684ec9badd9f4305d584f4786f6042d35b87e3", + "size": 8353, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca684ec9badd9f4305d584f4786f6042d35b87e3" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-network/sourceframe_trace.py", + "mode": "100644", + "type": "blob", + "sha": "965b9101c68167a245b17bbdf49f884b2f62d5db", + "size": 7269, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/965b9101c68167a245b17bbdf49f884b2f62d5db" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage", + "mode": "040000", + "type": "tree", + "sha": "c64d9826d080bac09b589091f525ab9efef6573b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c64d9826d080bac09b589091f525ab9efef6573b" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/cert.py", + "mode": "100644", + "type": "blob", + "sha": "bb6879adcd3b2a0c78afba69ea05ed154e4b786b", + "size": 1983, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bb6879adcd3b2a0c78afba69ea05ed154e4b786b" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/frames.py", + "mode": "100644", + "type": "blob", + "sha": "45126062136d58f2d4fedcf549f40cd95d456c7f", + "size": 4206, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/45126062136d58f2d4fedcf549f40cd95d456c7f" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/hist.py", + "mode": "100644", + "type": "blob", + "sha": "30fc761818781e881962cbab3efcb0547e1173a1", + "size": 6689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/30fc761818781e881962cbab3efcb0547e1173a1" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/producer.py", + "mode": "100644", + "type": "blob", + "sha": "10d2110f9bf25a857f5b7fef76bb95fa367d3eac", + "size": 12485, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/10d2110f9bf25a857f5b7fef76bb95fa367d3eac" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/complex-twostage/run.py", + "mode": "100644", + "type": "blob", + "sha": "fe438f91656df7dc6b236d7b2000261282776228", + "size": 1365, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fe438f91656df7dc6b236d7b2000261282776228" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout", + "mode": "040000", + "type": "tree", + "sha": "14b36433deff7101013d235b58524030a0ab83e8", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/14b36433deff7101013d235b58524030a0ab83e8" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_frames.py", + "mode": "100644", + "type": "blob", + "sha": "f22b6998f9415dd0b081a146f00e5c30065d6689", + "size": 15297, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f22b6998f9415dd0b081a146f00e5c30065d6689" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_lifted.py", + "mode": "100644", + "type": "blob", + "sha": "4a19240e2fe5f55891d842fd451bd0cb24e4ae76", + "size": 36417, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a19240e2fe5f55891d842fd451bd0cb24e4ae76" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_stair.py", + "mode": "100644", + "type": "blob", + "sha": "d3d1dea1a9a42601410fb5cd3edc5888d63d217b", + "size": 10844, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d3d1dea1a9a42601410fb5cd3edc5888d63d217b" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/check_word.py", + "mode": "100644", + "type": "blob", + "sha": "7db40994e4d74afe191c3fd8ac5c9acc9b438eeb", + "size": 11772, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7db40994e4d74afe191c3fd8ac5c9acc9b438eeb" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/deferred.py", + "mode": "100644", + "type": "blob", + "sha": "b77bb4861c38b731e5b41a17af8fc1b63b56ec42", + "size": 9289, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b77bb4861c38b731e5b41a17af8fc1b63b56ec42" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/deferred-readout/linalg.py", + "mode": "100644", + "type": "blob", + "sha": "a81cbaa61e2c09075f900546ec46833103b77ac1", + "size": 6412, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a81cbaa61e2c09075f900546ec46833103b77ac1" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap", + "mode": "040000", + "type": "tree", + "sha": "5f71b6044b61e30841c7fb22283b5fac72429750", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5f71b6044b61e30841c7fb22283b5fac72429750" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/README.md", + "mode": "100644", + "type": "blob", + "sha": "536b9b40604d1391582b5e86ccc6aac64dc236d7", + "size": 439, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/536b9b40604d1391582b5e86ccc6aac64dc236d7" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/factor.py", + "mode": "100644", + "type": "blob", + "sha": "9908b695e021f9069123e2bf15095caf1ccae337", + "size": 3120, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9908b695e021f9069123e2bf15095caf1ccae337" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/frames.py", + "mode": "100644", + "type": "blob", + "sha": "31c8130c5946574fd6996a56dac246ee688bffb1", + "size": 9402, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31c8130c5946574fd6996a56dac246ee688bffb1" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/moment.py", + "mode": "100644", + "type": "blob", + "sha": "1d0c379fb8490f6f51717888da5904c9c1168e44", + "size": 2205, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d0c379fb8490f6f51717888da5904c9c1168e44" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/partial-swap/test_factor.py", + "mode": "100644", + "type": "blob", + "sha": "aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0", + "size": 5524, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts", + "mode": "040000", + "type": "tree", + "sha": "77b85d5afb2aba8a481407796e2cdaf043eb1f6a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/77b85d5afb2aba8a481407796e2cdaf043eb1f6a" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/README.md", + "mode": "100644", + "type": "blob", + "sha": "390bb577fd4ec1fa774ded95887ce5855adc17e7", + "size": 893, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/390bb577fd4ec1fa774ded95887ce5855adc17e7" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/complexside.py", + "mode": "100644", + "type": "blob", + "sha": "5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6", + "size": 2484, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/export.py", + "mode": "100644", + "type": "blob", + "sha": "7f95483f148e9022245b3240659478c66ed5df00", + "size": 562, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7f95483f148e9022245b3240659478c66ed5df00" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/global.cpp", + "mode": "100644", + "type": "blob", + "sha": "eac7e283d2ad8484d4f0718ba455304035a5440d", + "size": 11513, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eac7e283d2ad8484d4f0718ba455304035a5440d" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/pr7-role-counts/local.py", + "mode": "100644", + "type": "blob", + "sha": "5e8157d957e67293c66f6793911ef77cf6581135", + "size": 7590, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e8157d957e67293c66f6793911ef77cf6581135" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit", + "mode": "040000", + "type": "tree", + "sha": "a661cc26a4a2926060cd129e0c76ff16126dd7f9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/a661cc26a4a2926060cd129e0c76ff16126dd7f9" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/bruhat8.py", + "mode": "100644", + "type": "blob", + "sha": "f2c4ece08c01503a9ef42f67081b3abe0aab9321", + "size": 1204, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2c4ece08c01503a9ef42f67081b3abe0aab9321" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/cert_rt.py", + "mode": "100644", + "type": "blob", + "sha": "9113ef8fe31f59ed446658e856318e03f44f062e", + "size": 2123, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9113ef8fe31f59ed446658e856318e03f44f062e" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkgm.py", + "mode": "100644", + "type": "blob", + "sha": "b5dd1bef63c86ab9acf49e9093fff704267ebd39", + "size": 1507, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b5dd1bef63c86ab9acf49e9093fff704267ebd39" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/checkside.py", + "mode": "100644", + "type": "blob", + "sha": "f2ac3d9eb82c2428f1ec23c8a071bfbc387e4ad7", + "size": 3204, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2ac3d9eb82c2428f1ec23c8a071bfbc387e4ad7" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/corners.py", + "mode": "100644", + "type": "blob", + "sha": "810144541f6811b2407df94b5ca95deb25f6ff6d", + "size": 5671, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/810144541f6811b2407df94b5ca95deb25f6ff6d" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flag_existence.py", + "mode": "100644", + "type": "blob", + "sha": "a6143f138385df59b936814ec33b4bb6611330ec", + "size": 5766, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a6143f138385df59b936814ec33b4bb6611330ec" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/flagbasis.py", + "mode": "100644", + "type": "blob", + "sha": "98893c5a204513a784e783a5fd25b16570a75f39", + "size": 14081, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/98893c5a204513a784e783a5fd25b16570a75f39" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/gmside.py", + "mode": "100644", + "type": "blob", + "sha": "69862f57d00c67c575e51be323b2db351796172a", + "size": 1667, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/69862f57d00c67c575e51be323b2db351796172a" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/moment.py", + "mode": "100644", + "type": "blob", + "sha": "c514c372102a9ae4189bd573f6fb0d276fc54f1e", + "size": 3907, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c514c372102a9ae4189bd573f6fb0d276fc54f1e" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/orders.py", + "mode": "100644", + "type": "blob", + "sha": "86df1026f34ea313176aa06fe264d3e6b6469875", + "size": 1665, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/86df1026f34ea313176aa06fe264d3e6b6469875" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/rtgm.py", + "mode": "100644", + "type": "blob", + "sha": "c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04", + "size": 7431, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/side_chains.py", + "mode": "100644", + "type": "blob", + "sha": "d08377f94ea85799a1aadac6aef69df4607297fe", + "size": 6893, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d08377f94ea85799a1aadac6aef69df4607297fe" + }, + { + "path": "research/deferred-signed/swapnil-round7/independent/two-stage-bit/sidegen.py", + "mode": "100644", + "type": "blob", + "sha": "7ab495d87c762cfc00e485711d5f5d58d97e3fc1", + "size": 5515, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ab495d87c762cfc00e485711d5f5d58d97e3fc1" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean", + "mode": "040000", + "type": "tree", + "sha": "eb6b1c039bc415b6d615c95dd84c18247ce1a89e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/eb6b1c039bc415b6d615c95dd84c18247ce1a89e" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round5.lean", + "mode": "100644", + "type": "blob", + "sha": "2577a55fb158a46bb7c82db5e7f53587c5b5e91b", + "size": 5337, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2577a55fb158a46bb7c82db5e7f53587c5b5e91b" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round6.lean", + "mode": "100644", + "type": "blob", + "sha": "50514f86023fd1e948dd9bf9c9be2ec11d12e166", + "size": 4793, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50514f86023fd1e948dd9bf9c9be2ec11d12e166" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/Round7.lean", + "mode": "100644", + "type": "blob", + "sha": "b523099790aadab761c9a7a1085583f988d16d9b", + "size": 6309, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b523099790aadab761c9a7a1085583f988d16d9b" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump.py", + "mode": "100644", + "type": "blob", + "sha": "dcc74f0aa73809eed6a1b60b6a4630945864e964", + "size": 1457, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dcc74f0aa73809eed6a1b60b6a4630945864e964" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump6.py", + "mode": "100644", + "type": "blob", + "sha": "564d980dd46da700b9cef392e8273bb2f02b6cc4", + "size": 1235, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/564d980dd46da700b9cef392e8273bb2f02b6cc4" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/dump7.py", + "mode": "100644", + "type": "blob", + "sha": "44046768cb7bd1a34158321385f0ebad726a968d", + "size": 1550, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/44046768cb7bd1a34158321385f0ebad726a968d" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/gen.py", + "mode": "100644", + "type": "blob", + "sha": "a19afaa20c5024ff12f9f57252d49832906dbf44", + "size": 5896, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a19afaa20c5024ff12f9f57252d49832906dbf44" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round5-histograms.json", + "mode": "100644", + "type": "blob", + "sha": "d04e8b717dda125c010e7d1717f68530c79b03a6", + "size": 1498, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d04e8b717dda125c010e7d1717f68530c79b03a6" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round6-histograms.json", + "mode": "100644", + "type": "blob", + "sha": "d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3", + "size": 956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3" + }, + { + "path": "research/deferred-signed/swapnil-round7/lean/round7-histograms.json", + "mode": "100644", + "type": "blob", + "sha": "830484689b2a0801992ce6b6e884014bc9c933fe", + "size": 2338, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/830484689b2a0801992ce6b6e884014bc9c933fe" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes", + "mode": "040000", + "type": "tree", + "sha": "691c916a4af1346361bcf877d658c5222b8f6244", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/691c916a4af1346361bcf877d658c5222b8f6244" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/complex-source-frames.tex", + "mode": "100644", + "type": "blob", + "sha": "65b9e9129a5c4ebe205c0c971f8559a571808b95", + "size": 4632, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65b9e9129a5c4ebe205c0c971f8559a571808b95" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/copied-centres.tex", + "mode": "100644", + "type": "blob", + "sha": "cdcc820c95c9aa984a703460a968421bb37189a0", + "size": 4267, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cdcc820c95c9aa984a703460a968421bb37189a0" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/data-edge-batching.tex", + "mode": "100644", + "type": "blob", + "sha": "76c91c10c96bbb0432f7f4996c5734e5eee0b956", + "size": 2201, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/76c91c10c96bbb0432f7f4996c5734e5eee0b956" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/deferred-readout.tex", + "mode": "100644", + "type": "blob", + "sha": "3b6dab87052c5c941a38e857d9caba60423c944a", + "size": 8621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3b6dab87052c5c941a38e857d9caba60423c944a" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/fine-field-lemma.tex", + "mode": "100644", + "type": "blob", + "sha": "331789a6f16c5aef87a37eedef147a3146450b86", + "size": 19643, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/331789a6f16c5aef87a37eedef147a3146450b86" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/flag-basis.tex", + "mode": "100644", + "type": "blob", + "sha": "5647021edd381d28fbb44ced0f8f7bcfcdeaa72f", + "size": 6846, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5647021edd381d28fbb44ced0f8f7bcfcdeaa72f" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/partial-swap-batching.tex", + "mode": "100644", + "type": "blob", + "sha": "319f6447632924760047f4a49d0f070a3094de37", + "size": 7133, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/319f6447632924760047f4a49d0f070a3094de37" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/round3-combination.tex", + "mode": "100644", + "type": "blob", + "sha": "74d1f9a16673bb2b6258028a4259df7f0be67b35", + "size": 4060, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74d1f9a16673bb2b6258028a4259df7f0be67b35" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/segmented-inverse.tex", + "mode": "100644", + "type": "blob", + "sha": "09ad215ccf3876d604fbbea1f25e772cd63e875b", + "size": 19302, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/09ad215ccf3876d604fbbea1f25e772cd63e875b" + }, + { + "path": "research/deferred-signed/swapnil-round7/notes/stack-notes.tex", + "mode": "100644", + "type": "blob", + "sha": "2c77009e0119100371d9546519f9fa06e5fe814f", + "size": 16610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c77009e0119100371d9546519f9fa06e5fe814f" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts", + "mode": "040000", + "type": "tree", + "sha": "71e88e6f34dff93d665d674dc3006fb462484f6b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/71e88e6f34dff93d665d674dc3006fb462484f6b" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate.py", + "mode": "100644", + "type": "blob", + "sha": "71c743a58a3d7027b865572f8bb2c5f6afe8c9db", + "size": 4597, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/71c743a58a3d7027b865572f8bb2c5f6afe8c9db" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round3.py", + "mode": "100644", + "type": "blob", + "sha": "c5a9fa429bd88f7134eadf5c85eb7ce39c573e28", + "size": 4474, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c5a9fa429bd88f7134eadf5c85eb7ce39c573e28" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round4.py", + "mode": "100644", + "type": "blob", + "sha": "5f6b2c6910563bf534f43d308d57679a90f10033", + "size": 2915, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5f6b2c6910563bf534f43d308d57679a90f10033" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round5.py", + "mode": "100644", + "type": "blob", + "sha": "73403788933bd05b3d3d117a09a38ca519c85482", + "size": 3413, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/73403788933bd05b3d3d117a09a38ca519c85482" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round6.py", + "mode": "100644", + "type": "blob", + "sha": "aeb3e6f6c4490a097e82763517005519ed9fba3d", + "size": 2479, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aeb3e6f6c4490a097e82763517005519ed9fba3d" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/certificate_round7.py", + "mode": "100644", + "type": "blob", + "sha": "32c0058d832b43cb95e288467e152f72ca6083ac", + "size": 3532, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32c0058d832b43cb95e288467e152f72ca6083ac" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_fine_field.py", + "mode": "100644", + "type": "blob", + "sha": "13d2316ee5bf9a01514855267dee54ae583111a4", + "size": 19709, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13d2316ee5bf9a01514855267dee54ae583111a4" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_gs_path.py", + "mode": "100644", + "type": "blob", + "sha": "b1e4281c733dc395155c4547ffc50a7b3a87fd2a", + "size": 13237, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b1e4281c733dc395155c4547ffc50a7b3a87fd2a" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_identities.py", + "mode": "100644", + "type": "blob", + "sha": "b4c481350ad8890d479fdcf954f79a04c15cd548", + "size": 2762, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b4c481350ad8890d479fdcf954f79a04c15cd548" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_reuse_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "447418acb431af6110b10f62f9581378cf24f1bf", + "size": 5681, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/447418acb431af6110b10f62f9581378cf24f1bf" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_segmented_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c", + "size": 3976, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c" + }, + { + "path": "research/deferred-signed/swapnil-round7/scripts/check_subblock_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "a9876c9fc01ca077dcaf13b095019357560ffd6c", + "size": 3733, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a9876c9fc01ca077dcaf13b095019357560ffd6c" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests", + "mode": "040000", + "type": "tree", + "sha": "d0a6232dbc7feeff48c0c1f9d96c42256c99c645", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/d0a6232dbc7feeff48c0c1f9d96c42256c99c645" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round3.py", + "mode": "100644", + "type": "blob", + "sha": "33116082d2d11bbcfa0144c54dda5c6b8fb42e1c", + "size": 1262, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/33116082d2d11bbcfa0144c54dda5c6b8fb42e1c" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round4.py", + "mode": "100644", + "type": "blob", + "sha": "68bb03e902271d87c59a102e0a83205d87cc870e", + "size": 1781, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68bb03e902271d87c59a102e0a83205d87cc870e" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round5.py", + "mode": "100644", + "type": "blob", + "sha": "f88e4647631a1b525faac9151fa76f0534edfd15", + "size": 1750, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f88e4647631a1b525faac9151fa76f0534edfd15" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round6.py", + "mode": "100644", + "type": "blob", + "sha": "5af8799c2c1df73d277b3ca38dabc1b9d8b64b05", + "size": 1063, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5af8799c2c1df73d277b3ca38dabc1b9d8b64b05" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_round7.py", + "mode": "100644", + "type": "blob", + "sha": "ad6d0de81e1c3cdc38f860b28619be93f597f475", + "size": 2199, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad6d0de81e1c3cdc38f860b28619be93f597f475" + }, + { + "path": "research/deferred-signed/swapnil-round7/tests/test_witness.py", + "mode": "100644", + "type": "blob", + "sha": "a4412d43150ccb76e8cef7947a8e6f7cf3165ea5", + "size": 2066, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a4412d43150ccb76e8cef7947a8e6f7cf3165ea5" + }, + { + "path": "research/deferred-signed/validation-prior", + "mode": "040000", + "type": "tree", + "sha": "cb261bacad1f9f888fd4caad1d31f123ce42dada", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cb261bacad1f9f888fd4caad1d31f123ce42dada" + }, + { + "path": "research/deferred-signed/validation-prior/complex-prior-replay.json", + "mode": "100644", + "type": "blob", + "sha": "0d53f10d142b7ce4c567b0b0169b1ca9103713ee", + "size": 8359, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d53f10d142b7ce4c567b0b0169b1ca9103713ee" + }, + { + "path": "research/deferred-signed/validation-prior/round6_complex_interface_controls.py", + "mode": "100644", + "type": "blob", + "sha": "7a84af93ed875da010ad7c8dc89c0e78d9e0873c", + "size": 5278, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7a84af93ed875da010ad7c8dc89c0e78d9e0873c" + }, + { + "path": "research/deferred-signed/validation-prior/round6_complex_literal_ledger.py", + "mode": "100644", + "type": "blob", + "sha": "269d26c42193642091ac51f1760c345fef6b7601", + "size": 7152, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/269d26c42193642091ac51f1760c345fef6b7601" + }, + { + "path": "research/deferred-signed/validation-prior/round7_balanced_assembly_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "f82253aa70a818b5ae59c51f1da56021d1a207a9", + "size": 3151, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f82253aa70a818b5ae59c51f1da56021d1a207a9" + }, + { + "path": "research/deferred-signed/validation-prior/round7_literal_frame_ledger.py", + "mode": "100644", + "type": "blob", + "sha": "aa0de9ed8a4467008200617e74dd7c8a5b1d370a", + "size": 8657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa0de9ed8a4467008200617e74dd7c8a5b1d370a" + }, + { + "path": "research/deferred-signed/validation-prior/round7_tensor_endpoint_controls.py", + "mode": "100644", + "type": "blob", + "sha": "2db779468c4f67a72b2ecf2d715fd6bea81ef946", + "size": 2265, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2db779468c4f67a72b2ecf2d715fd6bea81ef946" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-full-basis.json", + "mode": "100644", + "type": "blob", + "sha": "3fc62f301d4f50d680cfbfe9417c4f2ed7e02b26", + "size": 853, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3fc62f301d4f50d680cfbfe9417c4f2ed7e02b26" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-moment-audit.json", + "mode": "100644", + "type": "blob", + "sha": "ac62a25d8caf1b992a85f0ea3c61f2686a864ecf", + "size": 22652, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ac62a25d8caf1b992a85f0ea3c61f2686a864ecf" + }, + { + "path": "research/deferred-signed/validation-prior/swapnil-round7-validation-job.json", + "mode": "100644", + "type": "blob", + "sha": "869231d71d1f1298ed521fa643d9989bfdb2633b", + "size": 1483, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/869231d71d1f1298ed521fa643d9989bfdb2633b" + }, + { + "path": "research/deferred-signed/verify.py", + "mode": "100644", + "type": "blob", + "sha": "b3536e65e5ecb3222acf1c0e92d7ed330eed20cb", + "size": 6920, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b3536e65e5ecb3222acf1c0e92d7ed330eed20cb" + }, + { + "path": "research/enlarged-positive-frame-networks", + "mode": "040000", + "type": "tree", + "sha": "c30b8a96a81752eae396d77c624fc44d30cc61f9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c30b8a96a81752eae396d77c624fc44d30cc61f9" + }, + { + "path": "research/enlarged-positive-frame-networks/LICENSE-PR37.txt", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "research/enlarged-positive-frame-networks/README.md", + "mode": "100644", + "type": "blob", + "sha": "fb2838c85d73928d4bb0e9aee5701ee434475261", + "size": 4074, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fb2838c85d73928d4bb0e9aee5701ee434475261" + }, + { + "path": "research/enlarged-positive-frame-networks/agents", + "mode": "040000", + "type": "tree", + "sha": "d11b43e0f8719d4b45f2664d9c499770a68578f5", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/d11b43e0f8719d4b45f2664d9c499770a68578f5" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry", + "mode": "040000", + "type": "tree", + "sha": "65968c8e8afdc7b514dc7e8b874fe17ac4572d55", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/65968c8e8afdc7b514dc7e8b874fe17ac4572d55" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code", + "mode": "040000", + "type": "tree", + "sha": "52dfa05e26ffd2a4cce343cd56839ae490f2f5b2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/52dfa05e26ffd2a4cce343cd56839ae490f2f5b2" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code/binary_io.hpp", + "mode": "100644", + "type": "blob", + "sha": "f0316551e32b1ca9066130796749e76467e36532", + "size": 72123, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0316551e32b1ca9066130796749e76467e36532" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code/negative_basis_classify_pairs.cpp", + "mode": "100644", + "type": "blob", + "sha": "c2493ac3b440c14e7de87527c6a5605ce26eec2c", + "size": 5153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c2493ac3b440c14e7de87527c6a5605ce26eec2c" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code/negative_exception_rank_union.cpp", + "mode": "100644", + "type": "blob", + "sha": "a2b888bfde6ec0fd20f7b2b130085e8e11c70579", + "size": 4596, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a2b888bfde6ec0fd20f7b2b130085e8e11c70579" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code/positive_frame_profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "66c42ff3f43f82bc7f5add7a34ce9ef73f0db0b3", + "size": 13040, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/66c42ff3f43f82bc7f5add7a34ce9ef73f0db0b3" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/code/positive_negative_projector_review.py", + "mode": "100644", + "type": "blob", + "sha": "201a56e07ee529215730f1d942c88a2b613f3c2c", + "size": 4651, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/201a56e07ee529215730f1d942c88a2b613f3c2c" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/input-manifest.json", + "mode": "100644", + "type": "blob", + "sha": "1c0f818f490ef37ff45adeda9fde6c1974f98afd", + "size": 4665, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1c0f818f490ef37ff45adeda9fde6c1974f98afd" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/negative-basis-proof.md", + "mode": "100644", + "type": "blob", + "sha": "e59a2500c54fbe600fed85a665a5a28f219b9ee0", + "size": 5286, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e59a2500c54fbe600fed85a665a5a28f219b9ee0" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/positive-frame-basis-proof.md", + "mode": "100644", + "type": "blob", + "sha": "db5cacac58171d19f907c5ae53f92d75fe0bab0d", + "size": 4673, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db5cacac58171d19f907c5ae53f92d75fe0bab0d" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/reproduce.md", + "mode": "100644", + "type": "blob", + "sha": "bc9114b56cce7f8e0dbb8498bc801f32300e1999", + "size": 4113, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc9114b56cce7f8e0dbb8498bc801f32300e1999" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results", + "mode": "040000", + "type": "tree", + "sha": "378d15af2c2b959ffd3a41f9f806aa7396b4c068", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/378d15af2c2b959ffd3a41f9f806aa7396b4c068" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/best-positive-negative-rational-profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "97cb9b48d1eee5d201188053f55b045a80b3b7cb", + "size": 9003, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/97cb9b48d1eee5d201188053f55b045a80b3b7cb" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/best-positive-negative-rational-profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "f23712e0815e2f3ec3838a72f3a496aebee49a9b", + "size": 13115, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f23712e0815e2f3ec3838a72f3a496aebee49a9b" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/both-negative-data-input-audit.json", + "mode": "100644", + "type": "blob", + "sha": "438dccb94d0cd134fd64b92f454e6fc1125aa435", + "size": 1285, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/438dccb94d0cd134fd64b92f454e6fc1125aa435" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/negative-exception-exact-part-0.json", + "mode": "100644", + "type": "blob", + "sha": "1ed4bccb20d97c8e685f099e4b4518bc7d455e31", + "size": 13619, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1ed4bccb20d97c8e685f099e4b4518bc7d455e31" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/negative-exception-exact-part-1.json", + "mode": "100644", + "type": "blob", + "sha": "f66ff36939646b36f24aec4dbf3cd6a12cd9c44a", + "size": 13702, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f66ff36939646b36f24aec4dbf3cd6a12cd9c44a" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/negative-exception-exact-part-2.json", + "mode": "100644", + "type": "blob", + "sha": "379e41a055fdf1ef5a92ee34f685b311e492adb8", + "size": 13806, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/379e41a055fdf1ef5a92ee34f685b311e492adb8" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/negative-exception-exact-part-3.json", + "mode": "100644", + "type": "blob", + "sha": "d55ef5e0840837e24abf5c8e3e3e2c018bb8f57c", + "size": 13608, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d55ef5e0840837e24abf5c8e3e3e2c018bb8f57c" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/positive-negative-projector-23.json", + "mode": "100644", + "type": "blob", + "sha": "a22db92ee6a11bc33cf59b6864819e2345d6e9af", + "size": 7325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a22db92ee6a11bc33cf59b6864819e2345d6e9af" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/geometry/results/positive-negative-projector-25.json", + "mode": "100644", + "type": "blob", + "sha": "740921de8a123082362d8be7a89e61a74f3e53d4", + "size": 7529, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/740921de8a123082362d8be7a89e61a74f3e53d4" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph", + "mode": "040000", + "type": "tree", + "sha": "e7fffb98817dbc2fc3b02d4ccf625bc2991d110d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e7fffb98817dbc2fc3b02d4ccf625bc2991d110d" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code", + "mode": "040000", + "type": "tree", + "sha": "f3fbeba154c53aab688db9b88864a66f0cb32f13", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/f3fbeba154c53aab688db9b88864a66f0cb32f13" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/alternative_producer_clones.py", + "mode": "100644", + "type": "blob", + "sha": "e252b9aa8bfba5ec137e9233b41c62349ed50689", + "size": 12064, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e252b9aa8bfba5ec137e9233b41c62349ed50689" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/binary_io.hpp", + "mode": "100644", + "type": "blob", + "sha": "9ec72c629aba3f62cecca996d91f09f859d987ba", + "size": 1678, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9ec72c629aba3f62cecca996d91f09f859d987ba" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/check_compiled_witness.py", + "mode": "100644", + "type": "blob", + "sha": "c8be738379353233c915c1c0ccde068c041d6863", + "size": 16956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8be738379353233c915c1c0ccde068c041d6863" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/frame_match_envelope.cpp", + "mode": "100644", + "type": "blob", + "sha": "664b415ff088be2bfcd1f0ec1477c7bbe15cd010", + "size": 6503, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/664b415ff088be2bfcd1f0ec1477c7bbe15cd010" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/moment_match_positive.cpp", + "mode": "100644", + "type": "blob", + "sha": "e078fbaa9304c694feba653675f32de43884951f", + "size": 7146, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e078fbaa9304c694feba653675f32de43884951f" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/moment_match_rank_node.cpp", + "mode": "100644", + "type": "blob", + "sha": "de730658a82c0d91ead0d667ab46b434f096e70d", + "size": 7150, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de730658a82c0d91ead0d667ab46b434f096e70d" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/positive_clone_search.py", + "mode": "100644", + "type": "blob", + "sha": "9ab2f3201cd77f2c1b6d6ea9237b377dffb17a5b", + "size": 13008, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9ab2f3201cd77f2c1b6d6ea9237b377dffb17a5b" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/producer_search.py", + "mode": "100644", + "type": "blob", + "sha": "f28f1b66d82fb6a4547e116aa0bdd8b8467d746d", + "size": 15963, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f28f1b66d82fb6a4547e116aa0bdd8b8467d746d" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/rebuild_alternative_selected.py", + "mode": "100644", + "type": "blob", + "sha": "40ffa9971d1254b797d5028110f7dfe7ae762d05", + "size": 3180, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/40ffa9971d1254b797d5028110f7dfe7ae762d05" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/code/rebuild_selected.py", + "mode": "100644", + "type": "blob", + "sha": "d9ef7bc86fba4696bb20e884ab6acc9ad8bf7f0c", + "size": 6010, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d9ef7bc86fba4696bb20e884ab6acc9ad8bf7f0c" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/input-manifest.json", + "mode": "100644", + "type": "blob", + "sha": "1c1166e5549fb236308b790a246dc9ea949a3612", + "size": 1433, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1c1166e5549fb236308b790a246dc9ea949a3612" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/reports", + "mode": "040000", + "type": "tree", + "sha": "cceb8383283dda97a7da86eb22f5e31167bfa192", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cceb8383283dda97a7da86eb22f5e31167bfa192" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/reports/mapped-provider-lemma.md", + "mode": "100644", + "type": "blob", + "sha": "55061116749f8b7f22874dac26db6e9f2a3d6ba3", + "size": 3773, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/55061116749f8b7f22874dac26db6e9f2a3d6ba3" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/results", + "mode": "040000", + "type": "tree", + "sha": "99d1c2a224d0e57b058194c532c2fe7332c40e67", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/99d1c2a224d0e57b058194c532c2fe7332c40e67" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/results/best-mapped-positive-negative-compiler-1535.json", + "mode": "100644", + "type": "blob", + "sha": "f8ccd28c78ad802e2917e9fd9d7f25e1090a9032", + "size": 4311, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f8ccd28c78ad802e2917e9fd9d7f25e1090a9032" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/results/best-positive-negative-recovery-23.json", + "mode": "100644", + "type": "blob", + "sha": "0e0b0b09fb48f8e1cd99252443ebfcf971055d67", + "size": 4539, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e0b0b09fb48f8e1cd99252443ebfcf971055d67" + }, + { + "path": "research/enlarged-positive-frame-networks/agents/graph/results/best-positive-negative-recovery-25.json", + "mode": "100644", + "type": "blob", + "sha": "1faf9b69d71e95c5140f5723e678b185f4895053", + "size": 4594, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1faf9b69d71e95c5140f5723e678b185f4895053" + }, + { + "path": "research/enlarged-positive-frame-networks/code", + "mode": "040000", + "type": "tree", + "sha": "0ac554c983af85155dac54bf40718ecdb7048e23", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0ac554c983af85155dac54bf40718ecdb7048e23" + }, + { + "path": "research/enlarged-positive-frame-networks/code/adopted-pr37-provenance.json", + "mode": "100644", + "type": "blob", + "sha": "fc774b0031813142f156265121fe2e8793cf84af", + "size": 522, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fc774b0031813142f156265121fe2e8793cf84af" + }, + { + "path": "research/enlarged-positive-frame-networks/code/adopted_pr37_balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/enlarged-positive-frame-networks/code/exact_composition.py", + "mode": "100644", + "type": "blob", + "sha": "5d2943d71a96883d2b1d8b577458baf8bccc0e48", + "size": 7297, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d2943d71a96883d2b1d8b577458baf8bccc0e48" + }, + { + "path": "research/enlarged-positive-frame-networks/code/explicit_profile_composition.py", + "mode": "100644", + "type": "blob", + "sha": "d749aeb72171eb9564075bec82b62f9bb519fea2", + "size": 3467, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d749aeb72171eb9564075bec82b62f9bb519fea2" + }, + { + "path": "research/enlarged-positive-frame-networks/code/fixed-basis-provenance.json", + "mode": "100644", + "type": "blob", + "sha": "525221dee23b629b682a08f204f96bd29b06c4c0", + "size": 715, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/525221dee23b629b682a08f204f96bd29b06c4c0" + }, + { + "path": "research/enlarged-positive-frame-networks/fixtures", + "mode": "040000", + "type": "tree", + "sha": "4576bf9a409724dd5546d60ea07c293e958239d3", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/4576bf9a409724dd5546d60ea07c293e958239d3" + }, + { + "path": "research/enlarged-positive-frame-networks/fixtures/both-negative-data-profile.json", + "mode": "100644", + "type": "blob", + "sha": "eb1ca0cda15d53c8c6dd50f86f4dc1cd75d0efea", + "size": 581, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb1ca0cda15d53c8c6dd50f86f4dc1cd75d0efea" + }, + { + "path": "research/enlarged-positive-frame-networks/fixtures/mapped-positive-negative-axis-profiles.json", + "mode": "100644", + "type": "blob", + "sha": "8161e1277cb71daa7101a680db3af5f99d1f27fc", + "size": 9847, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8161e1277cb71daa7101a680db3af5f99d1f27fc" + }, + { + "path": "research/enlarged-positive-frame-networks/fixtures/phase-pr36.json", + "mode": "100644", + "type": "blob", + "sha": "368757d1b4867a78931e4fe671ac965bc047d4ea", + "size": 519, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/368757d1b4867a78931e4fe671ac965bc047d4ea" + }, + { + "path": "research/enlarged-positive-frame-networks/reports", + "mode": "040000", + "type": "tree", + "sha": "52f0d43b1b2e3bb2b60d9df3dbdc35d469609daf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/52f0d43b1b2e3bb2b60d9df3dbdc35d469609daf" + }, + { + "path": "research/enlarged-positive-frame-networks/reports/construction-ledger.json", + "mode": "100644", + "type": "blob", + "sha": "92eb4c18870361ee52f8b7b342404bbab6647f37", + "size": 7300, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/92eb4c18870361ee52f8b7b342404bbab6647f37" + }, + { + "path": "research/enlarged-positive-frame-networks/runs", + "mode": "040000", + "type": "tree", + "sha": "ac934dd27f38f6513ccecf5c4af6bab6a132dcdf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ac934dd27f38f6513ccecf5c4af6bab6a132dcdf" + }, + { + "path": "research/enlarged-positive-frame-networks/runs/mapped-positive-negative-composition", + "mode": "040000", + "type": "tree", + "sha": "139a7c259625ff72bc7567e5b040863fdb41c1a1", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/139a7c259625ff72bc7567e5b040863fdb41c1a1" + }, + { + "path": "research/enlarged-positive-frame-networks/runs/mapped-positive-negative-composition/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "3937cce6ce2aafdd23f242ee6ecd1f0bc2b32667", + "size": 39015, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3937cce6ce2aafdd23f242ee6ecd1f0bc2b32667" + }, + { + "path": "research/gaussian-parity-synthesis", + "mode": "040000", + "type": "tree", + "sha": "ecfbccf9e0a9a20c619ff0f3c56bf687a069249b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ecfbccf9e0a9a20c619ff0f3c56bf687a069249b" + }, + { + "path": "research/gaussian-parity-synthesis/.gitattributes", + "mode": "100644", + "type": "blob", + "sha": "dc89a0caac26d5638fcc16fded5031eaee87eb60", + "size": 96, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dc89a0caac26d5638fcc16fded5031eaee87eb60" + }, + { + "path": "research/gaussian-parity-synthesis/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "05dbc008b5f574436044a74d7ca38823dc79a5b3", + "size": 115, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05dbc008b5f574436044a74d7ca38823dc79a5b3" + }, + { + "path": "research/gaussian-parity-synthesis/AuditAll.lean", + "mode": "100644", + "type": "blob", + "sha": "2d456e37a5b62f13c4d463b553647f2813d6955a", + "size": 9058, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2d456e37a5b62f13c4d463b553647f2813d6955a" + }, + { + "path": "research/gaussian-parity-synthesis/CommunityPrecisionProfile.lean", + "mode": "100644", + "type": "blob", + "sha": "287e013be6ff35e75ae2df854f08b7d158d3cfa1", + "size": 2923, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/287e013be6ff35e75ae2df854f08b7d158d3cfa1" + }, + { + "path": "research/gaussian-parity-synthesis/DyadicCertificates.lean", + "mode": "100644", + "type": "blob", + "sha": "b085247ab273f79e8fe1b1ef38bab0eb2b310856", + "size": 15741, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b085247ab273f79e8fe1b1ef38bab0eb2b310856" + }, + { + "path": "research/gaussian-parity-synthesis/FORMALIZATION_MAP.md", + "mode": "100644", + "type": "blob", + "sha": "4bdcb9eb9834299a31f233f99c9665152284cd8a", + "size": 9138, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4bdcb9eb9834299a31f233f99c9665152284cd8a" + }, + { + "path": "research/gaussian-parity-synthesis/FRAME_REVIEW.md", + "mode": "100644", + "type": "blob", + "sha": "cd82b4dc0cad7eed144eef347dea8a0ee23e5055", + "size": 4188, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cd82b4dc0cad7eed144eef347dea8a0ee23e5055" + }, + { + "path": "research/gaussian-parity-synthesis/GaussianLattice.lean", + "mode": "100644", + "type": "blob", + "sha": "4cca2a5e33b027298788124a34f07c76b88ecea5", + "size": 11097, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cca2a5e33b027298788124a34f07c76b88ecea5" + }, + { + "path": "research/gaussian-parity-synthesis/GaussianScalarCircuits.lean", + "mode": "100644", + "type": "blob", + "sha": "107dd78da427e8c388a18f561f5ac79c8200c7db", + "size": 26299, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/107dd78da427e8c388a18f561f5ac79c8200c7db" + }, + { + "path": "research/gaussian-parity-synthesis/GaussianTensorExecution.lean", + "mode": "100644", + "type": "blob", + "sha": "5c0acc70b2a1df8106c090a18b74f818be3a62c0", + "size": 15392, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5c0acc70b2a1df8106c090a18b74f818be3a62c0" + }, + { + "path": "research/gaussian-parity-synthesis/IMAGE_PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "d6d96e3e5954eb23e90bded7f1ded65b9768cdcd", + "size": 8344, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d6d96e3e5954eb23e90bded7f1ded65b9768cdcd" + }, + { + "path": "research/gaussian-parity-synthesis/LEDGER.md", + "mode": "100644", + "type": "blob", + "sha": "b80e6e2d70cde2d224a38eb0f9f16aa309780bdc", + "size": 15271, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b80e6e2d70cde2d224a38eb0f9f16aa309780bdc" + }, + { + "path": "research/gaussian-parity-synthesis/Makefile", + "mode": "100644", + "type": "blob", + "sha": "cb65f90b369a656ab325aea1a00f9671bc15effc", + "size": 376, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb65f90b369a656ab325aea1a00f9671bc15effc" + }, + { + "path": "research/gaussian-parity-synthesis/PAPER_REVIEW.md", + "mode": "100644", + "type": "blob", + "sha": "368f8c75240af581e6cc725b05a1567812d3ec12", + "size": 3208, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/368f8c75240af581e6cc725b05a1567812d3ec12" + }, + { + "path": "research/gaussian-parity-synthesis/PROVENANCE.md", + "mode": "100644", + "type": "blob", + "sha": "ca430efd4af6f4225acb5b9ed4e624bb4867fe5f", + "size": 2942, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca430efd4af6f4225acb5b9ed4e624bb4867fe5f" + }, + { + "path": "research/gaussian-parity-synthesis/README.md", + "mode": "100644", + "type": "blob", + "sha": "788d2718897ab80c8bbe2a8f7ac54b4229de3e0a", + "size": 6132, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/788d2718897ab80c8bbe2a8f7ac54b4229de3e0a" + }, + { + "path": "research/gaussian-parity-synthesis/REVIEW.md", + "mode": "100644", + "type": "blob", + "sha": "0a6a4c7c1e8bef9c9aa9c7fb636e5ad6c0c411ae", + "size": 5935, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0a6a4c7c1e8bef9c9aa9c7fb636e5ad6c0c411ae" + }, + { + "path": "research/gaussian-parity-synthesis/SOURCES.json", + "mode": "100644", + "type": "blob", + "sha": "54a45aa369519e024ea27d449b435e8ce58e4bff", + "size": 1594, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/54a45aa369519e024ea27d449b435e8ce58e4bff" + }, + { + "path": "research/gaussian-parity-synthesis/adapter-verification.json", + "mode": "100644", + "type": "blob", + "sha": "f0b3d7ec026fc1b29a003c80fe6e11499b56e65f", + "size": 475, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0b3d7ec026fc1b29a003c80fe6e11499b56e65f" + }, + { + "path": "research/gaussian-parity-synthesis/axiom-audit.log", + "mode": "100644", + "type": "blob", + "sha": "d0ef1424876d63459f36326ffb046f770de2e339", + "size": 14127, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d0ef1424876d63459f36326ffb046f770de2e339" + }, + { + "path": "research/gaussian-parity-synthesis/community-complex-profile.json", + "mode": "100644", + "type": "blob", + "sha": "6aa20540e9fd80765c7eb616220870247bcd5719", + "size": 1471, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6aa20540e9fd80765c7eb616220870247bcd5719" + }, + { + "path": "research/gaussian-parity-synthesis/community-parity-synthesis.pdf", + "mode": "100644", + "type": "blob", + "sha": "1502f01ff65633e7ac71e164de4aed8bd798b7fb", + "size": 70391, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1502f01ff65633e7ac71e164de4aed8bd798b7fb" + }, + { + "path": "research/gaussian-parity-synthesis/community-parity-synthesis.tex", + "mode": "100644", + "type": "blob", + "sha": "5cfa2cf150497b4d1a4aed0f6b816ed611cb0a31", + "size": 14709, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5cfa2cf150497b4d1a4aed0f6b816ed611cb0a31" + }, + { + "path": "research/gaussian-parity-synthesis/image-audit.log", + "mode": "100644", + "type": "blob", + "sha": "12fc7506bdad25c6b7e8551429f8e130f5eb24f2", + "size": 2980, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/12fc7506bdad25c6b7e8551429f8e130f5eb24f2" + }, + { + "path": "research/gaussian-parity-synthesis/lake-build.log", + "mode": "100644", + "type": "blob", + "sha": "3e49fe14c768a3eae2eb620fe16246db63d76ccb", + "size": 29068, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3e49fe14c768a3eae2eb620fe16246db63d76ccb" + }, + { + "path": "research/gaussian-parity-synthesis/lakefile.lean", + "mode": "100644", + "type": "blob", + "sha": "5d0b048fb71c3c7781142c3dce626df98bc301dd", + "size": 256, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d0b048fb71c3c7781142c3dce626df98bc301dd" + }, + { + "path": "research/gaussian-parity-synthesis/lean-toolchain", + "mode": "100644", + "type": "blob", + "sha": "561ad7126be6c074c10065993897d75d197961b1", + "size": 26, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/561ad7126be6c074c10065993897d75d197961b1" + }, + { + "path": "research/gaussian-parity-synthesis/ledger.json", + "mode": "100644", + "type": "blob", + "sha": "b69949f01e9dacbf45007afcb956f141c1a7b411", + "size": 45845, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b69949f01e9dacbf45007afcb956f141c1a7b411" + }, + { + "path": "research/gaussian-parity-synthesis/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "beba94fdb81b37cf7834a028e2336ee73878f686", + "size": 9189, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/beba94fdb81b37cf7834a028e2336ee73878f686" + }, + { + "path": "research/gaussian-parity-synthesis/mixed-center-verification.json", + "mode": "100644", + "type": "blob", + "sha": "b32071e6b34672e97057b0fe71edfb2f2417f0da", + "size": 5662, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b32071e6b34672e97057b0fe71edfb2f2417f0da" + }, + { + "path": "research/gaussian-parity-synthesis/mixed_center_adapter.py", + "mode": "100644", + "type": "blob", + "sha": "7d0346f98eab247d0838c785e1a3f2410f8c0ad6", + "size": 1076, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d0346f98eab247d0838c785e1a3f2410f8c0ad6" + }, + { + "path": "research/gaussian-parity-synthesis/phase-endpoint-verification.json", + "mode": "100644", + "type": "blob", + "sha": "b6db4aaf2e13e152460e6b712dd6862ddfe4fca9", + "size": 825, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b6db4aaf2e13e152460e6b712dd6862ddfe4fca9" + }, + { + "path": "research/gaussian-parity-synthesis/pi_exact.py", + "mode": "100644", + "type": "blob", + "sha": "ed987ad053c54474fd7af8c8a3ffb62378312309", + "size": 4315, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed987ad053c54474fd7af8c8a3ffb62378312309" + }, + { + "path": "research/gaussian-parity-synthesis/precision-profile-verification.json", + "mode": "100644", + "type": "blob", + "sha": "d4502d517c411bb5d13195bf3db2afb86dd2da0b", + "size": 1023, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d4502d517c411bb5d13195bf3db2afb86dd2da0b" + }, + { + "path": "research/gaussian-parity-synthesis/references", + "mode": "040000", + "type": "tree", + "sha": "0cd8e1013b4a4c9862eacbd67deb9d0bf600ef5d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0cd8e1013b4a4c9862eacbd67deb9d0bf600ef5d" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46", + "mode": "040000", + "type": "tree", + "sha": "1b73ec67e17cef8d4b8f10e19d290529da2e5fea", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1b73ec67e17cef8d4b8f10e19d290529da2e5fea" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "a8474f5c31dd4f0b24232ae1d4a274405b5bb677", + "size": 8538, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8474f5c31dd4f0b24232ae1d4a274405b5bb677" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/certificates", + "mode": "040000", + "type": "tree", + "sha": "204d7ed824d8d293ed84b674c66c4cd3b09be6d8", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/204d7ed824d8d293ed84b674c66c4cd3b09be6d8" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/certificates/copied-centers-complex-input.json", + "mode": "100644", + "type": "blob", + "sha": "368757d1b4867a78931e4fe671ac965bc047d4ea", + "size": 519, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/368757d1b4867a78931e4fe671ac965bc047d4ea" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/notes", + "mode": "040000", + "type": "tree", + "sha": "6c2f934b725929ffe1905e08cad82092dbfc9763", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6c2f934b725929ffe1905e08cad82092dbfc9763" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/notes/copied-centers-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "fddd7bc7f2a2f749ba6eada19d153bf9243ee31c", + "size": 4732, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fddd7bc7f2a2f749ba6eada19d153bf9243ee31c" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/notes/copied-centers-lemma.tex", + "mode": "100644", + "type": "blob", + "sha": "8933aaf508aa9d4c75ba1290913e02f6868d351d", + "size": 5328, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8933aaf508aa9d4c75ba1290913e02f6868d351d" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/notes/structured-bulk-complex.tex", + "mode": "100644", + "type": "blob", + "sha": "53868b41b2fe979cae9dae242ea0e0aef5681257", + "size": 5806, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/53868b41b2fe979cae9dae242ea0e0aef5681257" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/research", + "mode": "040000", + "type": "tree", + "sha": "ac1d814a3983487c284a9ef43c8e6100fadb2b17", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ac1d814a3983487c284a9ef43c8e6100fadb2b17" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/research/copied-fixed", + "mode": "040000", + "type": "tree", + "sha": "6f36d4d4d295ca5fe7f70fef8c47fd21fb62152c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6f36d4d4d295ca5fe7f70fef8c47fd21fb62152c" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/research/copied-fixed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "b5cbb678ebdb14d880aeec84cecbba82604591e0", + "size": 306657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b5cbb678ebdb14d880aeec84cecbba82604591e0" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts", + "mode": "040000", + "type": "tree", + "sha": "991a582bf45a2ea5eccf45bbda3a6922aaa648ac", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/991a582bf45a2ea5eccf45bbda3a6922aaa648ac" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/exclusion_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "aaa99986c4b81c5d4fbe016fd216a4818940bb95", + "size": 8658, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aaa99986c4b81c5d4fbe016fd216a4818940bb95" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/paired_exclusion_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "size": 2289, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/36d1fa2c0235b9b307243a8735e38a3fbf957113" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/paired_triple_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "6b10e490b7601c212df889affe06736925f15281", + "size": 5625, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6b10e490b7601c212df889affe06736925f15281" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/partial_swap", + "mode": "040000", + "type": "tree", + "sha": "5940d8bd9f598a6af777b5121b9ab2a34e86a715", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5940d8bd9f598a6af777b5121b9ab2a34e86a715" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/partial_swap/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "ba99c12519d14b27975fb49fc713d9f109b6535c", + "size": 281, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ba99c12519d14b27975fb49fc713d9f109b6535c" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/partial_swap/binary.py", + "mode": "100644", + "type": "blob", + "sha": "69a398e9afe3b3118f30996aba36e0b733f2f5f7", + "size": 1010, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/69a398e9afe3b3118f30996aba36e0b733f2f5f7" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/structured_bulk", + "mode": "040000", + "type": "tree", + "sha": "14661c945928a9cf0b63c9baaa2f4b9870190e9f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/14661c945928a9cf0b63c9baaa2f4b9870190e9f" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/structured_bulk/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "423fb75fd37fd52482a60c99589c4e4d7d815a27", + "size": 75, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/423fb75fd37fd52482a60c99589c4e4d7d815a27" + }, + { + "path": "research/gaussian-parity-synthesis/references/pr46/scripts/structured_bulk/complex.py", + "mode": "100644", + "type": "blob", + "sha": "f1e27c6a100c6a8f974f77c4029c92218c9fce9f", + "size": 9987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f1e27c6a100c6a8f974f77c4029c92218c9fce9f" + }, + { + "path": "research/gaussian-parity-synthesis/verify.ps1", + "mode": "100644", + "type": "blob", + "sha": "b1d1ae43abfdce984b289121e85217c1f340bb9e", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b1d1ae43abfdce984b289121e85217c1f340bb9e" + }, + { + "path": "research/gaussian-parity-synthesis/verify_adapter.py", + "mode": "100644", + "type": "blob", + "sha": "4c16f205a0abbbf7305fbaebf44744945ffd9e5e", + "size": 1601, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4c16f205a0abbbf7305fbaebf44744945ffd9e5e" + }, + { + "path": "research/gaussian-parity-synthesis/verify_mixed_center_image.py", + "mode": "100644", + "type": "blob", + "sha": "44f5a7f8b397a164f3f8d02279836536154b8be0", + "size": 16897, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/44f5a7f8b397a164f3f8d02279836536154b8be0" + }, + { + "path": "research/gaussian-parity-synthesis/verify_phase_endpoint.py", + "mode": "100644", + "type": "blob", + "sha": "368818411d28c55f17f745ec05e8f80f3509bdea", + "size": 4910, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/368818411d28c55f17f745ec05e8f80f3509bdea" + }, + { + "path": "research/gaussian-parity-synthesis/verify_precision_profile.py", + "mode": "100644", + "type": "blob", + "sha": "9b9cfdf51af0473ca05c2b2e2dfa4834f25ee552", + "size": 2825, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9b9cfdf51af0473ca05c2b2e2dfa4834f25ee552" + }, + { + "path": "research/gaussian-parity", + "mode": "040000", + "type": "tree", + "sha": "9fca83e893254fda00369789c21986dc876b4dec", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9fca83e893254fda00369789c21986dc876b4dec" + }, + { + "path": "research/gaussian-parity/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "023121239553deb9d58c9abb942d006d7271fe56", + "size": 148, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/023121239553deb9d58c9abb942d006d7271fe56" + }, + { + "path": "research/gaussian-parity/AuditAll.lean", + "mode": "100644", + "type": "blob", + "sha": "82104604d13f4882a8e9ceac0e4f484deee7b44e", + "size": 3358, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/82104604d13f4882a8e9ceac0e4f484deee7b44e" + }, + { + "path": "research/gaussian-parity/DyadicCertificates.lean", + "mode": "100644", + "type": "blob", + "sha": "b085247ab273f79e8fe1b1ef38bab0eb2b310856", + "size": 15741, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b085247ab273f79e8fe1b1ef38bab0eb2b310856" + }, + { + "path": "research/gaussian-parity/FORMALIZATION_MAP.md", + "mode": "100644", + "type": "blob", + "sha": "ed50f2344fda227e3d85c57b6d7ed2f326649348", + "size": 5282, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed50f2344fda227e3d85c57b6d7ed2f326649348" + }, + { + "path": "research/gaussian-parity/GaussianLattice.lean", + "mode": "100644", + "type": "blob", + "sha": "4cca2a5e33b027298788124a34f07c76b88ecea5", + "size": 11097, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cca2a5e33b027298788124a34f07c76b88ecea5" + }, + { + "path": "research/gaussian-parity/Makefile", + "mode": "100644", + "type": "blob", + "sha": "c8feb3ca9ba33f5009c595e766c82debb6844c51", + "size": 166, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8feb3ca9ba33f5009c595e766c82debb6844c51" + }, + { + "path": "research/gaussian-parity/PROVENANCE.md", + "mode": "100644", + "type": "blob", + "sha": "f1b8f7982f6fbd29826d0ae3aea2541a6cfa1f2f", + "size": 3214, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f1b8f7982f6fbd29826d0ae3aea2541a6cfa1f2f" + }, + { + "path": "research/gaussian-parity/README.md", + "mode": "100644", + "type": "blob", + "sha": "5759defeead8b614e480467275c76f345e92c406", + "size": 4103, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5759defeead8b614e480467275c76f345e92c406" + }, + { + "path": "research/gaussian-parity/axiom-audit.log", + "mode": "100644", + "type": "blob", + "sha": "eb783849505914249e0f75db9de6ec81834c526d", + "size": 5624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb783849505914249e0f75db9de6ec81834c526d" + }, + { + "path": "research/gaussian-parity/gaussian-parity-certificates.pdf", + "mode": "100644", + "type": "blob", + "sha": "d4bfe769db698d4a06a47eba3dbfeed77c3759f7", + "size": 81305, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d4bfe769db698d4a06a47eba3dbfeed77c3759f7" + }, + { + "path": "research/gaussian-parity/gaussian-parity-certificates.tex", + "mode": "100644", + "type": "blob", + "sha": "e364cff719a12a5dfd52f2975cd07cc0318da511", + "size": 21007, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e364cff719a12a5dfd52f2975cd07cc0318da511" + }, + { + "path": "research/gaussian-parity/kernel-check.log", + "mode": "100644", + "type": "blob", + "sha": "5ea5a53b7667d7b96294e77b61ab2c639188dcab", + "size": 2591, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5ea5a53b7667d7b96294e77b61ab2c639188dcab" + }, + { + "path": "research/gaussian-parity/lake-build.log", + "mode": "100644", + "type": "blob", + "sha": "c2c6c77b06782568026876b54bd05e9f62977200", + "size": 10966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c2c6c77b06782568026876b54bd05e9f62977200" + }, + { + "path": "research/gaussian-parity/lakefile.lean", + "mode": "100644", + "type": "blob", + "sha": "de88a50718a288f04d7d8ab79f679ccf071e4695", + "size": 180, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de88a50718a288f04d7d8ab79f679ccf071e4695" + }, + { + "path": "research/gaussian-parity/lean-toolchain", + "mode": "100644", + "type": "blob", + "sha": "18640c8b066b182147f324d3aefd8ee48ee45238", + "size": 25, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/18640c8b066b182147f324d3aefd8ee48ee45238" + }, + { + "path": "research/gaussian-parity/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "56757a78521808f285ec3fe9a6e5bc7cef176777", + "size": 5738, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/56757a78521808f285ec3fe9a6e5bc7cef176777" + }, + { + "path": "research/gaussian-parity/repo-unit-tests.log", + "mode": "100644", + "type": "blob", + "sha": "6f717475d5d55bd669536fd91fe6dcb528087ab4", + "size": 26688, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6f717475d5d55bd669536fd91fe6dcb528087ab4" + }, + { + "path": "research/gaussian-parity/verification.json", + "mode": "100644", + "type": "blob", + "sha": "a3098adbc841bedde59d2ae7a9a1b09085835d51", + "size": 605, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a3098adbc841bedde59d2ae7a9a1b09085835d51" + }, + { + "path": "research/gaussian-parity/verify.ps1", + "mode": "100644", + "type": "blob", + "sha": "27244523f3ac70bffa88c973d95048dfe918babd", + "size": 763, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/27244523f3ac70bffa88c973d95048dfe918babd" + }, + { + "path": "research/gaussian-parity/verify_exact.py", + "mode": "100644", + "type": "blob", + "sha": "82815ea2d177e696ed7cc5fdae6908ab37686618", + "size": 5700, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/82815ea2d177e696ed7cc5fdae6908ab37686618" + }, + { + "path": "research/joint-dual", + "mode": "040000", + "type": "tree", + "sha": "4904b5cde34813b341a6c6fab79e7abf692415d2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/4904b5cde34813b341a6c6fab79e7abf692415d2" + }, + { + "path": "research/joint-dual/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "39a51caf8280160f0fce1ca550074b97c6330238", + "size": 13990, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39a51caf8280160f0fce1ca550074b97c6330238" + }, + { + "path": "research/joint-dual/README.md", + "mode": "100644", + "type": "blob", + "sha": "eb2740369fa45d8eb0c7ed188a0a540527214166", + "size": 2966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb2740369fa45d8eb0c7ed188a0a540527214166" + }, + { + "path": "research/joint-dual/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "ff8cf2ab100ca13d099347c8375b20ffe4e13594", + "size": 6620, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff8cf2ab100ca13d099347c8375b20ffe4e13594" + }, + { + "path": "research/matrix-exponent-synthesis", + "mode": "040000", + "type": "tree", + "sha": "a7c30b1462b86ee6af7f372b3224b916cc2cfafe", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/a7c30b1462b86ee6af7f372b3224b916cc2cfafe" + }, + { + "path": "research/matrix-exponent-synthesis/.gitattributes", + "mode": "100644", + "type": "blob", + "sha": "4233cbd8933880d0df38211bc93b40ab8261bb4b", + "size": 23, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4233cbd8933880d0df38211bc93b40ab8261bb4b" + }, + { + "path": "research/matrix-exponent-synthesis/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "063fac83bfc0a613261e611a5d4af51874613714", + "size": 56, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/063fac83bfc0a613261e611a5d4af51874613714" + }, + { + "path": "research/matrix-exponent-synthesis/AuditAll.lean", + "mode": "100644", + "type": "blob", + "sha": "ce014e062feebba9e487d01cfcbb70d67998339c", + "size": 9357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ce014e062feebba9e487d01cfcbb70d67998339c" + }, + { + "path": "research/matrix-exponent-synthesis/CommutingPhases.lean", + "mode": "100644", + "type": "blob", + "sha": "211731b636fbb5792ab9306d9190ce757cb53dff", + "size": 1889, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/211731b636fbb5792ab9306d9190ce757cb53dff" + }, + { + "path": "research/matrix-exponent-synthesis/DyadicCertificates.lean", + "mode": "100644", + "type": "blob", + "sha": "b085247ab273f79e8fe1b1ef38bab0eb2b310856", + "size": 15741, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b085247ab273f79e8fe1b1ef38bab0eb2b310856" + }, + { + "path": "research/matrix-exponent-synthesis/FeasibilityNormalForm.lean", + "mode": "100644", + "type": "blob", + "sha": "40531a4409017f682d5674ae2bd70d6cfa447f15", + "size": 584, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/40531a4409017f682d5674ae2bd70d6cfa447f15" + }, + { + "path": "research/matrix-exponent-synthesis/FiniteRationalChecks.lean", + "mode": "100644", + "type": "blob", + "sha": "089a80bedf4eb78e7e89049c1f5bb0746466dcea", + "size": 3478, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/089a80bedf4eb78e7e89049c1f5bb0746466dcea" + }, + { + "path": "research/matrix-exponent-synthesis/GaussProduct3.lean", + "mode": "100644", + "type": "blob", + "sha": "ef8fe1ab8159cd19cb70ffc0e94af13fbe147929", + "size": 1204, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ef8fe1ab8159cd19cb70ffc0e94af13fbe147929" + }, + { + "path": "research/matrix-exponent-synthesis/GaussianLattice.lean", + "mode": "100644", + "type": "blob", + "sha": "4cca2a5e33b027298788124a34f07c76b88ecea5", + "size": 11097, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cca2a5e33b027298788124a34f07c76b88ecea5" + }, + { + "path": "research/matrix-exponent-synthesis/GaussianScalarCircuits.lean", + "mode": "100644", + "type": "blob", + "sha": "107dd78da427e8c388a18f561f5ac79c8200c7db", + "size": 26299, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/107dd78da427e8c388a18f561f5ac79c8200c7db" + }, + { + "path": "research/matrix-exponent-synthesis/LateQuotient.lean", + "mode": "100644", + "type": "blob", + "sha": "fcc1bd695cf67755847d33050deafa95d008ce4e", + "size": 2421, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fcc1bd695cf67755847d33050deafa95d008ce4e" + }, + { + "path": "research/matrix-exponent-synthesis/MatchingDual.lean", + "mode": "100644", + "type": "blob", + "sha": "560d4a99caf355248cf4d37f9f125f87731ae8f3", + "size": 5851, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/560d4a99caf355248cf4d37f9f125f87731ae8f3" + }, + { + "path": "research/matrix-exponent-synthesis/README.md", + "mode": "100644", + "type": "blob", + "sha": "a5c63ce20f3383ca1338c67a7f7c8b59efd5385e", + "size": 4966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5c63ce20f3383ca1338c67a7f7c8b59efd5385e" + }, + { + "path": "research/matrix-exponent-synthesis/RefinedFrontierCertificate.lean", + "mode": "100644", + "type": "blob", + "sha": "d422e79ee0892cf65711e058c9cebda82ad65d0e", + "size": 11850, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d422e79ee0892cf65711e058c9cebda82ad65d0e" + }, + { + "path": "research/matrix-exponent-synthesis/SharpQuotient.lean", + "mode": "100644", + "type": "blob", + "sha": "44165bf89549f5d5894557b682ad516aa5153a47", + "size": 2385, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/44165bf89549f5d5894557b682ad516aa5153a47" + }, + { + "path": "research/matrix-exponent-synthesis/audit", + "mode": "040000", + "type": "tree", + "sha": "695f984791dc1a8e99bb2229652f00a36fe760c2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/695f984791dc1a8e99bb2229652f00a36fe760c2" + }, + { + "path": "research/matrix-exponent-synthesis/audit/bilinear_projection.py", + "mode": "100644", + "type": "blob", + "sha": "2e0f1809ae53f150f3232900c3e868ced61a9478", + "size": 2569, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e0f1809ae53f150f3232900c3e868ced61a9478" + }, + { + "path": "research/matrix-exponent-synthesis/audit/independent_matrix_check.py", + "mode": "100644", + "type": "blob", + "sha": "270a7391dc8a47bb389043c7215e21fcca558c90", + "size": 2974, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/270a7391dc8a47bb389043c7215e21fcca558c90" + }, + { + "path": "research/matrix-exponent-synthesis/audit/matrix_two_adic_lift.py", + "mode": "100644", + "type": "blob", + "sha": "fc0236f65823082c585dafedf054c81046fe34a0", + "size": 2445, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fc0236f65823082c585dafedf054c81046fe34a0" + }, + { + "path": "research/matrix-exponent-synthesis/audit/phase_child_closure.py", + "mode": "100644", + "type": "blob", + "sha": "50dcbb3eed69db34524b31bef245993d48e00341", + "size": 2516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50dcbb3eed69db34524b31bef245993d48e00341" + }, + { + "path": "research/matrix-exponent-synthesis/audit/phase_operator_audit.py", + "mode": "100644", + "type": "blob", + "sha": "acd40d166c25de0262102c7e2ecada5c756f3655", + "size": 4226, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/acd40d166c25de0262102c7e2ecada5c756f3655" + }, + { + "path": "research/matrix-exponent-synthesis/audit/source_ci_audit.py", + "mode": "100644", + "type": "blob", + "sha": "a5f3b792af79e41ad088b1a7a1032b04b293b7f3", + "size": 2089, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5f3b792af79e41ad088b1a7a1032b04b293b7f3" + }, + { + "path": "research/matrix-exponent-synthesis/bridge", + "mode": "040000", + "type": "tree", + "sha": "075847dc9d7daeeebd664550671b96de134d747a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/075847dc9d7daeeebd664550671b96de134d747a" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/pr48", + "mode": "040000", + "type": "tree", + "sha": "465eb9f2a653c7d0d4ca5d915fcc4f4c3236e3c2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/465eb9f2a653c7d0d4ca5d915fcc4f4c3236e3c2" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/pr48/research", + "mode": "040000", + "type": "tree", + "sha": "9d2a390d678026c7cdcf67eafb0b17524fbacb97", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9d2a390d678026c7cdcf67eafb0b17524fbacb97" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/pr48/research/copied-fixed", + "mode": "040000", + "type": "tree", + "sha": "8e3a8880f386759c180ebb09c0cb54441ad9c539", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8e3a8880f386759c180ebb09c0cb54441ad9c539" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/pr48/research/copied-fixed/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "fa4b29c06df8e317c4074db4b8385622e9e27261", + "size": 308516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fa4b29c06df8e317c4074db4b8385622e9e27261" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/swap-composition-search", + "mode": "040000", + "type": "tree", + "sha": "ea739bd9a40b79b52703c764f97d5a7481971920", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ea739bd9a40b79b52703c764f97d5a7481971920" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/swap-composition-search/h23-g2-tail0-b2-pr47-even", + "mode": "040000", + "type": "tree", + "sha": "6d641a4565af1db22e3c237a9aee8d4305d8b58e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6d641a4565af1db22e3c237a9aee8d4305d8b58e" + }, + { + "path": "research/matrix-exponent-synthesis/bridge/swap-composition-search/h23-g2-tail0-b2-pr47-even/edges.txt", + "mode": "100644", + "type": "blob", + "sha": "c06c9688973d2def1740e915ede2c372f3c0d2a1", + "size": 379603, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c06c9688973d2def1740e915ede2c372f3c0d2a1" + }, + { + "path": "research/matrix-exponent-synthesis/candidate", + "mode": "040000", + "type": "tree", + "sha": "ddaf0fb22794ca63aa9708eb734abc9d467e5ac2", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ddaf0fb22794ca63aa9708eb734abc9d467e5ac2" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/README.md", + "mode": "100644", + "type": "blob", + "sha": "ee76923fb959acc2ad4fc578d79d6be4fea74113", + "size": 1853, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ee76923fb959acc2ad4fc578d79d6be4fea74113" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/arithmetic-verification.json", + "mode": "100644", + "type": "blob", + "sha": "65093fa88971f9dbca8ba27d1d268d50108b6c2e", + "size": 710, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65093fa88971f9dbca8ba27d1d268d50108b6c2e" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "f2fe2550ca73987999940ad1536a8e4133fe739c", + "size": 44726, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2fe2550ca73987999940ad1536a8e4133fe739c" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/generate_frontier_case.py", + "mode": "100644", + "type": "blob", + "sha": "b59e6409a12b3fcf0a6fc1045db879f1e727f9d4", + "size": 6541, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b59e6409a12b3fcf0a6fc1045db879f1e727f9d4" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/pinned62-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "d88d1f18fe874f7c87b6b910dad3f42c06aa49be", + "size": 31738, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d88d1f18fe874f7c87b6b910dad3f42c06aa49be" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/refined62-lean-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "576b1cf7554debbe0ec7e22a808c9f1932d005dc", + "size": 2207, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/576b1cf7554debbe0ec7e22a808c9f1932d005dc" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/verify_refinement.py", + "mode": "100644", + "type": "blob", + "sha": "c2bde7a6347b72e2b6c201b395a2cd1452b3cd8f", + "size": 3665, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c2bde7a6347b72e2b6c201b395a2cd1452b3cd8f" + }, + { + "path": "research/matrix-exponent-synthesis/candidate/weighted-lean-input.json", + "mode": "100644", + "type": "blob", + "sha": "77d80c01f895c2b1c0530b1ff92e255b3a3d3a44", + "size": 28750, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/77d80c01f895c2b1c0530b1ff92e255b3a3d3a44" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue", + "mode": "040000", + "type": "tree", + "sha": "1b67c1aed077c884c23935d8e730109bb483e84d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1b67c1aed077c884c23935d8e730109bb483e84d" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/MATCHING_SEARCH.md", + "mode": "100644", + "type": "blob", + "sha": "c9bd354401cb724c0cea4f3d035561b2e3dc77ef", + "size": 4543, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c9bd354401cb724c0cea4f3d035561b2e3dc77ef" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/README.md", + "mode": "100644", + "type": "blob", + "sha": "4c51c4ae72362361f2d28528f922e4654993e494", + "size": 5188, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4c51c4ae72362361f2d28528f922e4654993e494" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/all-cardinality-h25-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "cf611fe4e7b7b9509b8aec9d2ac8f10c3efe8c60", + "size": 767418, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cf611fe4e7b7b9509b8aec9d2ac8f10c3efe8c60" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/all-cardinality-stdlib-replay.json", + "mode": "100644", + "type": "blob", + "sha": "f1d458289b805d1d1b962c4045c5c000390fe486", + "size": 404, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f1d458289b805d1d1b962c4045c5c000390fe486" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/all_cardinality_certificate.py", + "mode": "100644", + "type": "blob", + "sha": "8655f816777e23c0357fa985caffdccfaeef94f0", + "size": 5260, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8655f816777e23c0357fa985caffdccfaeef94f0" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/assignment-audit-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "dce9a565fd5c8ed181c1f712162b7d2f0ff26aa6", + "size": 8801, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dce9a565fd5c8ed181c1f712162b7d2f0ff26aa6" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/assignment_certificate.py", + "mode": "100644", + "type": "blob", + "sha": "17429e8dcb6fd99651d51be97a02fb517b424e26", + "size": 13903, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/17429e8dcb6fd99651d51be97a02fb517b424e26" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/audit-receipt-pr48-final.json", + "mode": "100644", + "type": "blob", + "sha": "7c436d2b91b03c0be80324b8b398e9404c61af87", + "size": 20424, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7c436d2b91b03c0be80324b8b398e9404c61af87" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/audit_assignment_certificates.py", + "mode": "100644", + "type": "blob", + "sha": "a7785736e867fb5495ffb0504aaa887dad301cbe", + "size": 7032, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a7785736e867fb5495ffb0504aaa887dad301cbe" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/audit_catalogue.py", + "mode": "100644", + "type": "blob", + "sha": "5042a8663b7bcfcd2eedf46f0ce256db6c562eb5", + "size": 11849, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5042a8663b7bcfcd2eedf46f0ce256db6c562eb5" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/catalogue.py", + "mode": "100644", + "type": "blob", + "sha": "ed340bde1db31b209f033e8786598e44b32b3248", + "size": 27145, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed340bde1db31b209f033e8786598e44b32b3248" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/community-pr49-announcement-snapshot.json", + "mode": "100644", + "type": "blob", + "sha": "91e4e03be296bce629f6d6484ed7e0c45e510507", + "size": 4030, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/91e4e03be296bce629f6d6484ed7e0c45e510507" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/fixed-dag-dual-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "75ac130a91a11269a1e64554cb7d4a3e28932c84", + "size": 339248, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/75ac130a91a11269a1e64554cb7d4a3e28932c84" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/fixed-dag-h23-dual-final.json", + "mode": "100644", + "type": "blob", + "sha": "6c2e9738795aeb26d200c7338399470f8aac2a9d", + "size": 341090, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c2e9738795aeb26d200c7338399470f8aac2a9d" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/fixed-dag-h23-selected-dual.json", + "mode": "100644", + "type": "blob", + "sha": "fffc4c2074bd8c4c36b85fe109003fd06d723d7f", + "size": 340142, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fffc4c2074bd8c4c36b85fe109003fd06d723d7f" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/fixed-dag-h25-dual-final.json", + "mode": "100644", + "type": "blob", + "sha": "deabea7e5c19b62d1ec761e9f8baaddfb7d427e4", + "size": 454882, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/deabea7e5c19b62d1ec761e9f8baaddfb7d427e4" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/fixed-dag-h25-selected-dual.json", + "mode": "100644", + "type": "blob", + "sha": "fb3e92401929e15807a9132f5b7a8871d08e65df", + "size": 455870, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fb3e92401929e15807a9132f5b7a8871d08e65df" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/h23-even-integer-costs.tsv", + "mode": "100644", + "type": "blob", + "sha": "f7636f2f3c5c4f31b224c8969d7b21de317661d9", + "size": 558786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f7636f2f3c5c4f31b224c8969d7b21de317661d9" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/h23-selected-integer-costs.tsv", + "mode": "100644", + "type": "blob", + "sha": "f781e3648212b33f647cc1e6e564a5914b61d974", + "size": 560445, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f781e3648212b33f647cc1e6e564a5914b61d974" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/h25-full-integer-costs.tsv", + "mode": "100644", + "type": "blob", + "sha": "5e52446ff553a08576684ec2e644ac61465d3cf1", + "size": 745316, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e52446ff553a08576684ec2e644ac61465d3cf1" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/h25-selected-integer-costs.tsv", + "mode": "100644", + "type": "blob", + "sha": "b1e15ddaefcbeaaa104eef08667aa1b3e7f8da41", + "size": 752402, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b1e15ddaefcbeaaa104eef08667aa1b3e7f8da41" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs", + "mode": "040000", + "type": "tree", + "sha": "da49d3d09cddaa8b310f15e65063d4da763cb9df", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/da49d3d09cddaa8b310f15e65063d4da763cb9df" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/community-pr46-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "b5cbb678ebdb14d880aeec84cecbba82604591e0", + "size": 306657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b5cbb678ebdb14d880aeec84cecbba82604591e0" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/community-pr48-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "fa4b29c06df8e317c4074db4b8385622e9e27261", + "size": 308516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fa4b29c06df8e317c4074db4b8385622e9e27261" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching", + "mode": "040000", + "type": "tree", + "sha": "2ae79a06ee1f5e86821e66d3b186137e9e24df3c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2ae79a06ee1f5e86821e66d3b186137e9e24df3c" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching/h23-even-edges.txt", + "mode": "100644", + "type": "blob", + "sha": "c06c9688973d2def1740e915ede2c372f3c0d2a1", + "size": 379603, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c06c9688973d2def1740e915ede2c372f3c0d2a1" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching/h23-selected-edges.txt", + "mode": "100644", + "type": "blob", + "sha": "18baaa9cc8dfb0d3659e0a0909fdd0c870639bee", + "size": 381625, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/18baaa9cc8dfb0d3659e0a0909fdd0c870639bee" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching/h25-full-edges.txt", + "mode": "100644", + "type": "blob", + "sha": "fbd642e86bf257e4d2be82aea5a4730856d7a5a6", + "size": 515319, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fbd642e86bf257e4d2be82aea5a4730856d7a5a6" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching/h25-physical-first-order.uses", + "mode": "100644", + "type": "blob", + "sha": "c166f0f2f2810bc953acd0768256be2a2797f8f7", + "size": 63160, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c166f0f2f2810bc953acd0768256be2a2797f8f7" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/matching/h25-selected-edges.txt", + "mode": "100644", + "type": "blob", + "sha": "f591ba6c770e53c588ed9abef71fcfb10b23d106", + "size": 522143, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f591ba6c770e53c588ed9abef71fcfb10b23d106" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/inputs/outer48.json", + "mode": "100644", + "type": "blob", + "sha": "cb71fb2b3ab2c1c2033708151a833bd08e5aee4e", + "size": 98643, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb71fb2b3ab2c1c2033708151a833bd08e5aee4e" + }, + { + "path": "research/matrix-exponent-synthesis/catalogue/q16-search.json", + "mode": "100644", + "type": "blob", + "sha": "a831ce931baa10bd3fd5bf2af48d430e45ac551a", + "size": 6196, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a831ce931baa10bd3fd5bf2af48d430e45ac551a" + }, + { + "path": "research/matrix-exponent-synthesis/gaussian_matrix.py", + "mode": "100644", + "type": "blob", + "sha": "5245a2d6f133c2f13556e0e8be8e7770e3cd1936", + "size": 3062, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5245a2d6f133c2f13556e0e8be8e7770e3cd1936" + }, + { + "path": "research/matrix-exponent-synthesis/hierarchical_gaussian_matrix.py", + "mode": "100644", + "type": "blob", + "sha": "f7971e945155c08819d81a29263a94c5ede2e1fc", + "size": 3824, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f7971e945155c08819d81a29263a94c5ede2e1fc" + }, + { + "path": "research/matrix-exponent-synthesis/history", + "mode": "040000", + "type": "tree", + "sha": "159209aaab81d82d3052d424027dfb71b56aaa12", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/159209aaab81d82d3052d424027dfb71b56aaa12" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58", + "mode": "040000", + "type": "tree", + "sha": "b08242d618d7fa8fa8aab7f876d9fac2b6e2b3be", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/b08242d618d7fa8fa8aab7f876d9fac2b6e2b3be" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/RefinedFrontierCertificate.lean", + "mode": "100644", + "type": "blob", + "sha": "9f7459a2de352d1977653a1b1409a71264c0b421", + "size": 11925, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9f7459a2de352d1977653a1b1409a71264c0b421" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate", + "mode": "040000", + "type": "tree", + "sha": "bdf14c31d5a6bd2a0e9619d017e231ffae5cf4f6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/bdf14c31d5a6bd2a0e9619d017e231ffae5cf4f6" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/README.md", + "mode": "100644", + "type": "blob", + "sha": "746e730027a1d4a5fdd0d1aa753c0cdca495972d", + "size": 1999, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/746e730027a1d4a5fdd0d1aa753c0cdca495972d" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/arithmetic-verification.json", + "mode": "100644", + "type": "blob", + "sha": "8ce75c2ebcc24f897342dc7c0337db7719b6ac3b", + "size": 687, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8ce75c2ebcc24f897342dc7c0337db7719b6ac3b" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "ff026357f6018d35db606fb7588a125ce94f9c69", + "size": 47326, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff026357f6018d35db606fb7588a125ce94f9c69" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/generate_frontier_case.py", + "mode": "100644", + "type": "blob", + "sha": "b59e6409a12b3fcf0a6fc1045db879f1e727f9d4", + "size": 6541, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b59e6409a12b3fcf0a6fc1045db879f1e727f9d4" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/pinned58-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "c095bb93ad34a4f2a9391691a4b13684c4e97ee8", + "size": 35627, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c095bb93ad34a4f2a9391691a4b13684c4e97ee8" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/refined58-lean-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "f85b51eec586f7b677cdccf85ba58c0178bf1d83", + "size": 1860, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f85b51eec586f7b677cdccf85ba58c0178bf1d83" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/verify_refinement.py", + "mode": "100644", + "type": "blob", + "sha": "4a34f94674e3bfd53a506f21c5ef4bcede0e7f03", + "size": 3624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4a34f94674e3bfd53a506f21c5ef4bcede0e7f03" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/candidate/weighted-lean-input.json", + "mode": "100644", + "type": "blob", + "sha": "fe87435a6bf7b8cb816932c125659f4fd7f3cb92", + "size": 29039, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fe87435a6bf7b8cb816932c125659f4fd7f3cb92" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr58/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "16ac642a2e17dcc12b3f7e5214d5cac3b8710f47", + "size": 25473, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/16ac642a2e17dcc12b3f7e5214d5cac3b8710f47" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60", + "mode": "040000", + "type": "tree", + "sha": "e04bf44bba1a05fbeba29bf1cf32657412dd26e3", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e04bf44bba1a05fbeba29bf1cf32657412dd26e3" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/RefinedFrontierCertificate.lean", + "mode": "100644", + "type": "blob", + "sha": "f6709fff4cd5db69be44f9959c6cb9619345994e", + "size": 11911, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f6709fff4cd5db69be44f9959c6cb9619345994e" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate", + "mode": "040000", + "type": "tree", + "sha": "525f2215bacd850909c58d6ba61b0bf6853a44ac", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/525f2215bacd850909c58d6ba61b0bf6853a44ac" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/README.md", + "mode": "100644", + "type": "blob", + "sha": "459211d08de491b3c3be1f142165962e1805fa1e", + "size": 2061, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/459211d08de491b3c3be1f142165962e1805fa1e" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/arithmetic-verification.json", + "mode": "100644", + "type": "blob", + "sha": "b6f35a06a4f1f49e893279aaf276719289d3c8e3", + "size": 765, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b6f35a06a4f1f49e893279aaf276719289d3c8e3" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/arithmetic.json", + "mode": "100644", + "type": "blob", + "sha": "d617c1619fddbb3f0efd562e1d2081561e44038d", + "size": 47407, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d617c1619fddbb3f0efd562e1d2081561e44038d" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/generate_frontier_case.py", + "mode": "100644", + "type": "blob", + "sha": "b59e6409a12b3fcf0a6fc1045db879f1e727f9d4", + "size": 6541, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b59e6409a12b3fcf0a6fc1045db879f1e727f9d4" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/pinned60-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "423e1cdcabf1b1cb2796cdfb3a703a9c99e1da27", + "size": 37861, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/423e1cdcabf1b1cb2796cdfb3a703a9c99e1da27" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/refined60-lean-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "82c0594f704448aad7512d30641e3ac1ef94c414", + "size": 2448, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/82c0594f704448aad7512d30641e3ac1ef94c414" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/verify_refinement.py", + "mode": "100644", + "type": "blob", + "sha": "b8e9196c2e24f037c115225ec2a8feba30ef0e4f", + "size": 3624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b8e9196c2e24f037c115225ec2a8feba30ef0e4f" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/candidate/weighted-lean-input.json", + "mode": "100644", + "type": "blob", + "sha": "b79b40060874056d5b3ed760b09fdd8482f55b64", + "size": 28988, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b79b40060874056d5b3ed760b09fdd8482f55b64" + }, + { + "path": "research/matrix-exponent-synthesis/history/pr60/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "6306f2ba19c620fd0fb3327beeeae3d14aa9ef9d", + "size": 25562, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6306f2ba19c620fd0fb3327beeeae3d14aa9ef9d" + }, + { + "path": "research/matrix-exponent-synthesis/lakefile.lean", + "mode": "100644", + "type": "blob", + "sha": "204554d7a9d30023600dff14341fdd0a1c8bbd26", + "size": 359, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/204554d7a9d30023600dff14341fdd0a1c8bbd26" + }, + { + "path": "research/matrix-exponent-synthesis/lean-toolchain", + "mode": "100644", + "type": "blob", + "sha": "561ad7126be6c074c10065993897d75d197961b1", + "size": 26, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/561ad7126be6c074c10065993897d75d197961b1" + }, + { + "path": "research/matrix-exponent-synthesis/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "12f47ca060ec44701e5f99511fc427a5a4556256", + "size": 25422, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/12f47ca060ec44701e5f99511fc427a5a4556256" + }, + { + "path": "research/matrix-exponent-synthesis/matrix-exponent-synthesis.tex", + "mode": "100644", + "type": "blob", + "sha": "a5d23a18cc451a2198016b42e6c71911b27a9ab9", + "size": 17012, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5d23a18cc451a2198016b42e6c71911b27a9ab9" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source", + "mode": "040000", + "type": "tree", + "sha": "0620209003f86f108b82f7dfa3ada4b2b0157566", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0620209003f86f108b82f7dfa3ada4b2b0157566" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07", + "mode": "040000", + "type": "tree", + "sha": "9236d420fa28f78f7cd9138285a594e3a5806006", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9236d420fa28f78f7cd9138285a594e3a5806006" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "8aae8792c1e18567b558545ad62748a6ba6bfa9d", + "size": 75, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8aae8792c1e18567b558545ad62748a6ba6bfa9d" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/CURRENT_GUIDE.md", + "mode": "100644", + "type": "blob", + "sha": "a7ee6518733389a98605217b8b25c46dcaeae23d", + "size": 2799, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a7ee6518733389a98605217b8b25c46dcaeae23d" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/README.md", + "mode": "100644", + "type": "blob", + "sha": "37cf07177bd68b329d7ce3b7040fb2de65ccf745", + "size": 2977, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/37cf07177bd68b329d7ce3b7040fb2de65ccf745" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/README_FINAL_INTEGER_EXTENSION.md", + "mode": "100644", + "type": "blob", + "sha": "0450a7e3d835bdf58b57b7b6557a2cfb25546ffe", + "size": 2450, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0450a7e3d835bdf58b57b7b6557a2cfb25546ffe" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit", + "mode": "040000", + "type": "tree", + "sha": "850705819ba6f51e3d121015264d14bbe911219e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/850705819ba6f51e3d121015264d14bbe911219e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/README.md", + "mode": "100644", + "type": "blob", + "sha": "2cd6a569c29f301a9de8e6d3540c2f6a87cf0bb3", + "size": 5219, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2cd6a569c29f301a9de8e6d3540c2f6a87cf0bb3" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/flat16_2208_actual_exact_polynomial_verification.json", + "mode": "100644", + "type": "blob", + "sha": "c111b52990cb09a366fc5fbed33c45fc40bae33c", + "size": 76815, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c111b52990cb09a366fc5fbed33c45fc40bae33c" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/flat16_2208_integer_circuit.json", + "mode": "100644", + "type": "blob", + "sha": "ed086ba5f4d7d8dc498954787a73fe1f6b14ed85", + "size": 5584060, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed086ba5f4d7d8dc498954787a73fe1f6b14ed85" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/portable_regeneration_content_identity_actual.json", + "mode": "100644", + "type": "blob", + "sha": "2f8c4935972ceb9155d7b24e4933d35c170b5ed7", + "size": 802, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2f8c4935972ceb9155d7b24e4933d35c170b5ed7" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/portable_replay_original_actual.json", + "mode": "100644", + "type": "blob", + "sha": "fac0a24657a56b723a0085dd6dfc53a19394b129", + "size": 76815, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fac0a24657a56b723a0085dd6dfc53a19394b129" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/circuit/portable_replay_regenerated_actual.json", + "mode": "100644", + "type": "blob", + "sha": "97356c69ff046a82140557f93ef06b8b7d93dd87", + "size": 76988, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/97356c69ff046a82140557f93ef06b8b7d93dd87" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence", + "mode": "040000", + "type": "tree", + "sha": "1efc267cbb483fc43fdc0ccd9e4a0b55205c094a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1efc267cbb483fc43fdc0ccd9e4a0b55205c094a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/actual_integer_general_extension10_standard_public_projection.json", + "mode": "100644", + "type": "blob", + "sha": "34bce6ee799b2a8b698364496addde0c7b65779c", + "size": 10974, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34bce6ee799b2a8b698364496addde0c7b65779c" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/actual_nine_sources_35_standard_public_projection.json", + "mode": "100644", + "type": "blob", + "sha": "32e225b35b39f4121c06cb5d167715f01020dfa1", + "size": 34005, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32e225b35b39f4121c06cb5d167715f01020dfa1" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci", + "mode": "040000", + "type": "tree", + "sha": "2621c9e59e73f8a787bc65e20b90b83df6b10925", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2621c9e59e73f8a787bc65e20b90b83df6b10925" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184", + "mode": "040000", + "type": "tree", + "sha": "c249c402ee8d71c3a564c472534caaf05a70396a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c249c402ee8d71c3a564c472534caaf05a70396a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/BlockComposition.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/BlockComposition.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "cab8ce53b69d717af2362276e4e341e13c568925", + "size": 2898, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cab8ce53b69d717af2362276e4e341e13c568925" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Concrete16.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Concrete16.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "2a5af212bb1a352e30d6b24339e72462f1268908", + "size": 509, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a5af212bb1a352e30d6b24339e72462f1268908" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/DAGRefinement.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/DAGRefinement.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "93802c31b73a7b00f918c85f580e0562af7e1716", + "size": 938, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/93802c31b73a7b00f918c85f580e0562af7e1716" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/IntegerGeneralization.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/IntegerGeneralization.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "3a9b83d2a8c8e57b6216212e080edc4e447ab75c", + "size": 969, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a9b83d2a8c8e57b6216212e080edc4e447ab75c" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/IntegerLateDivision.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/IntegerLateDivision.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "12031944c0a051621fee4bbf3e6d53858020420e", + "size": 1020, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/12031944c0a051621fee4bbf3e6d53858020420e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/OrdinalTransport.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/OrdinalTransport.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "d96796d8d357ed64c01f4307fb8961db6c900871", + "size": 857, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d96796d8d357ed64c01f4307fb8961db6c900871" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Outer48Data.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Outer48Data.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "dccc46c9caca0c59ec539a76100188c70dc2d790", + "size": 612, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dccc46c9caca0c59ec539a76100188c70dc2d790" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Outer48Scheme.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/Outer48Scheme.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "51e99b8918200a5cab2ddf6c97cd0a86c1c41144", + "size": 506, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/51e99b8918200a5cab2ddf6c97cd0a86c1c41144" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/OuterLifting.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/OuterLifting.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "bf8b7a478d1f45360dd9ca0d8da7fda85fe1bbc7", + "size": 467, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bf8b7a478d1f45360dd9ca0d8da7fda85fe1bbc7" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/RosowskiEven.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/RosowskiEven.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "a3a6d617beecf4f498e3a24a98ec0a7d0031cbca", + "size": 1044, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a3a6d617beecf4f498e3a24a98ec0a7d0031cbca" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/RosowskiLeaf4.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/RosowskiLeaf4.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "59441dd0aaae52771c2b23801c6c506ff8268ca4", + "size": 1107, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/59441dd0aaae52771c2b23801c6c506ff8268ca4" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/SelectedFinalAxiomAudit.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/SelectedFinalAxiomAudit.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "e6db4772d093721b19a4c21777249b4b5fb4afca", + "size": 5557, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e6db4772d093721b19a4c21777249b4b5fb4afca" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/actual_download_qualification.json", + "mode": "100644", + "type": "blob", + "sha": "ea5f9d6970bf5f0bb5a2d496216332d2079dcf4f", + "size": 4799, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ea5f9d6970bf5f0bb5a2d496216332d2079dcf4f" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/github_ci/37675264184/actual_reproduction.json", + "mode": "100644", + "type": "blob", + "sha": "abf37dab7c3a8a63ab0204fd59bfe5039573fa1a", + "size": 7459, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/abf37dab7c3a8a63ab0204fd59bfe5039573fa1a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs", + "mode": "040000", + "type": "tree", + "sha": "4ff35c177893207a1169cddd795bcc307a9fc657", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/4ff35c177893207a1169cddd795bcc307a9fc657" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/BlockComposition.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/BlockComposition.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "cab8ce53b69d717af2362276e4e341e13c568925", + "size": 2898, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cab8ce53b69d717af2362276e4e341e13c568925" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Concrete16.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Concrete16.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "2a5af212bb1a352e30d6b24339e72462f1268908", + "size": 509, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a5af212bb1a352e30d6b24339e72462f1268908" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/DAGRefinement.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/DAGRefinement.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "93802c31b73a7b00f918c85f580e0562af7e1716", + "size": 938, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/93802c31b73a7b00f918c85f580e0562af7e1716" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/IntegerGeneralization.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/IntegerGeneralization.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "3a9b83d2a8c8e57b6216212e080edc4e447ab75c", + "size": 969, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a9b83d2a8c8e57b6216212e080edc4e447ab75c" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/IntegerLateDivision.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/IntegerLateDivision.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "12031944c0a051621fee4bbf3e6d53858020420e", + "size": 1020, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/12031944c0a051621fee4bbf3e6d53858020420e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/OrdinalTransport.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/OrdinalTransport.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "d96796d8d357ed64c01f4307fb8961db6c900871", + "size": 857, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d96796d8d357ed64c01f4307fb8961db6c900871" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Outer48Data.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Outer48Data.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "dccc46c9caca0c59ec539a76100188c70dc2d790", + "size": 612, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dccc46c9caca0c59ec539a76100188c70dc2d790" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Outer48Scheme.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/Outer48Scheme.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "51e99b8918200a5cab2ddf6c97cd0a86c1c41144", + "size": 506, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/51e99b8918200a5cab2ddf6c97cd0a86c1c41144" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/OuterLifting.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/OuterLifting.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "bf8b7a478d1f45360dd9ca0d8da7fda85fe1bbc7", + "size": 467, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bf8b7a478d1f45360dd9ca0d8da7fda85fe1bbc7" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/RosowskiEven.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/RosowskiEven.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "a3a6d617beecf4f498e3a24a98ec0a7d0031cbca", + "size": 1044, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a3a6d617beecf4f498e3a24a98ec0a7d0031cbca" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/RosowskiLeaf4.stderr.txt", + "mode": "100644", + "type": "blob", + "sha": "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", + "size": 0, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69de29bb2d1d6434b8b29ae775ad8c2e48c5391" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/logs/RosowskiLeaf4.stdout.txt", + "mode": "100644", + "type": "blob", + "sha": "59441dd0aaae52771c2b23801c6c506ff8268ca4", + "size": 1107, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/59441dd0aaae52771c2b23801c6c506ff8268ca4" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/evidence/public_module_scope.json", + "mode": "100644", + "type": "blob", + "sha": "872a3c9ba6834af9b739ce31c5ee7dcea3e7568f", + "size": 9898, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/872a3c9ba6834af9b739ce31c5ee7dcea3e7568f" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/generate_flat16_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "0b76e0620a5d43344dbe2aca77cadf9b460073bf", + "size": 7369, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b76e0620a5d43344dbe2aca77cadf9b460073bf" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/input", + "mode": "040000", + "type": "tree", + "sha": "12b775acbb1d57017751ab751807f2a8cd9e0b9d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/12b775acbb1d57017751ab751807f2a8cd9e0b9d" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/input/outer48_exact_rational_and_integer_data.json", + "mode": "100644", + "type": "blob", + "sha": "cb71fb2b3ab2c1c2033708151a833bd08e5aee4e", + "size": 98643, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb71fb2b3ab2c1c2033708151a833bd08e5aee4e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean", + "mode": "040000", + "type": "tree", + "sha": "35abb693fb8e5d76a98f03713ba111c176d5a1d5", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/35abb693fb8e5d76a98f03713ba111c176d5a1d5" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/BlockComposition.lean", + "mode": "100644", + "type": "blob", + "sha": "298c788e4ea14485fe214f3636cbee90d4e19ec2", + "size": 6211, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/298c788e4ea14485fe214f3636cbee90d4e19ec2" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/Concrete16.lean", + "mode": "100644", + "type": "blob", + "sha": "3e696cd340bc0f37f45b79fa3f49f02059e509f1", + "size": 1365, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3e696cd340bc0f37f45b79fa3f49f02059e509f1" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/DAGRefinement.lean", + "mode": "100644", + "type": "blob", + "sha": "25cdad6cc3fe6efb0ea59d2f2fb578b0219bebb5", + "size": 5303, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/25cdad6cc3fe6efb0ea59d2f2fb578b0219bebb5" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/IntegerGeneralization.lean", + "mode": "100644", + "type": "blob", + "sha": "e9ee4f871d171a991ff7402ff1aba9f778d4d151", + "size": 2613, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e9ee4f871d171a991ff7402ff1aba9f778d4d151" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/IntegerLateDivision.lean", + "mode": "100644", + "type": "blob", + "sha": "8cf8636c74b49d13a7a973544b0be4a4f57181a0", + "size": 6222, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8cf8636c74b49d13a7a973544b0be4a4f57181a0" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/OrdinalTransport.lean", + "mode": "100644", + "type": "blob", + "sha": "7d8d5414b75601809fa79612f9d67ed040f32bb1", + "size": 1533, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d8d5414b75601809fa79612f9d67ed040f32bb1" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/Outer48Data.lean", + "mode": "100644", + "type": "blob", + "sha": "875e611b35c79d49cabd22eb838150be21e401df", + "size": 14124, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/875e611b35c79d49cabd22eb838150be21e401df" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/Outer48Scheme.lean", + "mode": "100644", + "type": "blob", + "sha": "b3f07d07d87dfc83e045689f0749f342594d2912", + "size": 2695, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b3f07d07d87dfc83e045689f0749f342594d2912" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/OuterLifting.lean", + "mode": "100644", + "type": "blob", + "sha": "50a8e4cded4d7ca7b48e395074460655768c7e62", + "size": 4463, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50a8e4cded4d7ca7b48e395074460655768c7e62" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/RosowskiEven.lean", + "mode": "100644", + "type": "blob", + "sha": "bdf5e0b6017e94c45966f2a4a97702aaa442d1cd", + "size": 2516, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bdf5e0b6017e94c45966f2a4a97702aaa442d1cd" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/RosowskiLeaf4.lean", + "mode": "100644", + "type": "blob", + "sha": "3ff2a76de3dcd527b16d6bc1d0de192e786cf750", + "size": 5778, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3ff2a76de3dcd527b16d6bc1d0de192e786cf750" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/SelectedAxiomAudit.lean", + "mode": "100644", + "type": "blob", + "sha": "2b4519d447c3b67719cf2d8855a2a5d8507b263f", + "size": 2128, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2b4519d447c3b67719cf2d8855a2a5d8507b263f" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/SelectedFinalAxiomAudit.lean", + "mode": "100644", + "type": "blob", + "sha": "f9fc921a400f88c8a346cc95b0981e715be19b9b", + "size": 2734, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f9fc921a400f88c8a346cc95b0981e715be19b9b" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/check_final_selected_axioms.py", + "mode": "100644", + "type": "blob", + "sha": "db941e4ed78e37b2b95ac640a025ed4d2e3f03fb", + "size": 3807, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db941e4ed78e37b2b95ac640a025ed4d2e3f03fb" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/check_selected_axioms.py", + "mode": "100644", + "type": "blob", + "sha": "38b2dfeecfba4063462d6a7cd32c3c3ef754ea37", + "size": 3786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38b2dfeecfba4063462d6a7cd32c3c3ef754ea37" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/final_source_manifest.json", + "mode": "100644", + "type": "blob", + "sha": "3252c7240b99649aeba2f0306dabd1d0aeabee0e", + "size": 6322, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3252c7240b99649aeba2f0306dabd1d0aeabee0e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/lakefile.toml", + "mode": "100644", + "type": "blob", + "sha": "6abc98592465b4144c4694b6849915925a52b717", + "size": 489, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6abc98592465b4144c4694b6849915925a52b717" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/lean-toolchain", + "mode": "100644", + "type": "blob", + "sha": "a8afa7d1b02d96f0671eba854a8dc4b416beb473", + "size": 25, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8afa7d1b02d96f0671eba854a8dc4b416beb473" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/lean/source_manifest.json", + "mode": "100644", + "type": "blob", + "sha": "551d623b8768c62f3cec2e0f54217b54b7360e0a", + "size": 5193, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/551d623b8768c62f3cec2e0f54217b54b7360e0a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript", + "mode": "040000", + "type": "tree", + "sha": "8d1f31c5e4bc6e4e558d3e0cccc05a9adc082c33", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/8d1f31c5e4bc6e4e558d3e0cccc05a9adc082c33" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/Hybrid_Composition_revised.ast.json", + "mode": "100644", + "type": "blob", + "sha": "01e3607b96beb98e23f4142a184b7859edb99634", + "size": 476018, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/01e3607b96beb98e23f4142a184b7859edb99634" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/Hybrid_Composition_revised.md", + "mode": "100644", + "type": "blob", + "sha": "d89e33a51d6ddfa14011aea1bdd3db8147524e5e", + "size": 29013, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d89e33a51d6ddfa14011aea1bdd3db8147524e5e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/Hybrid_Composition_revised.pdf", + "mode": "100644", + "type": "blob", + "sha": "5dfb7c3b5b8c6672a4dbd7ea6d4c26a431ae700a", + "size": 722194, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5dfb7c3b5b8c6672a4dbd7ea6d4c26a431ae700a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/Hybrid_Composition_revised.review_draft.md", + "mode": "100644", + "type": "blob", + "sha": "74781671f064e9699f48b2c39b0ada7c9b2fd116", + "size": 27666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74781671f064e9699f48b2c39b0ada7c9b2fd116" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/Hybrid_Composition_revised.tex", + "mode": "100644", + "type": "blob", + "sha": "995008a4f3bacc041530890e17e7aae7662eefa6", + "size": 32739, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/995008a4f3bacc041530890e17e7aae7662eefa6" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/actual_9_page_visual_QA.json", + "mode": "100644", + "type": "blob", + "sha": "7d7ca9a9c85a55e0bb95031486e6ae7de3dc5b4a", + "size": 1562, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d7ca9a9c85a55e0bb95031486e6ae7de3dc5b4a" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/current_manuscript_manifest.json", + "mode": "100644", + "type": "blob", + "sha": "901105ef02df9d635a0a7e13dda476c8e430a84c", + "size": 965, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/901105ef02df9d635a0a7e13dda476c8e430a84c" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/manuscript/native_latex_actual_result.json", + "mode": "100644", + "type": "blob", + "sha": "3a1075ad164be6d74767924962f49c340a102104", + "size": 557, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3a1075ad164be6d74767924962f49c340a102104" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/portable_generator_path_provenance_only.diff", + "mode": "100644", + "type": "blob", + "sha": "2643765e06d76a51772a7824129624ea251f81a9", + "size": 7252, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2643765e06d76a51772a7824129624ea251f81a9" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/portable_public_replay_manifest.json", + "mode": "100644", + "type": "blob", + "sha": "a57ff7284ae90e8731cf2e2b3abc9255c3ba47f6", + "size": 3431, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a57ff7284ae90e8731cf2e2b3abc9255c3ba47f6" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/portable_python_replay_preparation.json", + "mode": "100644", + "type": "blob", + "sha": "0e037043935a85295dcd069b5ae173871b4ca16e", + "size": 2959, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e037043935a85295dcd069b5ae173871b4ca16e" + }, + { + "path": "research/matrix-exponent-synthesis/openmath-source/personal-matrix-hybrid-2026-10-07/verify_flat16_polynomials.py", + "mode": "100644", + "type": "blob", + "sha": "5b0aa5cc5348b364bd6d20d6093e58b9e64399ce", + "size": 6212, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5b0aa5cc5348b364bd6d20d6093e58b9e64399ce" + }, + { + "path": "research/matrix-exponent-synthesis/pi_exact.py", + "mode": "100644", + "type": "blob", + "sha": "ed987ad053c54474fd7af8c8a3ffb62378312309", + "size": 4315, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed987ad053c54474fd7af8c8a3ffb62378312309" + }, + { + "path": "research/matrix-exponent-synthesis/receipts", + "mode": "040000", + "type": "tree", + "sha": "59549c038b2b596ac1576bf03ff52b9121832aa3", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/59549c038b2b596ac1576bf03ff52b9121832aa3" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/bilinear_projection_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "6e827b18c0dea029741f9b4d638a925d83646649", + "size": 647, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6e827b18c0dea029741f9b4d638a925d83646649" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/gaussian-matrix-verification.json", + "mode": "100644", + "type": "blob", + "sha": "8409bbdf59ed857d494b70d97ea7a11e2752f0ec", + "size": 2898, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8409bbdf59ed857d494b70d97ea7a11e2752f0ec" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/hierarchical-gaussian-verification.json", + "mode": "100644", + "type": "blob", + "sha": "a5955a61e43f41095c1d97edcf7d220a5ae7de58", + "size": 3365, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5955a61e43f41095c1d97edcf7d220a5ae7de58" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/independent_matching_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "d2922092bb8c2f3ac82efaa0ae7fcf04ed3d9b15", + "size": 2424, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d2922092bb8c2f3ac82efaa0ae7fcf04ed3d9b15" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/independent_matrix_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "ed1dadef8e61f4ff841c6c8bee0abb4d8fccb5c1", + "size": 739, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed1dadef8e61f4ff841c6c8bee0abb4d8fccb5c1" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/matrix_two_adic_lift_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "5d213791fae8a11f3dc9c4b91632a56f0bd6bea6", + "size": 1609, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d213791fae8a11f3dc9c4b91632a56f0bd6bea6" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/phase_child_closure_receipt_v2.json", + "mode": "100644", + "type": "blob", + "sha": "1dcef6ed8bbbdde6ef85131377ec508ac67640fe", + "size": 2388, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1dcef6ed8bbbdde6ef85131377ec508ac67640fe" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/phase_operator_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "ce8dd2f77df88fae40a930645ac4f78c1fcd818a", + "size": 2977, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ce8dd2f77df88fae40a930645ac4f78c1fcd818a" + }, + { + "path": "research/matrix-exponent-synthesis/receipts/source_ci_audit_receipt.json", + "mode": "100644", + "type": "blob", + "sha": "1b7b881bff6ebfaea9b58f516375800c9ad2cafc", + "size": 860, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b7b881bff6ebfaea9b58f516375800c9ad2cafc" + }, + { + "path": "research/matrix-exponent-synthesis/run_checks.py", + "mode": "100644", + "type": "blob", + "sha": "ad0ba26078ffeeb079991789db65a81d94145920", + "size": 2895, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad0ba26078ffeeb079991789db65a81d94145920" + }, + { + "path": "research/matrix-exponent-synthesis/verify_gaussian_matrix.py", + "mode": "100644", + "type": "blob", + "sha": "b77a050bcb30aa15b958de8eb5941f8278c65aa0", + "size": 2250, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b77a050bcb30aa15b958de8eb5941f8278c65aa0" + }, + { + "path": "research/matrix-exponent-synthesis/verify_hierarchical_gaussian.py", + "mode": "100644", + "type": "blob", + "sha": "4e8716b807435ddecaac35a21df72152d77d2eba", + "size": 2153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e8716b807435ddecaac35a21df72152d77d2eba" + }, + { + "path": "research/pair-assembly", + "mode": "040000", + "type": "tree", + "sha": "83792dba9fa8d9984fddcd64c5a14bb5f06e7cea", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/83792dba9fa8d9984fddcd64c5a14bb5f06e7cea" + }, + { + "path": "research/pair-assembly/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "26e1166562eff395a1fbb632751f985586ed078f", + "size": 10524, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/26e1166562eff395a1fbb632751f985586ed078f" + }, + { + "path": "research/pair-assembly/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "5a89d29e5f31f4f64a39b6ffec30c19175f56449", + "size": 11375, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5a89d29e5f31f4f64a39b6ffec30c19175f56449" + }, + { + "path": "research/pair-assembly/audit.py", + "mode": "100644", + "type": "blob", + "sha": "34d4990f66af048a3092af24b1b9dd2fef60fd9f", + "size": 3826, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34d4990f66af048a3092af24b1b9dd2fef60fd9f" + }, + { + "path": "research/pair-assembly/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/pair-assembly/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "db1c621c7e1e3a1b18fb24d9022eb901a63a2d19", + "size": 312064, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db1c621c7e1e3a1b18fb24d9022eb901a63a2d19" + }, + { + "path": "research/pair-assembly/comparison-pr40.json", + "mode": "100644", + "type": "blob", + "sha": "e0b14fb24396c741a3bf2f183db4c6f2cb0acab3", + "size": 786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0b14fb24396c741a3bf2f183db4c6f2cb0acab3" + }, + { + "path": "research/pair-assembly/comparison-pr41.json", + "mode": "100644", + "type": "blob", + "sha": "f2968fb1dda682090d1a3d2bc9ad86ad13aac71f", + "size": 718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2968fb1dda682090d1a3d2bc9ad86ad13aac71f" + }, + { + "path": "research/pair-assembly/comparison-pr42.json", + "mode": "100644", + "type": "blob", + "sha": "3f4378580e90fdd1e9b92b847dd60ba22afc288e", + "size": 796, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f4378580e90fdd1e9b92b847dd60ba22afc288e" + }, + { + "path": "research/pair-assembly/comparison-pr43.json", + "mode": "100644", + "type": "blob", + "sha": "503e4a74ce26a3af808f629fd5fe6b82746e8ee8", + "size": 848, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/503e4a74ce26a3af808f629fd5fe6b82746e8ee8" + }, + { + "path": "research/pair-assembly/comparison-pr44.json", + "mode": "100644", + "type": "blob", + "sha": "9c0c416158790e5d417e4d9c93e13bcf3f120e07", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c0c416158790e5d417e4d9c93e13bcf3f120e07" + }, + { + "path": "research/pair-assembly/comparison-pr46.json", + "mode": "100644", + "type": "blob", + "sha": "427983e2e07e13a44977b043973b2d4ec93ddf72", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/427983e2e07e13a44977b043973b2d4ec93ddf72" + }, + { + "path": "research/pair-assembly/comparison-pr47.json", + "mode": "100644", + "type": "blob", + "sha": "bc387e8d37e34152043a9f79192c8e35a4d67728", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc387e8d37e34152043a9f79192c8e35a4d67728" + }, + { + "path": "research/pair-assembly/comparison-pr48.json", + "mode": "100644", + "type": "blob", + "sha": "b0ab3101d8755ca3b10dba7e5532982003665520", + "size": 666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0ab3101d8755ca3b10dba7e5532982003665520" + }, + { + "path": "research/pair-assembly/comparison-pr53.json", + "mode": "100644", + "type": "blob", + "sha": "d08d9d4c2b88de2738c9e1467870b55fe797c6a4", + "size": 769, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d08d9d4c2b88de2738c9e1467870b55fe797c6a4" + }, + { + "path": "research/pair-assembly/comparison-pr54.json", + "mode": "100644", + "type": "blob", + "sha": "1d01f78c2abddafac1ea4622148366865ca75696", + "size": 769, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d01f78c2abddafac1ea4622148366865ca75696" + }, + { + "path": "research/pair-assembly/comparison-pr57.json", + "mode": "100644", + "type": "blob", + "sha": "d9839fdc8c7be7099ab7ebeeabb62f8b02f8721e", + "size": 757, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d9839fdc8c7be7099ab7ebeeabb62f8b02f8721e" + }, + { + "path": "research/pair-assembly/data-corners.json", + "mode": "100644", + "type": "blob", + "sha": "4cb7a2b26fc48afd020b7966c43fd30cf2321514", + "size": 40579, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cb7a2b26fc48afd020b7966c43fd30cf2321514" + }, + { + "path": "research/pair-assembly/data_corners.cpp", + "mode": "100644", + "type": "blob", + "sha": "251f6c87cca42619a0c1b6d83705df5cad0e9c33", + "size": 3295, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/251f6c87cca42619a0c1b6d83705df5cad0e9c33" + }, + { + "path": "research/pair-assembly/data_recovery.py", + "mode": "100644", + "type": "blob", + "sha": "38972cab7e1fda608c3898fc9f2f578bf253211a", + "size": 2272, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38972cab7e1fda608c3898fc9f2f578bf253211a" + }, + { + "path": "research/pair-assembly/frame", + "mode": "040000", + "type": "tree", + "sha": "e215641860b42e9d5d1f3f113742c0b1177eb52f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e215641860b42e9d5d1f3f113742c0b1177eb52f" + }, + { + "path": "research/pair-assembly/frame/frame-certificate.json", + "mode": "100644", + "type": "blob", + "sha": "58612546b9794dc8000a21a8596f502b5a423b18", + "size": 31722, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/58612546b9794dc8000a21a8596f502b5a423b18" + }, + { + "path": "research/pair-assembly/frame/frame-compiler.json", + "mode": "100644", + "type": "blob", + "sha": "ab8cde595cbc8cdc8cc79d3767681d415ff8c863", + "size": 4672, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ab8cde595cbc8cdc8cc79d3767681d415ff8c863" + }, + { + "path": "research/pair-assembly/frame/frame-profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "eb1b3ea09f031f079c22604420d50077527dea55", + "size": 456, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eb1b3ea09f031f079c22604420d50077527dea55" + }, + { + "path": "research/pair-assembly/frame/frame-profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "bf52841d28004af34e5cb9c7c12cd071b6edcc81", + "size": 476, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bf52841d28004af34e5cb9c7c12cd071b6edcc81" + }, + { + "path": "research/pair-assembly/frame/frame-transitions-23.json", + "mode": "100644", + "type": "blob", + "sha": "b15f1e692a1f60a4c8cd608ab3e60f262639a945", + "size": 685, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b15f1e692a1f60a4c8cd608ab3e60f262639a945" + }, + { + "path": "research/pair-assembly/frame/frame-transitions-25.json", + "mode": "100644", + "type": "blob", + "sha": "c181f190c674b56a39fb255a8832b7fdd953d0bd", + "size": 689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c181f190c674b56a39fb255a8832b7fdd953d0bd" + }, + { + "path": "research/pair-assembly/frame/frame-word-23.json.gz", + "mode": "100644", + "type": "blob", + "sha": "e041f08f7724efe9d73a5601cf215ab717948d1f", + "size": 2509674, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e041f08f7724efe9d73a5601cf215ab717948d1f" + }, + { + "path": "research/pair-assembly/frame/frame-word-25.json.gz", + "mode": "100644", + "type": "blob", + "sha": "000cd479f4642aacbfb595548130645afdf39d5f", + "size": 3479363, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/000cd479f4642aacbfb595548130645afdf39d5f" + }, + { + "path": "research/pair-assembly/frame/frame_compile.py", + "mode": "100644", + "type": "blob", + "sha": "325e2aea3fcf03f30ae51afb410a905ee55a360e", + "size": 3051, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/325e2aea3fcf03f30ae51afb410a905ee55a360e" + }, + { + "path": "research/pair-assembly/frame/frame_verify.py", + "mode": "100644", + "type": "blob", + "sha": "d47c1cb3df9712296d4388d2ced012543a24b2bb", + "size": 8890, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d47c1cb3df9712296d4388d2ced012543a24b2bb" + }, + { + "path": "research/pair-assembly/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "2d1c918980ae81de9332791e18c234b324e283bd", + "size": 311296, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2d1c918980ae81de9332791e18c234b324e283bd" + }, + { + "path": "research/pair-assembly/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "ae504176e5f2b0dac75da9b63830fd4c3795fcb6", + "size": 446760, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ae504176e5f2b0dac75da9b63830fd4c3795fcb6" + }, + { + "path": "research/pair-assembly/optimize_matching.py", + "mode": "100644", + "type": "blob", + "sha": "d79db50f2ffb52daf136c32759ad660e95b69177", + "size": 3537, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d79db50f2ffb52daf136c32759ad660e95b69177" + }, + { + "path": "research/pair-assembly/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "916c1d3712a8a4fce6c1010be8e29fb9248d201b", + "size": 428, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/916c1d3712a8a4fce6c1010be8e29fb9248d201b" + }, + { + "path": "research/pair-assembly/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "548ee601a94763e87b4a0b8a3074d839ff68381d", + "size": 445, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/548ee601a94763e87b4a0b8a3074d839ff68381d" + }, + { + "path": "research/pair-assembly/original_timeline.py", + "mode": "100644", + "type": "blob", + "sha": "0fb348896edac82a6ac3e682d611049cb8488ff1", + "size": 14542, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb348896edac82a6ac3e682d611049cb8488ff1" + }, + { + "path": "research/pair-assembly/pair_graph.py", + "mode": "100644", + "type": "blob", + "sha": "eef8e1eba07ad4a6474551328cd2d769d1b470b4", + "size": 10259, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eef8e1eba07ad4a6474551328cd2d769d1b470b4" + }, + { + "path": "research/pair-assembly/producer-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "b082e37e244b765445fb42c057f0ca67e2b78100", + "size": 20354, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b082e37e244b765445fb42c057f0ca67e2b78100" + }, + { + "path": "research/pair-assembly/producer.py", + "mode": "100644", + "type": "blob", + "sha": "9345680de078029aaf51c5c0dbc0c61e575ff870", + "size": 9876, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9345680de078029aaf51c5c0dbc0c61e575ff870" + }, + { + "path": "research/pair-assembly/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "d7b69944e17f4c3260062208770f610e4d75e33d", + "size": 457, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d7b69944e17f4c3260062208770f610e4d75e33d" + }, + { + "path": "research/pair-assembly/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "79883504e5a3a67e13f5043b84d978fbbcb4d46b", + "size": 477, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/79883504e5a3a67e13f5043b84d978fbbcb4d46b" + }, + { + "path": "research/pair-assembly/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/pair-assembly/reversed", + "mode": "040000", + "type": "tree", + "sha": "850c2bf5dbc76dde06b74712be69ecbc72059b33", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/850c2bf5dbc76dde06b74712be69ecbc72059b33" + }, + { + "path": "research/pair-assembly/reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "618912ee497c053e7d891c6b7f07c5517edeae71", + "size": 805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/618912ee497c053e7d891c6b7f07c5517edeae71" + }, + { + "path": "research/pair-assembly/reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "7ad54118609fb8eebbb329d8862c8c899039a93b", + "size": 4689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ad54118609fb8eebbb329d8862c8c899039a93b" + }, + { + "path": "research/pair-assembly/reversed/pr34", + "mode": "040000", + "type": "tree", + "sha": "80c5b3126c18d39bb78836a93317f97869427acf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/80c5b3126c18d39bb78836a93317f97869427acf" + }, + { + "path": "research/pair-assembly/reversed/pr34/certify_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "e7367cb24862b7f416c4f36181b6d383ba53bb7c", + "size": 5526, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7367cb24862b7f416c4f36181b6d383ba53bb7c" + }, + { + "path": "research/pair-assembly/reversed/pr34/independent_controls.py", + "mode": "100644", + "type": "blob", + "sha": "d5578d5c51081ca922c1a4f3dc320253c011afe6", + "size": 5610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d5578d5c51081ca922c1a4f3dc320253c011afe6" + }, + { + "path": "research/pair-assembly/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "e47c8fc2d63d3939ac8dfb52f2045f4289166648", + "size": 326, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e47c8fc2d63d3939ac8dfb52f2045f4289166648" + }, + { + "path": "research/pair-assembly/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "c9e0445c9d8f6871ff4a0cfe25509f1538498e1d", + "size": 326, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c9e0445c9d8f6871ff4a0cfe25509f1538498e1d" + }, + { + "path": "research/pair-assembly/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "3936d397b34d5f55bba1db1082c5b33d6bc42c1f", + "size": 1510, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3936d397b34d5f55bba1db1082c5b33d6bc42c1f" + }, + { + "path": "research/pair-assembly/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "212c34df66d48cd38908e17a8441bc4d890ee7ff", + "size": 1527, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/212c34df66d48cd38908e17a8441bc4d890ee7ff" + }, + { + "path": "research/pair-assembly/verify.py", + "mode": "100644", + "type": "blob", + "sha": "743fd2902b0f28c4138fe1cc175aafdb2c8dac7c", + "size": 19642, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/743fd2902b0f28c4138fe1cc175aafdb2c8dac7c" + }, + { + "path": "research/parallel-announcements", + "mode": "040000", + "type": "tree", + "sha": "2149612fc5db7ef63c4768bce4d6dc022c28931a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2149612fc5db7ef63c4768bce4d6dc022c28931a" + }, + { + "path": "research/parallel-announcements/README.md", + "mode": "100644", + "type": "blob", + "sha": "7da7db0878f730da8da802cd841b401fc7afba73", + "size": 5844, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7da7db0878f730da8da802cd841b401fc7afba73" + }, + { + "path": "research/parallel-announcements/verification.json", + "mode": "100644", + "type": "blob", + "sha": "6e11ac9d6282afc3be2e78ce7acf9eb83fbef86d", + "size": 8634, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6e11ac9d6282afc3be2e78ce7acf9eb83fbef86d" + }, + { + "path": "research/parallel-announcements/verify.py", + "mode": "100644", + "type": "blob", + "sha": "940aac6828109f5b38467c5e5aa81fc4d3c045d0", + "size": 7155, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/940aac6828109f5b38467c5e5aa81fc4d3c045d0" + }, + { + "path": "research/positive-skip", + "mode": "040000", + "type": "tree", + "sha": "dd62ab28c1c2c04937e83f93b2caa88b1af6edbf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/dd62ab28c1c2c04937e83f93b2caa88b1af6edbf" + }, + { + "path": "research/positive-skip/README.md", + "mode": "100644", + "type": "blob", + "sha": "25826c2fede722d2b9a2a045db7f84cd07139d70", + "size": 4244, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/25826c2fede722d2b9a2a045db7f84cd07139d70" + }, + { + "path": "research/positive-skip/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "310334ecc8d440fde329e9f69f0798e4baf68df9", + "size": 2867, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/310334ecc8d440fde329e9f69f0798e4baf68df9" + }, + { + "path": "research/positive-skip/build.py", + "mode": "100644", + "type": "blob", + "sha": "c8f36207ab8ede4b9bddd4a3a44eba51afedefb2", + "size": 5776, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8f36207ab8ede4b9bddd4a3a44eba51afedefb2" + }, + { + "path": "research/positive-skip/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "c4e190b5a517097c2fd861838e3d05b25a8a5020", + "size": 36321, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c4e190b5a517097c2fd861838e3d05b25a8a5020" + }, + { + "path": "research/positive-skip/comparison-pr53.json", + "mode": "100644", + "type": "blob", + "sha": "1fdc3173b19f67d874f72cd952960cd1a16a4c84", + "size": 680, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1fdc3173b19f67d874f72cd952960cd1a16a4c84" + }, + { + "path": "research/positive-skip/comparison-pr54.json", + "mode": "100644", + "type": "blob", + "sha": "1c0696c6959d40e7d956746bcba1fc00944705f3", + "size": 683, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1c0696c6959d40e7d956746bcba1fc00944705f3" + }, + { + "path": "research/positive-skip/exact-recertification.json", + "mode": "100644", + "type": "blob", + "sha": "ffbbb4f5064e276520dc5b934af5039bfbefae45", + "size": 4435, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ffbbb4f5064e276520dc5b934af5039bfbefae45" + }, + { + "path": "research/positive-skip/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "1e636ddbc1553f2190d3f1ecf34c8911a7b367dd", + "size": 105808, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1e636ddbc1553f2190d3f1ecf34c8911a7b367dd" + }, + { + "path": "research/positive-skip/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "997622a29c781cc80812f0ff7a7576d59a8c9465", + "size": 142336, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/997622a29c781cc80812f0ff7a7576d59a8c9465" + }, + { + "path": "research/positive-skip/pins.json", + "mode": "100644", + "type": "blob", + "sha": "cb3a5c58f7a9fdf8d0e7575142269fb206503da6", + "size": 492, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb3a5c58f7a9fdf8d0e7575142269fb206503da6" + }, + { + "path": "research/positive-skip/pr51", + "mode": "040000", + "type": "tree", + "sha": "62311cf023e739e86c58f7c4149089e8babafd4b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/62311cf023e739e86c58f7c4149089e8babafd4b" + }, + { + "path": "research/positive-skip/pr51/LICENSE-PR37.txt", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "research/positive-skip/pr51/alternative_producer_clones.py", + "mode": "100644", + "type": "blob", + "sha": "e252b9aa8bfba5ec137e9233b41c62349ed50689", + "size": 12064, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e252b9aa8bfba5ec137e9233b41c62349ed50689" + }, + { + "path": "research/positive-skip/pr51/check_compiled_witness.py", + "mode": "100644", + "type": "blob", + "sha": "c8be738379353233c915c1c0ccde068c041d6863", + "size": 16956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8be738379353233c915c1c0ccde068c041d6863" + }, + { + "path": "research/positive-skip/pr51/moment_match_rank_node.cpp", + "mode": "100644", + "type": "blob", + "sha": "de730658a82c0d91ead0d667ab46b434f096e70d", + "size": 7150, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de730658a82c0d91ead0d667ab46b434f096e70d" + }, + { + "path": "research/positive-skip/pr51/positive_clone_search.py", + "mode": "100644", + "type": "blob", + "sha": "9ab2f3201cd77f2c1b6d6ea9237b377dffb17a5b", + "size": 13008, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9ab2f3201cd77f2c1b6d6ea9237b377dffb17a5b" + }, + { + "path": "research/positive-skip/pr51/positive_frame_profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "66c42ff3f43f82bc7f5add7a34ce9ef73f0db0b3", + "size": 13040, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/66c42ff3f43f82bc7f5add7a34ce9ef73f0db0b3" + }, + { + "path": "research/positive-skip/pr51/producer_search.py", + "mode": "100644", + "type": "blob", + "sha": "f28f1b66d82fb6a4547e116aa0bdd8b8467d746d", + "size": 15963, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f28f1b66d82fb6a4547e116aa0bdd8b8467d746d" + }, + { + "path": "research/positive-skip/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "ebec242b064a8203a1fa3b0b77342de0caab14ca", + "size": 221, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ebec242b064a8203a1fa3b0b77342de0caab14ca" + }, + { + "path": "research/positive-skip/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "d83af38cfb0e2aab2553976c3fd97d518a6d2e2e", + "size": 232, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d83af38cfb0e2aab2553976c3fd97d518a6d2e2e" + }, + { + "path": "research/positive-skip/tools", + "mode": "040000", + "type": "tree", + "sha": "38bb5c4ada533e4a96085cbb5643ace8cf710059", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/38bb5c4ada533e4a96085cbb5643ace8cf710059" + }, + { + "path": "research/positive-skip/tools/cprof.cpp", + "mode": "100644", + "type": "blob", + "sha": "f8d76f159d850b79c5ba222a8d0d83865977229b", + "size": 10154, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f8d76f159d850b79c5ba222a8d0d83865977229b" + }, + { + "path": "research/positive-skip/tools/solve51.py", + "mode": "100644", + "type": "blob", + "sha": "5e890a3045ce4bd612a1ce2cd2086266ad19bb78", + "size": 1428, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e890a3045ce4bd612a1ce2cd2086266ad19bb78" + }, + { + "path": "research/positive-skip/validation.json", + "mode": "100644", + "type": "blob", + "sha": "6d00591940fdc978e0e879e3bec59a2d1a82b0de", + "size": 987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6d00591940fdc978e0e879e3bec59a2d1a82b0de" + }, + { + "path": "research/positive-skip/witness.py", + "mode": "100644", + "type": "blob", + "sha": "5a46a81eda1d81dfc4f6cc24bb9035b21d67c09f", + "size": 5434, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5a46a81eda1d81dfc4f6cc24bb9035b21d67c09f" + }, + { + "path": "research/skip-clones", + "mode": "040000", + "type": "tree", + "sha": "b2b00c53e8c96c220e3b4cd13126050b4b98a32e", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/b2b00c53e8c96c220e3b4cd13126050b4b98a32e" + }, + { + "path": "research/skip-clones/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "975bf774f454147d183b13d159773cb5e891973d", + "size": 15958, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/975bf774f454147d183b13d159773cb5e891973d" + }, + { + "path": "research/skip-clones/README.md", + "mode": "100644", + "type": "blob", + "sha": "fedbeefe611e3ca4e917cf62eca3eb587c94407c", + "size": 4303, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fedbeefe611e3ca4e917cf62eca3eb587c94407c" + }, + { + "path": "research/skip-clones/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", + "size": 13997, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5" + }, + { + "path": "research/skip-clones/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "167f1a293c2cdb33e1030668157a84698df20f20", + "size": 41940, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/167f1a293c2cdb33e1030668157a84698df20f20" + }, + { + "path": "research/skip-clones/clone-jobs-23.json", + "mode": "100644", + "type": "blob", + "sha": "ba33adbcc2888909e9ba48ce86ce323635945045", + "size": 1462873, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ba33adbcc2888909e9ba48ce86ce323635945045" + }, + { + "path": "research/skip-clones/clone-jobs-25.json", + "mode": "100644", + "type": "blob", + "sha": "3dba51dff2aca4a2a2d087da69fd983314275fab", + "size": 1966657, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3dba51dff2aca4a2a2d087da69fd983314275fab" + }, + { + "path": "research/skip-clones/clone_io.py", + "mode": "100644", + "type": "blob", + "sha": "ff8a05e2058107c59bdb1fed3dac1b1417bddfa7", + "size": 2449, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff8a05e2058107c59bdb1fed3dac1b1417bddfa7" + }, + { + "path": "research/skip-clones/cloned_graph.py", + "mode": "100644", + "type": "blob", + "sha": "f4fe2d1fb13510876189c9ce7bbb7c8b09628e32", + "size": 13035, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f4fe2d1fb13510876189c9ce7bbb7c8b09628e32" + }, + { + "path": "research/skip-clones/comparison-pr49.json", + "mode": "100644", + "type": "blob", + "sha": "7d4c1f1d4af29f695dae6989b4c78162b7740a85", + "size": 802, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d4c1f1d4af29f695dae6989b4c78162b7740a85" + }, + { + "path": "research/skip-clones/comparison-pr50.json", + "mode": "100644", + "type": "blob", + "sha": "e06f2b360dfe2d6ec137ebbf7056122cc0552ab6", + "size": 873, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e06f2b360dfe2d6ec137ebbf7056122cc0552ab6" + }, + { + "path": "research/skip-clones/comparison-pr51.json", + "mode": "100644", + "type": "blob", + "sha": "6e8aa3dfaf2b1210d7b13368ecf2079a1f37bc41", + "size": 884, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6e8aa3dfaf2b1210d7b13368ecf2079a1f37bc41" + }, + { + "path": "research/skip-clones/comparison-pr53.json", + "mode": "100644", + "type": "blob", + "sha": "8a22de10692ce6134a989b4f97f1524ec1ab565c", + "size": 909, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8a22de10692ce6134a989b4f97f1524ec1ab565c" + }, + { + "path": "research/skip-clones/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "00ce373a99fa00720d5beca93e0778d424932754", + "size": 105808, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/00ce373a99fa00720d5beca93e0778d424932754" + }, + { + "path": "research/skip-clones/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "2e3f92258f99cf138c23c039a7b70a423e3a6556", + "size": 141584, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e3f92258f99cf138c23c039a7b70a423e3a6556" + }, + { + "path": "research/skip-clones/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "7df8199d2fd555a9de466ec58d619121bfcfc218", + "size": 430, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7df8199d2fd555a9de466ec58d619121bfcfc218" + }, + { + "path": "research/skip-clones/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "ca29fdfc178244c5104e2e7d8002acff53305875", + "size": 453, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca29fdfc178244c5104e2e7d8002acff53305875" + }, + { + "path": "research/skip-clones/parameters.json", + "mode": "100644", + "type": "blob", + "sha": "34325cb9cb293c4005654fd94df98fdbc3c79cc8", + "size": 151, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34325cb9cb293c4005654fd94df98fdbc3c79cc8" + }, + { + "path": "research/skip-clones/pin_sources.py", + "mode": "100644", + "type": "blob", + "sha": "ebf3ef5165db6cc969117a2908946ccf5e9a09f6", + "size": 2374, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ebf3ef5165db6cc969117a2908946ccf5e9a09f6" + }, + { + "path": "research/skip-clones/producer-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "5aca36e75f552e4780aaf1ffb334e50476b77817", + "size": 7273, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5aca36e75f552e4780aaf1ffb334e50476b77817" + }, + { + "path": "research/skip-clones/producer.py", + "mode": "100644", + "type": "blob", + "sha": "f77953730aaebe538501867989a43df4e2a0bd0d", + "size": 6065, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f77953730aaebe538501867989a43df4e2a0bd0d" + }, + { + "path": "research/skip-clones/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "fcd358ddf6330e43c52f005aee573f34f69ea773", + "size": 458, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fcd358ddf6330e43c52f005aee573f34f69ea773" + }, + { + "path": "research/skip-clones/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "482b384f85e9cbd642324634b3655929e6fef93f", + "size": 481, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/482b384f85e9cbd642324634b3655929e6fef93f" + }, + { + "path": "research/skip-clones/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/skip-clones/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "7ce3cc946fc2af85ce9371f15d5d55a9a37e9e4e", + "size": 352, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ce3cc946fc2af85ce9371f15d5d55a9a37e9e4e" + }, + { + "path": "research/skip-clones/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "4702db6a08299702ee0a79ed6cd81543fd953110", + "size": 352, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4702db6a08299702ee0a79ed6cd81543fd953110" + }, + { + "path": "research/skip-clones/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "83666e60788292a1b6ddcabac800d6c360a69d17", + "size": 1309, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/83666e60788292a1b6ddcabac800d6c360a69d17" + }, + { + "path": "research/skip-clones/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "a5f32e882b30df30e4685aeab4c537f7018d6a06", + "size": 1332, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a5f32e882b30df30e4685aeab4c537f7018d6a06" + }, + { + "path": "research/skip-clones/validation.json", + "mode": "100644", + "type": "blob", + "sha": "ec6c11305a424aca80ad6bb588151a5f960b8300", + "size": 8777, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ec6c11305a424aca80ad6bb588151a5f960b8300" + }, + { + "path": "research/skip-clones/witness.py", + "mode": "100644", + "type": "blob", + "sha": "73ea15dc32fc10866275ca37d3cf78407a3b5bd7", + "size": 12501, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/73ea15dc32fc10866275ca37d3cf78407a3b5bd7" + }, + { + "path": "research/skip-strips", + "mode": "040000", + "type": "tree", + "sha": "1d5e0cc0b7cf5d8f6e5c2e05a2f63fe621a76b75", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1d5e0cc0b7cf5d8f6e5c2e05a2f63fe621a76b75" + }, + { + "path": "research/skip-strips/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "e41cd36689098a5f0b3c3b6663d11bc5858636af", + "size": 7142, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e41cd36689098a5f0b3c3b6663d11bc5858636af" + }, + { + "path": "research/skip-strips/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "6265ba3791f1fc3ddc78bd379cde88d425df2017", + "size": 11557, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6265ba3791f1fc3ddc78bd379cde88d425df2017" + }, + { + "path": "research/skip-strips/audit.py", + "mode": "100644", + "type": "blob", + "sha": "34d4990f66af048a3092af24b1b9dd2fef60fd9f", + "size": 3826, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34d4990f66af048a3092af24b1b9dd2fef60fd9f" + }, + { + "path": "research/skip-strips/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/skip-strips/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "e9bb0dc03552105628d79ccd0d55a01759f21194", + "size": 310776, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e9bb0dc03552105628d79ccd0d55a01759f21194" + }, + { + "path": "research/skip-strips/comparison-pr40.json", + "mode": "100644", + "type": "blob", + "sha": "e0b14fb24396c741a3bf2f183db4c6f2cb0acab3", + "size": 786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0b14fb24396c741a3bf2f183db4c6f2cb0acab3" + }, + { + "path": "research/skip-strips/comparison-pr41.json", + "mode": "100644", + "type": "blob", + "sha": "f2968fb1dda682090d1a3d2bc9ad86ad13aac71f", + "size": 718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2968fb1dda682090d1a3d2bc9ad86ad13aac71f" + }, + { + "path": "research/skip-strips/comparison-pr42.json", + "mode": "100644", + "type": "blob", + "sha": "3f4378580e90fdd1e9b92b847dd60ba22afc288e", + "size": 796, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f4378580e90fdd1e9b92b847dd60ba22afc288e" + }, + { + "path": "research/skip-strips/comparison-pr43.json", + "mode": "100644", + "type": "blob", + "sha": "503e4a74ce26a3af808f629fd5fe6b82746e8ee8", + "size": 848, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/503e4a74ce26a3af808f629fd5fe6b82746e8ee8" + }, + { + "path": "research/skip-strips/comparison-pr44.json", + "mode": "100644", + "type": "blob", + "sha": "9c0c416158790e5d417e4d9c93e13bcf3f120e07", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c0c416158790e5d417e4d9c93e13bcf3f120e07" + }, + { + "path": "research/skip-strips/comparison-pr46.json", + "mode": "100644", + "type": "blob", + "sha": "427983e2e07e13a44977b043973b2d4ec93ddf72", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/427983e2e07e13a44977b043973b2d4ec93ddf72" + }, + { + "path": "research/skip-strips/comparison-pr47.json", + "mode": "100644", + "type": "blob", + "sha": "bc387e8d37e34152043a9f79192c8e35a4d67728", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc387e8d37e34152043a9f79192c8e35a4d67728" + }, + { + "path": "research/skip-strips/comparison-pr48.json", + "mode": "100644", + "type": "blob", + "sha": "b0ab3101d8755ca3b10dba7e5532982003665520", + "size": 666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0ab3101d8755ca3b10dba7e5532982003665520" + }, + { + "path": "research/skip-strips/data-corners.json", + "mode": "100644", + "type": "blob", + "sha": "4cb7a2b26fc48afd020b7966c43fd30cf2321514", + "size": 40579, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cb7a2b26fc48afd020b7966c43fd30cf2321514" + }, + { + "path": "research/skip-strips/data_corners.cpp", + "mode": "100644", + "type": "blob", + "sha": "251f6c87cca42619a0c1b6d83705df5cad0e9c33", + "size": 3295, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/251f6c87cca42619a0c1b6d83705df5cad0e9c33" + }, + { + "path": "research/skip-strips/data_recovery.py", + "mode": "100644", + "type": "blob", + "sha": "38972cab7e1fda608c3898fc9f2f578bf253211a", + "size": 2272, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38972cab7e1fda608c3898fc9f2f578bf253211a" + }, + { + "path": "research/skip-strips/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "4b807fb5a7bbd8a78791ac8163f621f1cc263f90", + "size": 101760, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4b807fb5a7bbd8a78791ac8163f621f1cc263f90" + }, + { + "path": "research/skip-strips/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "effbc2e7e5d13e310f11d1010680f5ffa1b3c9f0", + "size": 135936, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/effbc2e7e5d13e310f11d1010680f5ffa1b3c9f0" + }, + { + "path": "research/skip-strips/optimize_matching.py", + "mode": "100644", + "type": "blob", + "sha": "ef5bfeb733afe5c17b45edf136496bf11da95f88", + "size": 3537, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ef5bfeb733afe5c17b45edf136496bf11da95f88" + }, + { + "path": "research/skip-strips/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "c814cbb766d22c9500e88e2b25a01bf5f5e4cd8f", + "size": 430, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c814cbb766d22c9500e88e2b25a01bf5f5e4cd8f" + }, + { + "path": "research/skip-strips/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "f2877eb031f2080bf40dbaa94ba2eae1624568ed", + "size": 453, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2877eb031f2080bf40dbaa94ba2eae1624568ed" + }, + { + "path": "research/skip-strips/original_timeline.py", + "mode": "100644", + "type": "blob", + "sha": "0fb348896edac82a6ac3e682d611049cb8488ff1", + "size": 14542, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb348896edac82a6ac3e682d611049cb8488ff1" + }, + { + "path": "research/skip-strips/producer-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "76f0f0382639b5362702f83d76b6d9d402437c5a", + "size": 20372, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/76f0f0382639b5362702f83d76b6d9d402437c5a" + }, + { + "path": "research/skip-strips/producer.py", + "mode": "100644", + "type": "blob", + "sha": "1f0b0bd2574ba2225a0180bc136aae45f91a65ac", + "size": 9875, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1f0b0bd2574ba2225a0180bc136aae45f91a65ac" + }, + { + "path": "research/skip-strips/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "ad9ed7fff49d159dabbd5e277139ecad05c26270", + "size": 458, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad9ed7fff49d159dabbd5e277139ecad05c26270" + }, + { + "path": "research/skip-strips/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "3dde139a028e445cd644fa72a6d50488eb74065a", + "size": 481, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3dde139a028e445cd644fa72a6d50488eb74065a" + }, + { + "path": "research/skip-strips/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/skip-strips/reversed", + "mode": "040000", + "type": "tree", + "sha": "850c2bf5dbc76dde06b74712be69ecbc72059b33", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/850c2bf5dbc76dde06b74712be69ecbc72059b33" + }, + { + "path": "research/skip-strips/reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "618912ee497c053e7d891c6b7f07c5517edeae71", + "size": 805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/618912ee497c053e7d891c6b7f07c5517edeae71" + }, + { + "path": "research/skip-strips/reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "7ad54118609fb8eebbb329d8862c8c899039a93b", + "size": 4689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ad54118609fb8eebbb329d8862c8c899039a93b" + }, + { + "path": "research/skip-strips/reversed/pr34", + "mode": "040000", + "type": "tree", + "sha": "80c5b3126c18d39bb78836a93317f97869427acf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/80c5b3126c18d39bb78836a93317f97869427acf" + }, + { + "path": "research/skip-strips/reversed/pr34/certify_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "e7367cb24862b7f416c4f36181b6d383ba53bb7c", + "size": 5526, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7367cb24862b7f416c4f36181b6d383ba53bb7c" + }, + { + "path": "research/skip-strips/reversed/pr34/independent_controls.py", + "mode": "100644", + "type": "blob", + "sha": "d5578d5c51081ca922c1a4f3dc320253c011afe6", + "size": 5610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d5578d5c51081ca922c1a4f3dc320253c011afe6" + }, + { + "path": "research/skip-strips/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "18bea13775b650cc8f78315c2961048f8d04322b", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/18bea13775b650cc8f78315c2961048f8d04322b" + }, + { + "path": "research/skip-strips/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "900ae4fdcc089f7170d89fccdb384d30fd299849", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/900ae4fdcc089f7170d89fccdb384d30fd299849" + }, + { + "path": "research/skip-strips/skip_graph.py", + "mode": "100644", + "type": "blob", + "sha": "e3ff56e33d5af7bd30878a538a77f6a0821192c5", + "size": 7644, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e3ff56e33d5af7bd30878a538a77f6a0821192c5" + }, + { + "path": "research/skip-strips/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "75690f9d9a5cc267668a4b2047999f6a75db1dab", + "size": 1509, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/75690f9d9a5cc267668a4b2047999f6a75db1dab" + }, + { + "path": "research/skip-strips/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "c169d8ac6226cb2a71931da3472f6512ea5d136a", + "size": 1534, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c169d8ac6226cb2a71931da3472f6512ea5d136a" + }, + { + "path": "research/skip-strips/verify.py", + "mode": "100644", + "type": "blob", + "sha": "642efac75ebb3f3ebe3b044e45b4ce43d1502f5b", + "size": 18444, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/642efac75ebb3f3ebe3b044e45b4ce43d1502f5b" + }, + { + "path": "research/skip-suffix", + "mode": "040000", + "type": "tree", + "sha": "6edcad4bcf84a9396c7bd11a62c490292827446f", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/6edcad4bcf84a9396c7bd11a62c490292827446f" + }, + { + "path": "research/skip-suffix/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "1799156264faf57f359146f97714dcdc127f40db", + "size": 7644, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1799156264faf57f359146f97714dcdc127f40db" + }, + { + "path": "research/skip-suffix/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "fd5958f1c51b053b5e4a924520497298c0743d3f", + "size": 11498, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fd5958f1c51b053b5e4a924520497298c0743d3f" + }, + { + "path": "research/skip-suffix/audit.py", + "mode": "100644", + "type": "blob", + "sha": "34d4990f66af048a3092af24b1b9dd2fef60fd9f", + "size": 3826, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/34d4990f66af048a3092af24b1b9dd2fef60fd9f" + }, + { + "path": "research/skip-suffix/balanced_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "c7fd42867d741939db6a41529bfdbb136f03191b", + "size": 9711, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c7fd42867d741939db6a41529bfdbb136f03191b" + }, + { + "path": "research/skip-suffix/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "333f35cf58516eb049ce750fceaa98279d66aee8", + "size": 311026, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/333f35cf58516eb049ce750fceaa98279d66aee8" + }, + { + "path": "research/skip-suffix/comparison-pr40.json", + "mode": "100644", + "type": "blob", + "sha": "e0b14fb24396c741a3bf2f183db4c6f2cb0acab3", + "size": 786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0b14fb24396c741a3bf2f183db4c6f2cb0acab3" + }, + { + "path": "research/skip-suffix/comparison-pr41.json", + "mode": "100644", + "type": "blob", + "sha": "f2968fb1dda682090d1a3d2bc9ad86ad13aac71f", + "size": 718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2968fb1dda682090d1a3d2bc9ad86ad13aac71f" + }, + { + "path": "research/skip-suffix/comparison-pr42.json", + "mode": "100644", + "type": "blob", + "sha": "3f4378580e90fdd1e9b92b847dd60ba22afc288e", + "size": 796, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f4378580e90fdd1e9b92b847dd60ba22afc288e" + }, + { + "path": "research/skip-suffix/comparison-pr43.json", + "mode": "100644", + "type": "blob", + "sha": "503e4a74ce26a3af808f629fd5fe6b82746e8ee8", + "size": 848, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/503e4a74ce26a3af808f629fd5fe6b82746e8ee8" + }, + { + "path": "research/skip-suffix/comparison-pr44.json", + "mode": "100644", + "type": "blob", + "sha": "9c0c416158790e5d417e4d9c93e13bcf3f120e07", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c0c416158790e5d417e4d9c93e13bcf3f120e07" + }, + { + "path": "research/skip-suffix/comparison-pr46.json", + "mode": "100644", + "type": "blob", + "sha": "427983e2e07e13a44977b043973b2d4ec93ddf72", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/427983e2e07e13a44977b043973b2d4ec93ddf72" + }, + { + "path": "research/skip-suffix/comparison-pr47.json", + "mode": "100644", + "type": "blob", + "sha": "bc387e8d37e34152043a9f79192c8e35a4d67728", + "size": 621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc387e8d37e34152043a9f79192c8e35a4d67728" + }, + { + "path": "research/skip-suffix/comparison-pr48.json", + "mode": "100644", + "type": "blob", + "sha": "b0ab3101d8755ca3b10dba7e5532982003665520", + "size": 666, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b0ab3101d8755ca3b10dba7e5532982003665520" + }, + { + "path": "research/skip-suffix/data-corners.json", + "mode": "100644", + "type": "blob", + "sha": "4cb7a2b26fc48afd020b7966c43fd30cf2321514", + "size": 40579, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cb7a2b26fc48afd020b7966c43fd30cf2321514" + }, + { + "path": "research/skip-suffix/data_corners.cpp", + "mode": "100644", + "type": "blob", + "sha": "02e13441d73809cd1bf5863c6b480f53485a61db", + "size": 4318, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/02e13441d73809cd1bf5863c6b480f53485a61db" + }, + { + "path": "research/skip-suffix/data_recovery.py", + "mode": "100644", + "type": "blob", + "sha": "38972cab7e1fda608c3898fc9f2f578bf253211a", + "size": 2272, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/38972cab7e1fda608c3898fc9f2f578bf253211a" + }, + { + "path": "research/skip-suffix/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "0f838b0d3155b1295c9f47ef53d1dbc84f3d28be", + "size": 103160, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0f838b0d3155b1295c9f47ef53d1dbc84f3d28be" + }, + { + "path": "research/skip-suffix/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "8ac16f3f3e12267a577c07e02b6b996a53c90a3b", + "size": 136416, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8ac16f3f3e12267a577c07e02b6b996a53c90a3b" + }, + { + "path": "research/skip-suffix/optimize_matching.py", + "mode": "100644", + "type": "blob", + "sha": "ef5bfeb733afe5c17b45edf136496bf11da95f88", + "size": 3537, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ef5bfeb733afe5c17b45edf136496bf11da95f88" + }, + { + "path": "research/skip-suffix/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "397e7a2086e7bcc7dc039d7ef7d97412c622e3d9", + "size": 429, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/397e7a2086e7bcc7dc039d7ef7d97412c622e3d9" + }, + { + "path": "research/skip-suffix/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "335ddce798e4dc27efcf0f023c8a9aefdb184d81", + "size": 453, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/335ddce798e4dc27efcf0f023c8a9aefdb184d81" + }, + { + "path": "research/skip-suffix/original_timeline.py", + "mode": "100644", + "type": "blob", + "sha": "0fb348896edac82a6ac3e682d611049cb8488ff1", + "size": 14542, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb348896edac82a6ac3e682d611049cb8488ff1" + }, + { + "path": "research/skip-suffix/producer-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "3cdc0862bdb2dc5de091dafc8eaab584772fec9b", + "size": 20372, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3cdc0862bdb2dc5de091dafc8eaab584772fec9b" + }, + { + "path": "research/skip-suffix/producer.py", + "mode": "100644", + "type": "blob", + "sha": "8b4820481f8b0d56946c2ceefa4fe50c9faf066c", + "size": 9886, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8b4820481f8b0d56946c2ceefa4fe50c9faf066c" + }, + { + "path": "research/skip-suffix/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "399c3466ae9d6845b2d711d38ee3e3eab3066a87", + "size": 458, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/399c3466ae9d6845b2d711d38ee3e3eab3066a87" + }, + { + "path": "research/skip-suffix/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "0fb4e929bcb31a33fa60d8cd747aff9f46906dec", + "size": 481, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0fb4e929bcb31a33fa60d8cd747aff9f46906dec" + }, + { + "path": "research/skip-suffix/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/skip-suffix/reversed", + "mode": "040000", + "type": "tree", + "sha": "850c2bf5dbc76dde06b74712be69ecbc72059b33", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/850c2bf5dbc76dde06b74712be69ecbc72059b33" + }, + { + "path": "research/skip-suffix/reversed/geometry-source.json", + "mode": "100644", + "type": "blob", + "sha": "618912ee497c053e7d891c6b7f07c5517edeae71", + "size": 805, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/618912ee497c053e7d891c6b7f07c5517edeae71" + }, + { + "path": "research/skip-suffix/reversed/geometry.py", + "mode": "100644", + "type": "blob", + "sha": "7ad54118609fb8eebbb329d8862c8c899039a93b", + "size": 4689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ad54118609fb8eebbb329d8862c8c899039a93b" + }, + { + "path": "research/skip-suffix/reversed/pr34", + "mode": "040000", + "type": "tree", + "sha": "80c5b3126c18d39bb78836a93317f97869427acf", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/80c5b3126c18d39bb78836a93317f97869427acf" + }, + { + "path": "research/skip-suffix/reversed/pr34/certify_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "e7367cb24862b7f416c4f36181b6d383ba53bb7c", + "size": 5526, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e7367cb24862b7f416c4f36181b6d383ba53bb7c" + }, + { + "path": "research/skip-suffix/reversed/pr34/independent_controls.py", + "mode": "100644", + "type": "blob", + "sha": "d5578d5c51081ca922c1a4f3dc320253c011afe6", + "size": 5610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d5578d5c51081ca922c1a4f3dc320253c011afe6" + }, + { + "path": "research/skip-suffix/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "abb4af1ba9ed4e7a354ca761067833baafc9cfd5", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/abb4af1ba9ed4e7a354ca761067833baafc9cfd5" + }, + { + "path": "research/skip-suffix/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "94c12582f6492f717840fc74ad87e01be7c834ff", + "size": 325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94c12582f6492f717840fc74ad87e01be7c834ff" + }, + { + "path": "research/skip-suffix/skip_graph.py", + "mode": "100644", + "type": "blob", + "sha": "6cdd455ee9a49c0309f1924d26440c6a0b0bdeb6", + "size": 8159, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6cdd455ee9a49c0309f1924d26440c6a0b0bdeb6" + }, + { + "path": "research/skip-suffix/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "1d5ea45510a97fda44b9f058bd70bbbb291a44c0", + "size": 1509, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d5ea45510a97fda44b9f058bd70bbbb291a44c0" + }, + { + "path": "research/skip-suffix/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "8038f11430dddcb0cf9f75fa3da09bae2397a71d", + "size": 1535, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8038f11430dddcb0cf9f75fa3da09bae2397a71d" + }, + { + "path": "research/skip-suffix/verify.py", + "mode": "100644", + "type": "blob", + "sha": "0d4779c7a794fa9efa7782758277f8256b687841", + "size": 18912, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d4779c7a794fa9efa7782758277f8256b687841" + }, + { + "path": "research/split-skip", + "mode": "040000", + "type": "tree", + "sha": "2899a309270951d3648025fb7e4173a7866bc9e1", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/2899a309270951d3648025fb7e4173a7866bc9e1" + }, + { + "path": "research/split-skip/PROOF.md", + "mode": "100644", + "type": "blob", + "sha": "5fe9e808be76f780243602a4364db3b30b16b264", + "size": 10419, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5fe9e808be76f780243602a4364db3b30b16b264" + }, + { + "path": "research/split-skip/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", + "size": 18868, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2ab610b6ea2edd2865fda793ef2168b0c76afb4f" + }, + { + "path": "research/split-skip/certificate.json", + "mode": "100644", + "type": "blob", + "sha": "809943e8a1d53d477127703ec33f906416342d00", + "size": 54541, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/809943e8a1d53d477127703ec33f906416342d00" + }, + { + "path": "research/split-skip/clone-jobs-23.json", + "mode": "100644", + "type": "blob", + "sha": "9774f0f403b311529e1cdb53ea11e67e81304a79", + "size": 803166, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9774f0f403b311529e1cdb53ea11e67e81304a79" + }, + { + "path": "research/split-skip/clone-jobs-25.json", + "mode": "100644", + "type": "blob", + "sha": "f58e27bd9c5679c0665a34817b0183de391ef6ea", + "size": 1055553, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f58e27bd9c5679c0665a34817b0183de391ef6ea" + }, + { + "path": "research/split-skip/clone_io.py", + "mode": "100644", + "type": "blob", + "sha": "8137a1363ba77099b1630ac95fcc803ffd7092c8", + "size": 1218, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8137a1363ba77099b1630ac95fcc803ffd7092c8" + }, + { + "path": "research/split-skip/cloned_graph.py", + "mode": "100644", + "type": "blob", + "sha": "7e2946f87a6099505c726d7120e5a02c00a0e603", + "size": 12912, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7e2946f87a6099505c726d7120e5a02c00a0e603" + }, + { + "path": "research/split-skip/comparison-pr54.json", + "mode": "100644", + "type": "blob", + "sha": "614659a22b789f807dbdda9bace0dd676791f09b", + "size": 2077, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/614659a22b789f807dbdda9bace0dd676791f09b" + }, + { + "path": "research/split-skip/config-23.json", + "mode": "100644", + "type": "blob", + "sha": "ccb45ee4621d2c0b69f3fd4656db309c5e0c2deb", + "size": 2889, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ccb45ee4621d2c0b69f3fd4656db309c5e0c2deb" + }, + { + "path": "research/split-skip/config-25.json", + "mode": "100644", + "type": "blob", + "sha": "05a9a1f5483af4ea9f7f2f43f4a4bce17c77dd6e", + "size": 3785, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05a9a1f5483af4ea9f7f2f43f4a4bce17c77dd6e" + }, + { + "path": "research/split-skip/data-corners.json", + "mode": "100644", + "type": "blob", + "sha": "4cb7a2b26fc48afd020b7966c43fd30cf2321514", + "size": 40579, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4cb7a2b26fc48afd020b7966c43fd30cf2321514" + }, + { + "path": "research/split-skip/data_corners.cpp", + "mode": "100644", + "type": "blob", + "sha": "251f6c87cca42619a0c1b6d83705df5cad0e9c33", + "size": 3295, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/251f6c87cca42619a0c1b6d83705df5cad0e9c33" + }, + { + "path": "research/split-skip/evidence", + "mode": "040000", + "type": "tree", + "sha": "03fe5843d8b4680ab33b11eef2aa6a4aa4c4d3b7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/03fe5843d8b4680ab33b11eef2aa6a4aa4c4d3b7" + }, + { + "path": "research/split-skip/evidence/clean_source_copy.txt", + "mode": "100644", + "type": "blob", + "sha": "0dae29bbc383a1c5047199c5ddcbfc34977d3682", + "size": 285, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0dae29bbc383a1c5047199c5ddcbfc34977d3682" + }, + { + "path": "research/split-skip/evidence/exact_witness.txt", + "mode": "100644", + "type": "blob", + "sha": "cb0edf551005bedd886920813ffb135ebf1a2561", + "size": 87, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb0edf551005bedd886920813ffb135ebf1a2561" + }, + { + "path": "research/split-skip/evidence/focused_tests.txt", + "mode": "100644", + "type": "blob", + "sha": "7f2fed8ef8b180fe90c3d4f0fdd24645ac23da77", + "size": 1413, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7f2fed8ef8b180fe90c3d4f0fdd24645ac23da77" + }, + { + "path": "research/split-skip/evidence/independent_arithmetic.txt", + "mode": "100644", + "type": "blob", + "sha": "f9861dacdc5457ef2d4fc4065c4c8ac33069a2a4", + "size": 198, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f9861dacdc5457ef2d4fc4065c4c8ac33069a2a4" + }, + { + "path": "research/split-skip/evidence/inherited_make_verify.txt", + "mode": "100644", + "type": "blob", + "sha": "fd28e06b5d907f7d156696ddd768d374cdb07845", + "size": 82727, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fd28e06b5d907f7d156696ddd768d374cdb07845" + }, + { + "path": "research/split-skip/evidence/integration_exact.txt", + "mode": "100644", + "type": "blob", + "sha": "cb0edf551005bedd886920813ffb135ebf1a2561", + "size": 87, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb0edf551005bedd886920813ffb135ebf1a2561" + }, + { + "path": "research/split-skip/evidence/integration_focused.txt", + "mode": "100644", + "type": "blob", + "sha": "7f6880e58000db6860d391cb083246e7c4d933ad", + "size": 1856, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7f6880e58000db6860d391cb083246e7c4d933ad" + }, + { + "path": "research/split-skip/evidence/integration_producer.txt", + "mode": "100644", + "type": "blob", + "sha": "be5fa0c426e6ee7f6e018128b7488b5f8278f273", + "size": 1261, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/be5fa0c426e6ee7f6e018128b7488b5f8278f273" + }, + { + "path": "research/split-skip/evidence/integration_tests.txt", + "mode": "100644", + "type": "blob", + "sha": "7dcaca062b153efe28d2391e26d8236d6a358180", + "size": 38390, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7dcaca062b153efe28d2391e26d8236d6a358180" + }, + { + "path": "research/split-skip/evidence/selected_producer.txt", + "mode": "100644", + "type": "blob", + "sha": "82e6dbd9375e5dd2bd3b9bf62fac38eb69c71684", + "size": 1257, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/82e6dbd9375e5dd2bd3b9bf62fac38eb69c71684" + }, + { + "path": "research/split-skip/graph.py", + "mode": "100644", + "type": "blob", + "sha": "e9dfd73b16a8ce831931b451e5dd5854767bdc04", + "size": 107, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e9dfd73b16a8ce831931b451e5dd5854767bdc04" + }, + { + "path": "research/split-skip/independent_arithmetic.py", + "mode": "100644", + "type": "blob", + "sha": "e2593dfa61e8e65be59869beb53346b99840c334", + "size": 3381, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e2593dfa61e8e65be59869beb53346b99840c334" + }, + { + "path": "research/split-skip/links-23.uses", + "mode": "100644", + "type": "blob", + "sha": "9c7c09aeee77146650835a2a44e8f97d79cdc844", + "size": 114728, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c7c09aeee77146650835a2a44e8f97d79cdc844" + }, + { + "path": "research/split-skip/links-25.uses", + "mode": "100644", + "type": "blob", + "sha": "e5cc7e6c0e4b7ecf1895b63a967d825f775d06b9", + "size": 152224, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e5cc7e6c0e4b7ecf1895b63a967d825f775d06b9" + }, + { + "path": "research/split-skip/original-23.json", + "mode": "100644", + "type": "blob", + "sha": "462baeb9612d95785f4361489fb48a35d1dd711f", + "size": 433, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/462baeb9612d95785f4361489fb48a35d1dd711f" + }, + { + "path": "research/split-skip/original-25.json", + "mode": "100644", + "type": "blob", + "sha": "f58afb425ee5a503118450025f9d92bec6104ec7", + "size": 454, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f58afb425ee5a503118450025f9d92bec6104ec7" + }, + { + "path": "research/split-skip/parameters.json", + "mode": "100644", + "type": "blob", + "sha": "a2c9d0928a13b14134f5f6a9da3d38f88165ec25", + "size": 106, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a2c9d0928a13b14134f5f6a9da3d38f88165ec25" + }, + { + "path": "research/split-skip/producer-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "d44d0a0de51ac1aec6661ab2557154e8bd5936c8", + "size": 20444, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d44d0a0de51ac1aec6661ab2557154e8bd5936c8" + }, + { + "path": "research/split-skip/producer.py", + "mode": "100644", + "type": "blob", + "sha": "9c2e53a6c257e39a5f9c5f647300a30dc3c1aa63", + "size": 4217, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c2e53a6c257e39a5f9c5f647300a30dc3c1aa63" + }, + { + "path": "research/split-skip/profiles-23.json", + "mode": "100644", + "type": "blob", + "sha": "1d7ce7d6ad2826ed0ef3d6fba7982d82a03f98c5", + "size": 458, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d7ce7d6ad2826ed0ef3d6fba7982d82a03f98c5" + }, + { + "path": "research/split-skip/profiles-25.json", + "mode": "100644", + "type": "blob", + "sha": "798ef674d230eaf9ad0e514814be9c2620246862", + "size": 482, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/798ef674d230eaf9ad0e514814be9c2620246862" + }, + { + "path": "research/split-skip/profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "410e50f475623183fab8de8f211e7d528599151a", + "size": 12139, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/410e50f475623183fab8de8f211e7d528599151a" + }, + { + "path": "research/split-skip/review", + "mode": "040000", + "type": "tree", + "sha": "1e96df9afe8e99a35674d27597a8f6b6946bc3cb", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/1e96df9afe8e99a35674d27597a8f6b6946bc3cb" + }, + { + "path": "research/split-skip/review/arithmetic-audit.txt", + "mode": "100644", + "type": "blob", + "sha": "070eab3dcc9b6173578651ba7ae7061898c01ab0", + "size": 5925, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/070eab3dcc9b6173578651ba7ae7061898c01ab0" + }, + { + "path": "research/split-skip/review/grouping-audit.txt", + "mode": "100644", + "type": "blob", + "sha": "051071cc8311364f0562d4596a26b5c9b3924612", + "size": 8748, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/051071cc8311364f0562d4596a26b5c9b3924612" + }, + { + "path": "research/split-skip/scalar-23.json", + "mode": "100644", + "type": "blob", + "sha": "2a6d805fd2834107c33a005b0d0cd7f331d8cc8e", + "size": 352, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a6d805fd2834107c33a005b0d0cd7f331d8cc8e" + }, + { + "path": "research/split-skip/scalar-25.json", + "mode": "100644", + "type": "blob", + "sha": "9c5cb202f39a54ea965c5381c95f69e132b861b0", + "size": 352, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c5cb202f39a54ea965c5381c95f69e132b861b0" + }, + { + "path": "research/split-skip/search-receipt.json", + "mode": "100644", + "type": "blob", + "sha": "3f4697855962cf82f72783dfc97544b2376db55b", + "size": 4982, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3f4697855962cf82f72783dfc97544b2376db55b" + }, + { + "path": "research/split-skip/search-summary.txt", + "mode": "100644", + "type": "blob", + "sha": "690061412971193fa231c3e20763ffc8952ae41f", + "size": 1169, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/690061412971193fa231c3e20763ffc8952ae41f" + }, + { + "path": "research/split-skip/split_graph.py", + "mode": "100644", + "type": "blob", + "sha": "08d31a53d9d616e378c262d452995b1fa9e93268", + "size": 7035, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/08d31a53d9d616e378c262d452995b1fa9e93268" + }, + { + "path": "research/split-skip/timeline-23.json", + "mode": "100644", + "type": "blob", + "sha": "810172ec1e15e25d899b028a57ed1fc168790b45", + "size": 1513, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/810172ec1e15e25d899b028a57ed1fc168790b45" + }, + { + "path": "research/split-skip/timeline-25.json", + "mode": "100644", + "type": "blob", + "sha": "b967e2dd4298b29d27fbc43adc5382211c04f2ed", + "size": 1535, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b967e2dd4298b29d27fbc43adc5382211c04f2ed" + }, + { + "path": "research/split-skip/uncloned-comparison.json", + "mode": "100644", + "type": "blob", + "sha": "857c2da6b8d8b0ecfe0fd56d5e7cd33b3131b45f", + "size": 2530, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/857c2da6b8d8b0ecfe0fd56d5e7cd33b3131b45f" + }, + { + "path": "research/split-skip/validation.json", + "mode": "100644", + "type": "blob", + "sha": "e56a0b1ba4bd8d39d56fd86977f543a2598008e8", + "size": 4900, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e56a0b1ba4bd8d39d56fd86977f543a2598008e8" + }, + { + "path": "research/split-skip/vendor", + "mode": "040000", + "type": "tree", + "sha": "83e9e6847eebc65057a1b2cf20e2e8ea8a265316", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/83e9e6847eebc65057a1b2cf20e2e8ea8a265316" + }, + { + "path": "research/split-skip/vendor/pr54", + "mode": "040000", + "type": "tree", + "sha": "9cd8dc1b75bf0f3807b78fbd110c7b9dedd6a0d9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/9cd8dc1b75bf0f3807b78fbd110c7b9dedd6a0d9" + }, + { + "path": "research/split-skip/vendor/pr54/clone_io.py", + "mode": "100644", + "type": "blob", + "sha": "ff8a05e2058107c59bdb1fed3dac1b1417bddfa7", + "size": 2449, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff8a05e2058107c59bdb1fed3dac1b1417bddfa7" + }, + { + "path": "research/split-skip/vendor/pr54/cloned_graph.py", + "mode": "100644", + "type": "blob", + "sha": "f4fe2d1fb13510876189c9ce7bbb7c8b09628e32", + "size": 13035, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f4fe2d1fb13510876189c9ce7bbb7c8b09628e32" + }, + { + "path": "research/split-skip/witness.py", + "mode": "100644", + "type": "blob", + "sha": "f98907db9c9beccc8b7745a1b41ab5647472f633", + "size": 8246, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f98907db9c9beccc8b7745a1b41ab5647472f633" + }, + { + "path": "research/swapnil-parallel", + "mode": "040000", + "type": "tree", + "sha": "802f46c10b2f8aeaad526df3ad5d789a3cf2dfd6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/802f46c10b2f8aeaad526df3ad5d789a3cf2dfd6" + }, + { + "path": "research/swapnil-parallel/README.md", + "mode": "100644", + "type": "blob", + "sha": "474512178f718277e4fae9d298db0e20970077f0", + "size": 6417, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/474512178f718277e4fae9d298db0e20970077f0" + }, + { + "path": "research/swapnil-parallel/SOURCE.json", + "mode": "100644", + "type": "blob", + "sha": "61c08a34084098887dcf0fc779788a4894595b6c", + "size": 9696, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/61c08a34084098887dcf0fc779788a4894595b6c" + }, + { + "path": "research/swapnil-parallel/upstream", + "mode": "040000", + "type": "tree", + "sha": "0460116e80bfd98b54c17cfac288eb93f3935242", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/0460116e80bfd98b54c17cfac288eb93f3935242" + }, + { + "path": "research/swapnil-parallel/upstream/.gitignore", + "mode": "100644", + "type": "blob", + "sha": "fcaeafddb14b5916950724f02f3be328f0c36ddf", + "size": 23, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fcaeafddb14b5916950724f02f3be328f0c36ddf" + }, + { + "path": "research/swapnil-parallel/upstream/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "research/swapnil-parallel/upstream/Makefile", + "mode": "100644", + "type": "blob", + "sha": "399870142c86ab53b7b3454b572add76523236a1", + "size": 1483, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/399870142c86ab53b7b3454b572add76523236a1" + }, + { + "path": "research/swapnil-parallel/upstream/NOTICE", + "mode": "100644", + "type": "blob", + "sha": "7755f325dd0a8d6d692f041c4a0db17851eed1d0", + "size": 2158, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7755f325dd0a8d6d692f041c4a0db17851eed1d0" + }, + { + "path": "research/swapnil-parallel/upstream/README.md", + "mode": "100644", + "type": "blob", + "sha": "2bf0759cb03e07689a3ce98c440eb101c5ac23d2", + "size": 13363, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2bf0759cb03e07689a3ce98c440eb101c5ac23d2" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts", + "mode": "040000", + "type": "tree", + "sha": "da9a954e0997b603ab9b7708d8eb282e03fdb581", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/da9a954e0997b603ab9b7708d8eb282e03fdb581" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/complex-source-frames.pdf", + "mode": "100644", + "type": "blob", + "sha": "68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0", + "size": 53103, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68b0dcd2192d3c3055b6db68ab46ff7cfe25c3f0" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/copied-centres.pdf", + "mode": "100644", + "type": "blob", + "sha": "c290bc5431382e6af840895e6892fba1dc165c7a", + "size": 43970, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c290bc5431382e6af840895e6892fba1dc165c7a" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/data-edge-batching.pdf", + "mode": "100644", + "type": "blob", + "sha": "cb94268721cc71fe42eb54c76b43fff566492d37", + "size": 39141, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cb94268721cc71fe42eb54c76b43fff566492d37" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/fine-field-lemma.pdf", + "mode": "100644", + "type": "blob", + "sha": "ff5bd622016110694ff79aa283e25b52953d8832", + "size": 95968, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ff5bd622016110694ff79aa283e25b52953d8832" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/flag-basis.pdf", + "mode": "100644", + "type": "blob", + "sha": "39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5", + "size": 54385, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/39b1289de2bedc139ebb8adfd9781ca9dbc9b5a5" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/partial-swap-batching.pdf", + "mode": "100644", + "type": "blob", + "sha": "a03f30c451a2baf59a69f8d5b30d12687f9ffdfc", + "size": 60416, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a03f30c451a2baf59a69f8d5b30d12687f9ffdfc" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/round3-combination.pdf", + "mode": "100644", + "type": "blob", + "sha": "0706f9d115468ca9314c47503b190346be67a0c9", + "size": 45026, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0706f9d115468ca9314c47503b190346be67a0c9" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/segmented-inverse.pdf", + "mode": "100644", + "type": "blob", + "sha": "65a2e177778547c4029570aee05237d1e69dcf3d", + "size": 104153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65a2e177778547c4029570aee05237d1e69dcf3d" + }, + { + "path": "research/swapnil-parallel/upstream/artifacts/stack-notes.pdf", + "mode": "100644", + "type": "blob", + "sha": "827f07e6b5be63d903f8f5becc1a57cf99355db0", + "size": 94315, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/827f07e6b5be63d903f8f5becc1a57cf99355db0" + }, + { + "path": "research/swapnil-parallel/upstream/certificates", + "mode": "040000", + "type": "tree", + "sha": "e721bf694bd4e6246802acda64bfc6646a129a4d", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e721bf694bd4e6246802acda64bfc6646a129a4d" + }, + { + "path": "research/swapnil-parallel/upstream/certificates/external", + "mode": "040000", + "type": "tree", + "sha": "b779d664d6cf75884e59cfd04f75ac59ba78f2d7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/b779d664d6cf75884e59cfd04f75ac59ba78f2d7" + }, + { + "path": "research/swapnil-parallel/upstream/certificates/external/pr24-bit-network.json", + "mode": "100644", + "type": "blob", + "sha": "4e212f628196ee434aa67b09a1cedcd8d4d72e85", + "size": 1634, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e212f628196ee434aa67b09a1cedcd8d4d72e85" + }, + { + "path": "research/swapnil-parallel/upstream/certificates/identities.json", + "mode": "100644", + "type": "blob", + "sha": "a87f969d341e04fa60fd48eff7cbd639bda955b1", + "size": 982, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a87f969d341e04fa60fd48eff7cbd639bda955b1" + }, + { + "path": "research/swapnil-parallel/upstream/certificates/witness.json", + "mode": "100644", + "type": "blob", + "sha": "94339ac381b3a3eea3f5edfb0638bbd06d617282", + "size": 1307, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94339ac381b3a3eea3f5edfb0638bbd06d617282" + }, + { + "path": "research/swapnil-parallel/upstream/independent", + "mode": "040000", + "type": "tree", + "sha": "25a3b10ba889e733f0931b09625410b95a5cd2f8", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/25a3b10ba889e733f0931b09625410b95a5cd2f8" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network", + "mode": "040000", + "type": "tree", + "sha": "cc366a4b63922a8ff6633e15af4a5af51b37f97c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cc366a4b63922a8ff6633e15af4a5af51b37f97c" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/README.md", + "mode": "100644", + "type": "blob", + "sha": "95a5da44ed26c34d3cb8dec581894a873ab5ade3", + "size": 1374, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/95a5da44ed26c34d3cb8dec581894a873ab5ade3" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/bc.py", + "mode": "100644", + "type": "blob", + "sha": "53e00de297d6f693c19c88425292647f594dac63", + "size": 778, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/53e00de297d6f693c19c88425292647f594dac63" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/fullbatch_cert.py", + "mode": "100644", + "type": "blob", + "sha": "103bbb7d271c2bfd05206a35aabd14986eaf9c0e", + "size": 1754, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/103bbb7d271c2bfd05206a35aabd14986eaf9c0e" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/fullbatch_hist.py", + "mode": "100644", + "type": "blob", + "sha": "5b04ed68ec9fb3c66bdd96025d14ed3dcb2a1458", + "size": 3955, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5b04ed68ec9fb3c66bdd96025d14ed3dcb2a1458" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/labels.py", + "mode": "100644", + "type": "blob", + "sha": "ec70ed13a59851c16202665dd34f667fde54708d", + "size": 3259, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ec70ed13a59851c16202665dd34f667fde54708d" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/roles.py", + "mode": "100644", + "type": "blob", + "sha": "d0d0594e2dee738f64401face0007501c9ccb4b9", + "size": 1070, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d0d0594e2dee738f64401face0007501c9ccb4b9" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/side.py", + "mode": "100644", + "type": "blob", + "sha": "2a625732bb10238aeb2d0f256dabd794b276262b", + "size": 8238, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2a625732bb10238aeb2d0f256dabd794b276262b" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/sourceframe_labels.py", + "mode": "100644", + "type": "blob", + "sha": "ae6a68014ad822a09a729fc06f89a2375730a65e", + "size": 4296, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ae6a68014ad822a09a729fc06f89a2375730a65e" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/sourceframe_sim.py", + "mode": "100644", + "type": "blob", + "sha": "ca684ec9badd9f4305d584f4786f6042d35b87e3", + "size": 8353, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ca684ec9badd9f4305d584f4786f6042d35b87e3" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-network/sourceframe_trace.py", + "mode": "100644", + "type": "blob", + "sha": "965b9101c68167a245b17bbdf49f884b2f62d5db", + "size": 7269, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/965b9101c68167a245b17bbdf49f884b2f62d5db" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage", + "mode": "040000", + "type": "tree", + "sha": "c64d9826d080bac09b589091f525ab9efef6573b", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c64d9826d080bac09b589091f525ab9efef6573b" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage/cert.py", + "mode": "100644", + "type": "blob", + "sha": "bb6879adcd3b2a0c78afba69ea05ed154e4b786b", + "size": 1983, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bb6879adcd3b2a0c78afba69ea05ed154e4b786b" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage/frames.py", + "mode": "100644", + "type": "blob", + "sha": "45126062136d58f2d4fedcf549f40cd95d456c7f", + "size": 4206, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/45126062136d58f2d4fedcf549f40cd95d456c7f" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage/hist.py", + "mode": "100644", + "type": "blob", + "sha": "30fc761818781e881962cbab3efcb0547e1173a1", + "size": 6689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/30fc761818781e881962cbab3efcb0547e1173a1" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage/producer.py", + "mode": "100644", + "type": "blob", + "sha": "10d2110f9bf25a857f5b7fef76bb95fa367d3eac", + "size": 12485, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/10d2110f9bf25a857f5b7fef76bb95fa367d3eac" + }, + { + "path": "research/swapnil-parallel/upstream/independent/complex-twostage/run.py", + "mode": "100644", + "type": "blob", + "sha": "fe438f91656df7dc6b236d7b2000261282776228", + "size": 1365, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fe438f91656df7dc6b236d7b2000261282776228" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap", + "mode": "040000", + "type": "tree", + "sha": "5f71b6044b61e30841c7fb22283b5fac72429750", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5f71b6044b61e30841c7fb22283b5fac72429750" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap/README.md", + "mode": "100644", + "type": "blob", + "sha": "536b9b40604d1391582b5e86ccc6aac64dc236d7", + "size": 439, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/536b9b40604d1391582b5e86ccc6aac64dc236d7" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap/factor.py", + "mode": "100644", + "type": "blob", + "sha": "9908b695e021f9069123e2bf15095caf1ccae337", + "size": 3120, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9908b695e021f9069123e2bf15095caf1ccae337" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap/frames.py", + "mode": "100644", + "type": "blob", + "sha": "31c8130c5946574fd6996a56dac246ee688bffb1", + "size": 9402, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31c8130c5946574fd6996a56dac246ee688bffb1" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap/moment.py", + "mode": "100644", + "type": "blob", + "sha": "1d0c379fb8490f6f51717888da5904c9c1168e44", + "size": 2205, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d0c379fb8490f6f51717888da5904c9c1168e44" + }, + { + "path": "research/swapnil-parallel/upstream/independent/partial-swap/test_factor.py", + "mode": "100644", + "type": "blob", + "sha": "aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0", + "size": 5524, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa9f0200ad5fc1f51ecdb9e257d397fcb3cc25c0" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts", + "mode": "040000", + "type": "tree", + "sha": "77b85d5afb2aba8a481407796e2cdaf043eb1f6a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/77b85d5afb2aba8a481407796e2cdaf043eb1f6a" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts/README.md", + "mode": "100644", + "type": "blob", + "sha": "390bb577fd4ec1fa774ded95887ce5855adc17e7", + "size": 893, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/390bb577fd4ec1fa774ded95887ce5855adc17e7" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts/complexside.py", + "mode": "100644", + "type": "blob", + "sha": "5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6", + "size": 2484, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5dc785f5a0075dfe23d4b9d70056a6cc6c96f9a6" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts/export.py", + "mode": "100644", + "type": "blob", + "sha": "7f95483f148e9022245b3240659478c66ed5df00", + "size": 562, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7f95483f148e9022245b3240659478c66ed5df00" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts/global.cpp", + "mode": "100644", + "type": "blob", + "sha": "eac7e283d2ad8484d4f0718ba455304035a5440d", + "size": 11513, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eac7e283d2ad8484d4f0718ba455304035a5440d" + }, + { + "path": "research/swapnil-parallel/upstream/independent/pr7-role-counts/local.py", + "mode": "100644", + "type": "blob", + "sha": "5e8157d957e67293c66f6793911ef77cf6581135", + "size": 7590, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e8157d957e67293c66f6793911ef77cf6581135" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit", + "mode": "040000", + "type": "tree", + "sha": "a661cc26a4a2926060cd129e0c76ff16126dd7f9", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/a661cc26a4a2926060cd129e0c76ff16126dd7f9" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/bruhat8.py", + "mode": "100644", + "type": "blob", + "sha": "f2c4ece08c01503a9ef42f67081b3abe0aab9321", + "size": 1204, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2c4ece08c01503a9ef42f67081b3abe0aab9321" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/cert_rt.py", + "mode": "100644", + "type": "blob", + "sha": "9113ef8fe31f59ed446658e856318e03f44f062e", + "size": 2123, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9113ef8fe31f59ed446658e856318e03f44f062e" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/checkgm.py", + "mode": "100644", + "type": "blob", + "sha": "b5dd1bef63c86ab9acf49e9093fff704267ebd39", + "size": 1507, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b5dd1bef63c86ab9acf49e9093fff704267ebd39" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/checkside.py", + "mode": "100644", + "type": "blob", + "sha": "f2ac3d9eb82c2428f1ec23c8a071bfbc387e4ad7", + "size": 3204, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2ac3d9eb82c2428f1ec23c8a071bfbc387e4ad7" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/corners.py", + "mode": "100644", + "type": "blob", + "sha": "810144541f6811b2407df94b5ca95deb25f6ff6d", + "size": 5671, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/810144541f6811b2407df94b5ca95deb25f6ff6d" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/flag_existence.py", + "mode": "100644", + "type": "blob", + "sha": "a6143f138385df59b936814ec33b4bb6611330ec", + "size": 5766, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a6143f138385df59b936814ec33b4bb6611330ec" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/flagbasis.py", + "mode": "100644", + "type": "blob", + "sha": "98893c5a204513a784e783a5fd25b16570a75f39", + "size": 14081, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/98893c5a204513a784e783a5fd25b16570a75f39" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/gmside.py", + "mode": "100644", + "type": "blob", + "sha": "69862f57d00c67c575e51be323b2db351796172a", + "size": 1667, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/69862f57d00c67c575e51be323b2db351796172a" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/moment.py", + "mode": "100644", + "type": "blob", + "sha": "c514c372102a9ae4189bd573f6fb0d276fc54f1e", + "size": 3907, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c514c372102a9ae4189bd573f6fb0d276fc54f1e" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/orders.py", + "mode": "100644", + "type": "blob", + "sha": "86df1026f34ea313176aa06fe264d3e6b6469875", + "size": 1665, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/86df1026f34ea313176aa06fe264d3e6b6469875" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/rtgm.py", + "mode": "100644", + "type": "blob", + "sha": "c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04", + "size": 7431, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c82f44c84acc59f4ac0f4b2cf16e6c2815acbe04" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/side_chains.py", + "mode": "100644", + "type": "blob", + "sha": "d08377f94ea85799a1aadac6aef69df4607297fe", + "size": 6893, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d08377f94ea85799a1aadac6aef69df4607297fe" + }, + { + "path": "research/swapnil-parallel/upstream/independent/two-stage-bit/sidegen.py", + "mode": "100644", + "type": "blob", + "sha": "7ab495d87c762cfc00e485711d5f5d58d97e3fc1", + "size": 5515, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7ab495d87c762cfc00e485711d5f5d58d97e3fc1" + }, + { + "path": "research/swapnil-parallel/upstream/lean", + "mode": "040000", + "type": "tree", + "sha": "db6ae3d101b9958f41ab977b698e66431f604bd7", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/db6ae3d101b9958f41ab977b698e66431f604bd7" + }, + { + "path": "research/swapnil-parallel/upstream/lean/Round5.lean", + "mode": "100644", + "type": "blob", + "sha": "2577a55fb158a46bb7c82db5e7f53587c5b5e91b", + "size": 5337, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2577a55fb158a46bb7c82db5e7f53587c5b5e91b" + }, + { + "path": "research/swapnil-parallel/upstream/lean/Round6.lean", + "mode": "100644", + "type": "blob", + "sha": "50514f86023fd1e948dd9bf9c9be2ec11d12e166", + "size": 4793, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50514f86023fd1e948dd9bf9c9be2ec11d12e166" + }, + { + "path": "research/swapnil-parallel/upstream/lean/dump.py", + "mode": "100644", + "type": "blob", + "sha": "dcc74f0aa73809eed6a1b60b6a4630945864e964", + "size": 1457, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dcc74f0aa73809eed6a1b60b6a4630945864e964" + }, + { + "path": "research/swapnil-parallel/upstream/lean/dump6.py", + "mode": "100644", + "type": "blob", + "sha": "564d980dd46da700b9cef392e8273bb2f02b6cc4", + "size": 1235, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/564d980dd46da700b9cef392e8273bb2f02b6cc4" + }, + { + "path": "research/swapnil-parallel/upstream/lean/gen.py", + "mode": "100644", + "type": "blob", + "sha": "019da04aed46e87ab641733032341687d494818d", + "size": 5453, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/019da04aed46e87ab641733032341687d494818d" + }, + { + "path": "research/swapnil-parallel/upstream/lean/round5-histograms.json", + "mode": "100644", + "type": "blob", + "sha": "d04e8b717dda125c010e7d1717f68530c79b03a6", + "size": 1498, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d04e8b717dda125c010e7d1717f68530c79b03a6" + }, + { + "path": "research/swapnil-parallel/upstream/lean/round6-histograms.json", + "mode": "100644", + "type": "blob", + "sha": "d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3", + "size": 956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d6b584964eadbbadc12a2b79bfa9dc9eaafdcbd3" + }, + { + "path": "research/swapnil-parallel/upstream/notes", + "mode": "040000", + "type": "tree", + "sha": "db6b1ba32c7a11d176529eb69c5500e37fc766a6", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/db6b1ba32c7a11d176529eb69c5500e37fc766a6" + }, + { + "path": "research/swapnil-parallel/upstream/notes/complex-source-frames.tex", + "mode": "100644", + "type": "blob", + "sha": "65b9e9129a5c4ebe205c0c971f8559a571808b95", + "size": 4632, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/65b9e9129a5c4ebe205c0c971f8559a571808b95" + }, + { + "path": "research/swapnil-parallel/upstream/notes/copied-centres.tex", + "mode": "100644", + "type": "blob", + "sha": "cdcc820c95c9aa984a703460a968421bb37189a0", + "size": 4267, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cdcc820c95c9aa984a703460a968421bb37189a0" + }, + { + "path": "research/swapnil-parallel/upstream/notes/data-edge-batching.tex", + "mode": "100644", + "type": "blob", + "sha": "76c91c10c96bbb0432f7f4996c5734e5eee0b956", + "size": 2201, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/76c91c10c96bbb0432f7f4996c5734e5eee0b956" + }, + { + "path": "research/swapnil-parallel/upstream/notes/fine-field-lemma.tex", + "mode": "100644", + "type": "blob", + "sha": "331789a6f16c5aef87a37eedef147a3146450b86", + "size": 19643, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/331789a6f16c5aef87a37eedef147a3146450b86" + }, + { + "path": "research/swapnil-parallel/upstream/notes/flag-basis.tex", + "mode": "100644", + "type": "blob", + "sha": "5647021edd381d28fbb44ced0f8f7bcfcdeaa72f", + "size": 6846, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5647021edd381d28fbb44ced0f8f7bcfcdeaa72f" + }, + { + "path": "research/swapnil-parallel/upstream/notes/partial-swap-batching.tex", + "mode": "100644", + "type": "blob", + "sha": "319f6447632924760047f4a49d0f070a3094de37", + "size": 7133, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/319f6447632924760047f4a49d0f070a3094de37" + }, + { + "path": "research/swapnil-parallel/upstream/notes/round3-combination.tex", + "mode": "100644", + "type": "blob", + "sha": "74d1f9a16673bb2b6258028a4259df7f0be67b35", + "size": 4060, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74d1f9a16673bb2b6258028a4259df7f0be67b35" + }, + { + "path": "research/swapnil-parallel/upstream/notes/segmented-inverse.tex", + "mode": "100644", + "type": "blob", + "sha": "09ad215ccf3876d604fbbea1f25e772cd63e875b", + "size": 19302, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/09ad215ccf3876d604fbbea1f25e772cd63e875b" + }, + { + "path": "research/swapnil-parallel/upstream/notes/stack-notes.tex", + "mode": "100644", + "type": "blob", + "sha": "2c77009e0119100371d9546519f9fa06e5fe814f", + "size": 16610, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2c77009e0119100371d9546519f9fa06e5fe814f" + }, + { + "path": "research/swapnil-parallel/upstream/scripts", + "mode": "040000", + "type": "tree", + "sha": "fa9e623c876c4ac052ed9d250530d21c343a2280", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/fa9e623c876c4ac052ed9d250530d21c343a2280" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/certificate.py", + "mode": "100644", + "type": "blob", + "sha": "71c743a58a3d7027b865572f8bb2c5f6afe8c9db", + "size": 4597, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/71c743a58a3d7027b865572f8bb2c5f6afe8c9db" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/certificate_round3.py", + "mode": "100644", + "type": "blob", + "sha": "c5a9fa429bd88f7134eadf5c85eb7ce39c573e28", + "size": 4474, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c5a9fa429bd88f7134eadf5c85eb7ce39c573e28" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/certificate_round4.py", + "mode": "100644", + "type": "blob", + "sha": "5f6b2c6910563bf534f43d308d57679a90f10033", + "size": 2915, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5f6b2c6910563bf534f43d308d57679a90f10033" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/certificate_round5.py", + "mode": "100644", + "type": "blob", + "sha": "73403788933bd05b3d3d117a09a38ca519c85482", + "size": 3413, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/73403788933bd05b3d3d117a09a38ca519c85482" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/certificate_round6.py", + "mode": "100644", + "type": "blob", + "sha": "aeb3e6f6c4490a097e82763517005519ed9fba3d", + "size": 2479, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aeb3e6f6c4490a097e82763517005519ed9fba3d" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_fine_field.py", + "mode": "100644", + "type": "blob", + "sha": "13d2316ee5bf9a01514855267dee54ae583111a4", + "size": 19709, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13d2316ee5bf9a01514855267dee54ae583111a4" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_gs_path.py", + "mode": "100644", + "type": "blob", + "sha": "b1e4281c733dc395155c4547ffc50a7b3a87fd2a", + "size": 13237, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b1e4281c733dc395155c4547ffc50a7b3a87fd2a" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_identities.py", + "mode": "100644", + "type": "blob", + "sha": "b4c481350ad8890d479fdcf954f79a04c15cd548", + "size": 2762, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b4c481350ad8890d479fdcf954f79a04c15cd548" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_reuse_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "447418acb431af6110b10f62f9581378cf24f1bf", + "size": 5681, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/447418acb431af6110b10f62f9581378cf24f1bf" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_segmented_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c", + "size": 3976, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/089cbec2bd30dc5d5384b88cf1fd2bf2e5594a1c" + }, + { + "path": "research/swapnil-parallel/upstream/scripts/check_subblock_inverse.py", + "mode": "100644", + "type": "blob", + "sha": "a9876c9fc01ca077dcaf13b095019357560ffd6c", + "size": 3733, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a9876c9fc01ca077dcaf13b095019357560ffd6c" + }, + { + "path": "research/swapnil-parallel/upstream/tests", + "mode": "040000", + "type": "tree", + "sha": "4624310b54469acbfbb0644d627fa2d2fc5ffc6a", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/4624310b54469acbfbb0644d627fa2d2fc5ffc6a" + }, + { + "path": "research/swapnil-parallel/upstream/tests/test_round3.py", + "mode": "100644", + "type": "blob", + "sha": "33116082d2d11bbcfa0144c54dda5c6b8fb42e1c", + "size": 1262, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/33116082d2d11bbcfa0144c54dda5c6b8fb42e1c" + }, + { + "path": "research/swapnil-parallel/upstream/tests/test_round4.py", + "mode": "100644", + "type": "blob", + "sha": "68bb03e902271d87c59a102e0a83205d87cc870e", + "size": 1781, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/68bb03e902271d87c59a102e0a83205d87cc870e" + }, + { + "path": "research/swapnil-parallel/upstream/tests/test_round5.py", + "mode": "100644", + "type": "blob", + "sha": "f88e4647631a1b525faac9151fa76f0534edfd15", + "size": 1750, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f88e4647631a1b525faac9151fa76f0534edfd15" + }, + { + "path": "research/swapnil-parallel/upstream/tests/test_round6.py", + "mode": "100644", + "type": "blob", + "sha": "5af8799c2c1df73d277b3ca38dabc1b9d8b64b05", + "size": 1063, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5af8799c2c1df73d277b3ca38dabc1b9d8b64b05" + }, + { + "path": "research/swapnil-parallel/upstream/tests/test_witness.py", + "mode": "100644", + "type": "blob", + "sha": "a4412d43150ccb76e8cef7947a8e6f7cf3165ea5", + "size": 2066, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a4412d43150ccb76e8cef7947a8e6f7cf3165ea5" + }, + { + "path": "research/swapnil-parallel/verification.json", + "mode": "100644", + "type": "blob", + "sha": "05cd85f6f1da9378bad1a8b6dbeca3ec24eccd12", + "size": 2621, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/05cd85f6f1da9378bad1a8b6dbeca3ec24eccd12" + }, + { + "path": "research/swapnil-parallel/verify.py", + "mode": "100644", + "type": "blob", + "sha": "514f49ed243bd84e29174d6261898f6fb9214a5e", + "size": 8287, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/514f49ed243bd84e29174d6261898f6fb9214a5e" + }, + { + "path": "scripts", + "mode": "040000", + "type": "tree", + "sha": "e225f2905970c57e73502ba81168e94bfcf5d86c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e225f2905970c57e73502ba81168e94bfcf5d86c" + }, + { + "path": "scripts/audit_additive_labels.py", + "mode": "100644", + "type": "blob", + "sha": "97d6796b5dd6e5aacff8b53558b3f23e0ded3aee", + "size": 2630, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/97d6796b5dd6e5aacff8b53558b3f23e0ded3aee" + }, + { + "path": "scripts/audit_affine_vectors.py", + "mode": "100644", + "type": "blob", + "sha": "9f5e3dff5e7c0444d160fec3a773fd702b0bc569", + "size": 1702, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9f5e3dff5e7c0444d160fec3a773fd702b0bc569" + }, + { + "path": "scripts/audit_bit_compression.py", + "mode": "100644", + "type": "blob", + "sha": "bc2521f862b1710b4afb060f07bcbeb595f78bce", + "size": 8274, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc2521f862b1710b4afb060f07bcbeb595f78bce" + }, + { + "path": "scripts/audit_block_carry.py", + "mode": "100644", + "type": "blob", + "sha": "052d4a1897478ffc6cfe4baef0cb326557dc8a2b", + "size": 8870, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/052d4a1897478ffc6cfe4baef0cb326557dc8a2b" + }, + { + "path": "scripts/audit_block_core.py", + "mode": "100644", + "type": "blob", + "sha": "465c4309cc8f5f5e481e76b3eea3ef20ebbce2ca", + "size": 2554, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/465c4309cc8f5f5e481e76b3eea3ef20ebbce2ca" + }, + { + "path": "scripts/audit_block_labels.py", + "mode": "100644", + "type": "blob", + "sha": "5270126421a2a0a35945a50dd76663c17ca65afc", + "size": 4442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5270126421a2a0a35945a50dd76663c17ca65afc" + }, + { + "path": "scripts/audit_cancellation.py", + "mode": "100644", + "type": "blob", + "sha": "bc3900f5903337d91a94f28d51429754c4c4b417", + "size": 12079, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bc3900f5903337d91a94f28d51429754c4c4b417" + }, + { + "path": "scripts/audit_coded_carries.py", + "mode": "100644", + "type": "blob", + "sha": "9caa445f8105826f363580c45f2e513a2bc7047d", + "size": 7113, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9caa445f8105826f363580c45f2e513a2bc7047d" + }, + { + "path": "scripts/audit_community_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "41176b012f4927b34d20fce65f085cecb72f64aa", + "size": 5153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/41176b012f4927b34d20fce65f085cecb72f64aa" + }, + { + "path": "scripts/audit_compact_controls.py", + "mode": "100644", + "type": "blob", + "sha": "22da5574cb160fafab359a0a41bfe86db5a3bc34", + "size": 7790, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/22da5574cb160fafab359a0a41bfe86db5a3bc34" + }, + { + "path": "scripts/audit_complex_centers.py", + "mode": "100644", + "type": "blob", + "sha": "3d985ee3eb1fd43ab5cc07a8570b438bf080e4a4", + "size": 3092, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3d985ee3eb1fd43ab5cc07a8570b438bf080e4a4" + }, + { + "path": "scripts/audit_core_limits.py", + "mode": "100644", + "type": "blob", + "sha": "954b1fadc72200af5a5355287eb7c2f1369c688f", + "size": 1392, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/954b1fadc72200af5a5355287eb7c2f1369c688f" + }, + { + "path": "scripts/audit_cube_cores.py", + "mode": "100644", + "type": "blob", + "sha": "c3a92b6616566b26c1fd477c48793d3064988d17", + "size": 3070, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c3a92b6616566b26c1fd477c48793d3064988d17" + }, + { + "path": "scripts/audit_cyclic_topology.py", + "mode": "100644", + "type": "blob", + "sha": "a6420a4ccf3066ba9f54cfb9f758cb6d9b9b3b90", + "size": 5987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a6420a4ccf3066ba9f54cfb9f758cb6d9b9b3b90" + }, + { + "path": "scripts/audit_disjoint_tensor.py", + "mode": "100644", + "type": "blob", + "sha": "08cb8184abcb7f81434395871152e4902df8cf84", + "size": 3593, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/08cb8184abcb7f81434395871152e4902df8cf84" + }, + { + "path": "scripts/audit_early_sharing.py", + "mode": "100644", + "type": "blob", + "sha": "33ce7c0dcffe97acab529700c348e2cd430ad874", + "size": 2440, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/33ce7c0dcffe97acab529700c348e2cd430ad874" + }, + { + "path": "scripts/audit_fano_completion.py", + "mode": "100644", + "type": "blob", + "sha": "56e3370aea0678ea6ee4228083fa570a9adb124e", + "size": 7455, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/56e3370aea0678ea6ee4228083fa570a9adb124e" + }, + { + "path": "scripts/audit_fano_permutation.py", + "mode": "100644", + "type": "blob", + "sha": "cbb09c4507c9030e4a1bcf9672e41ae470552398", + "size": 6460, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cbb09c4507c9030e4a1bcf9672e41ae470552398" + }, + { + "path": "scripts/audit_followup_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "a190d846e24adf332737687d7510576e1da93846", + "size": 4144, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a190d846e24adf332737687d7510576e1da93846" + }, + { + "path": "scripts/audit_fused_block.py", + "mode": "100644", + "type": "blob", + "sha": "c63869d22c6454cf6989bb6e70d41f0571eef985", + "size": 9737, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c63869d22c6454cf6989bb6e70d41f0571eef985" + }, + { + "path": "scripts/audit_gather_schedules.py", + "mode": "100644", + "type": "blob", + "sha": "03b6d9eb30193576a6a281f7897b5ada608369e6", + "size": 7616, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/03b6d9eb30193576a6a281f7897b5ada608369e6" + }, + { + "path": "scripts/audit_general_guard.py", + "mode": "100644", + "type": "blob", + "sha": "dd7d53ba8e0df79ec154b1426305063457b5595b", + "size": 2854, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dd7d53ba8e0df79ec154b1426305063457b5595b" + }, + { + "path": "scripts/audit_inplace_side.py", + "mode": "100644", + "type": "blob", + "sha": "2e9108178ee2e07d17f52d7cf79e079e91ba5feb", + "size": 2376, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e9108178ee2e07d17f52d7cf79e079e91ba5feb" + }, + { + "path": "scripts/audit_joint_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "5e0c224e9a8baaece4a5013234cb9f59fdf820d6", + "size": 6491, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5e0c224e9a8baaece4a5013234cb9f59fdf820d6" + }, + { + "path": "scripts/audit_joint_frames.py", + "mode": "100644", + "type": "blob", + "sha": "913be4a1f0a651f3aaf7b4ed1901916918ba2cef", + "size": 10013, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/913be4a1f0a651f3aaf7b4ed1901916918ba2cef" + }, + { + "path": "scripts/audit_joint_return.py", + "mode": "100644", + "type": "blob", + "sha": "c08b089d2527385791067df6c594f7ff9cdfbb7d", + "size": 8769, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c08b089d2527385791067df6c594f7ff9cdfbb7d" + }, + { + "path": "scripts/audit_mixed_point.py", + "mode": "100644", + "type": "blob", + "sha": "0c9e11b9f5d7fae9b5e5a312eca3f246b7aa7d3c", + "size": 8156, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c9e11b9f5d7fae9b5e5a312eca3f246b7aa7d3c" + }, + { + "path": "scripts/audit_packed_movement.py", + "mode": "100644", + "type": "blob", + "sha": "63e7d3af6258da197dffe4c98b7a47907f703916", + "size": 3314, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/63e7d3af6258da197dffe4c98b7a47907f703916" + }, + { + "path": "scripts/audit_pair_candidate.py", + "mode": "100644", + "type": "blob", + "sha": "04da76669657ae46a58c39a8ba07c689e9e43efa", + "size": 6522, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/04da76669657ae46a58c39a8ba07c689e9e43efa" + }, + { + "path": "scripts/audit_parity_side.py", + "mode": "100644", + "type": "blob", + "sha": "61d0f7b77cf86b1bd809d2b4286873295c8964bd", + "size": 2645, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/61d0f7b77cf86b1bd809d2b4286873295c8964bd" + }, + { + "path": "scripts/audit_positive_side.py", + "mode": "100644", + "type": "blob", + "sha": "e3114282b1877cca386e19bdb4e259f62f68bf1b", + "size": 3806, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e3114282b1877cca386e19bdb4e259f62f68bf1b" + }, + { + "path": "scripts/audit_positive_skip_exact.py", + "mode": "100644", + "type": "blob", + "sha": "026294676fbb2f1c48a0c6c20fa52098a5d48e22", + "size": 1930, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/026294676fbb2f1c48a0c6c20fa52098a5d48e22" + }, + { + "path": "scripts/audit_prime_subset_limits.py", + "mode": "100644", + "type": "blob", + "sha": "6b67b94a8c55a642998a81640226f8ede8bd29c9", + "size": 1268, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6b67b94a8c55a642998a81640226f8ede8bd29c9" + }, + { + "path": "scripts/audit_quadratic_affine.py", + "mode": "100644", + "type": "blob", + "sha": "9b1cddc5e836a3038fb7e15dbb5813cfc11c96c6", + "size": 2723, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9b1cddc5e836a3038fb7e15dbb5813cfc11c96c6" + }, + { + "path": "scripts/audit_rank_product_core.py", + "mode": "100644", + "type": "blob", + "sha": "62e1863c128d371af5a07ced80e13740d05979c8", + "size": 12271, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/62e1863c128d371af5a07ced80e13740d05979c8" + }, + { + "path": "scripts/audit_scratch_pooling.py", + "mode": "100644", + "type": "blob", + "sha": "94e169d35f818216956939800cfacede0f41f2f3", + "size": 2280, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94e169d35f818216956939800cfacede0f41f2f3" + }, + { + "path": "scripts/audit_shared_core.py", + "mode": "100644", + "type": "blob", + "sha": "20c6ade31bbe31b76d62f78d7251034cb23f89ff", + "size": 2607, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/20c6ade31bbe31b76d62f78d7251034cb23f89ff" + }, + { + "path": "scripts/audit_short_guards.py", + "mode": "100644", + "type": "blob", + "sha": "e5c52c8afe086a2d0c9418833c550c865ebf8615", + "size": 7956, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e5c52c8afe086a2d0c9418833c550c865ebf8615" + }, + { + "path": "scripts/audit_signed_sparse.py", + "mode": "100644", + "type": "blob", + "sha": "727820f54a4a854ee293c972e43c4c52b2803dd6", + "size": 2851, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/727820f54a4a854ee293c972e43c4c52b2803dd6" + }, + { + "path": "scripts/audit_single_intersection.py", + "mode": "100644", + "type": "blob", + "sha": "4add97e99529deb8a1e0f587290d6f1a2a6f5c9f", + "size": 4287, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4add97e99529deb8a1e0f587290d6f1a2a6f5c9f" + }, + { + "path": "scripts/audit_sparse_fusion.py", + "mode": "100644", + "type": "blob", + "sha": "4e8e789d686b85a49fc12d36f87619eed705d6a8", + "size": 12337, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4e8e789d686b85a49fc12d36f87619eed705d6a8" + }, + { + "path": "scripts/audit_split_centers.py", + "mode": "100644", + "type": "blob", + "sha": "13f8faba87ca3db7a5daa3d94e652bdb91224d06", + "size": 8825, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13f8faba87ca3db7a5daa3d94e652bdb91224d06" + }, + { + "path": "scripts/audit_stage_pair.py", + "mode": "100644", + "type": "blob", + "sha": "99f2fad2d7929f8753b6b9c6cabd276d110c88d9", + "size": 14015, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/99f2fad2d7929f8753b6b9c6cabd276d110c88d9" + }, + { + "path": "scripts/audit_stronger_screens.py", + "mode": "100644", + "type": "blob", + "sha": "35640b7964c4b893db010598db2535d5e49ab206", + "size": 4240, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/35640b7964c4b893db010598db2535d5e49ab206" + }, + { + "path": "scripts/audit_subset_cores.py", + "mode": "100644", + "type": "blob", + "sha": "4249c322ee806337ec9c907f917584da0b71abac", + "size": 5846, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4249c322ee806337ec9c907f917584da0b71abac" + }, + { + "path": "scripts/audit_ternary_side.py", + "mode": "100644", + "type": "blob", + "sha": "f2aaf97d39cf312a66cc444fb5b0abd2162e74ee", + "size": 3547, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2aaf97d39cf312a66cc444fb5b0abd2162e74ee" + }, + { + "path": "scripts/batched_bit_rank_moment.py", + "mode": "100644", + "type": "blob", + "sha": "594cda4c33e040bfa312398b60a22d7b19ec6f25", + "size": 5208, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/594cda4c33e040bfa312398b60a22d7b19ec6f25" + }, + { + "path": "scripts/batched_network.py", + "mode": "100644", + "type": "blob", + "sha": "c5904608fb1e5c0211356c1215326de55d49a18f", + "size": 7129, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c5904608fb1e5c0211356c1215326de55d49a18f" + }, + { + "path": "scripts/binary_phase_frames.py", + "mode": "100644", + "type": "blob", + "sha": "c8e4fa71fe60550324f9e43c1dd5ad6d9bf4e2f4", + "size": 3786, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8e4fa71fe60550324f9e43c1dd5ad6d9bf4e2f4" + }, + { + "path": "scripts/block_label_targets.py", + "mode": "100644", + "type": "blob", + "sha": "173152ce8dbd990f3f654f8aa992048088860048", + "size": 2570, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/173152ce8dbd990f3f654f8aa992048088860048" + }, + { + "path": "scripts/bulk_complex_guard.py", + "mode": "100644", + "type": "blob", + "sha": "25f32d5130b4790b52fe5e22caaf2d42ff982370", + "size": 2251, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/25f32d5130b4790b52fe5e22caaf2d42ff982370" + }, + { + "path": "scripts/certify.py", + "mode": "100644", + "type": "blob", + "sha": "a773311b726fd1ef98a056f6f76010e872d7908a", + "size": 11276, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a773311b726fd1ef98a056f6f76010e872d7908a" + }, + { + "path": "scripts/check_lean_axioms.py", + "mode": "100644", + "type": "blob", + "sha": "3709039da8c29f11a9668056ee34c3c9f560e9ac", + "size": 1346, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3709039da8c29f11a9668056ee34c3c9f560e9ac" + }, + { + "path": "scripts/compact_control_layer.py", + "mode": "100644", + "type": "blob", + "sha": "11b2e751bfb2fb141b586042b6f6fec4e498c763", + "size": 7892, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/11b2e751bfb2fb141b586042b6f6fec4e498c763" + }, + { + "path": "scripts/complex_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "size": 19732, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9e83a1065cd5b5f337b39de58d61bac335feb7ce" + }, + { + "path": "scripts/complex_compression.py", + "mode": "100644", + "type": "blob", + "sha": "8eb3cff3d013eafef496729667888ffd3824e268", + "size": 16182, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8eb3cff3d013eafef496729667888ffd3824e268" + }, + { + "path": "scripts/complex_network.py", + "mode": "100644", + "type": "blob", + "sha": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "size": 6105, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/af9bb6d7b31f3006189761d99bdd919da84656a8" + }, + { + "path": "scripts/controlled_bit_rank_moment.py", + "mode": "100644", + "type": "blob", + "sha": "0028f3a2f6277c2c08966f934244b2996d5dd484", + "size": 3637, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0028f3a2f6277c2c08966f934244b2996d5dd484" + }, + { + "path": "scripts/copied_centers", + "mode": "040000", + "type": "tree", + "sha": "945c16df65b2c1b468f8543fb74266a4b4802841", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/945c16df65b2c1b468f8543fb74266a4b4802841" + }, + { + "path": "scripts/copied_centers/README.md", + "mode": "100644", + "type": "blob", + "sha": "4dc9de2dc00747497027664496b9cc676b0758e6", + "size": 2400, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4dc9de2dc00747497027664496b9cc676b0758e6" + }, + { + "path": "scripts/copied_centers/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "e0758c53caeeb71fe05eb38bc6ad9bef8a5a8dd9", + "size": 72, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0758c53caeeb71fe05eb38bc6ad9bef8a5a8dd9" + }, + { + "path": "scripts/copied_centers/corners.py", + "mode": "100644", + "type": "blob", + "sha": "80fc438270be82ba4af9fc9aab2dca4d1a6e0029", + "size": 6470, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/80fc438270be82ba4af9fc9aab2dca4d1a6e0029" + }, + { + "path": "scripts/copied_centers/physical.py", + "mode": "100644", + "type": "blob", + "sha": "31d0083382c029e308bde18517dd154c74442457", + "size": 1538, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31d0083382c029e308bde18517dd154c74442457" + }, + { + "path": "scripts/copied_centers_network.py", + "mode": "100644", + "type": "blob", + "sha": "74796d6e1577b4d6745c77d82d586d1c78daf532", + "size": 8812, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74796d6e1577b4d6745c77d82d586d1c78daf532" + }, + { + "path": "scripts/copied_centers_producer.py", + "mode": "100644", + "type": "blob", + "sha": "01ef0cd5b9ea22d21a58563809a4431e6e2c4b7d", + "size": 4869, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/01ef0cd5b9ea22d21a58563809a4431e6e2c4b7d" + }, + { + "path": "scripts/dag_network.py", + "mode": "100644", + "type": "blob", + "sha": "e280c59564eaa6821130fab140d1596d2864de66", + "size": 6752, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e280c59564eaa6821130fab140d1596d2864de66" + }, + { + "path": "scripts/deferred_product", + "mode": "040000", + "type": "tree", + "sha": "7dfda253ccdbb59be1f053127c46cdda3648fcf4", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/7dfda253ccdbb59be1f053127c46cdda3648fcf4" + }, + { + "path": "scripts/deferred_product/complex_frames.py", + "mode": "100644", + "type": "blob", + "sha": "b8db662f7182fe59602784b5e05600c613ce99bb", + "size": 16461, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b8db662f7182fe59602784b5e05600c613ce99bb" + }, + { + "path": "scripts/deferred_product/replayed.py", + "mode": "100644", + "type": "blob", + "sha": "673fbbba70fd80b490d7990bf3c4c682e34e385d", + "size": 8372, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/673fbbba70fd80b490d7990bf3c4c682e34e385d" + }, + { + "path": "scripts/deferred_product_bit_checks.py", + "mode": "100644", + "type": "blob", + "sha": "b2169aefe31d0805cce4635260498bcc8c6e7492", + "size": 1882, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b2169aefe31d0805cce4635260498bcc8c6e7492" + }, + { + "path": "scripts/deferred_product_complex.py", + "mode": "100644", + "type": "blob", + "sha": "83bf78351281c8cd4c3a95d5274e63a2e113b8c5", + "size": 2358, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/83bf78351281c8cd4c3a95d5274e63a2e113b8c5" + }, + { + "path": "scripts/deferred_product_complex_frames.py", + "mode": "100644", + "type": "blob", + "sha": "1fe60872e94d6cbc16d45a8d8aa3dd856a614be5", + "size": 3098, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1fe60872e94d6cbc16d45a8d8aa3dd856a614be5" + }, + { + "path": "scripts/deferred_product_network.py", + "mode": "100644", + "type": "blob", + "sha": "b757c19fe0df669b15fd7b1c62d84dd3dfecaa72", + "size": 8210, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b757c19fe0df669b15fd7b1c62d84dd3dfecaa72" + }, + { + "path": "scripts/endpoint_gauge", + "mode": "040000", + "type": "tree", + "sha": "ef22569e4f7a361dddc5abab967af9ae5dfb22aa", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/ef22569e4f7a361dddc5abab967af9ae5dfb22aa" + }, + { + "path": "scripts/endpoint_gauge/README.md", + "mode": "100644", + "type": "blob", + "sha": "a19dc16b66c8f576f1f58d4a032247becf30cd55", + "size": 1876, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a19dc16b66c8f576f1f58d4a032247becf30cd55" + }, + { + "path": "scripts/endpoint_gauge/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "aaa2523040cad76f67d851b99e5bbfea1e0d8497", + "size": 74, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aaa2523040cad76f67d851b99e5bbfea1e0d8497" + }, + { + "path": "scripts/endpoint_gauge/bit.py", + "mode": "100644", + "type": "blob", + "sha": "4c62d83a6f4d63270ec34582696ccebbd472be8a", + "size": 966, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4c62d83a6f4d63270ec34582696ccebbd472be8a" + }, + { + "path": "scripts/endpoint_gauge/complex.py", + "mode": "100644", + "type": "blob", + "sha": "7127833c433954c96e7815dba2db62f71016c218", + "size": 8487, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7127833c433954c96e7815dba2db62f71016c218" + }, + { + "path": "scripts/endpoint_gauge/match_complex_general.cpp", + "mode": "100644", + "type": "blob", + "sha": "48df1bfea2ea5368cc612655cbd827527bb9e698", + "size": 4553, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/48df1bfea2ea5368cc612655cbd827527bb9e698" + }, + { + "path": "scripts/endpoint_gauge_network.py", + "mode": "100644", + "type": "blob", + "sha": "86916c09716352cbff529788c517cb5b250f85e0", + "size": 10743, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/86916c09716352cbff529788c517cb5b250f85e0" + }, + { + "path": "scripts/endpoint_gauge_producer.py", + "mode": "100644", + "type": "blob", + "sha": "7e36da67375a2d0fa50aa94f5163a6b14bc59de4", + "size": 6005, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7e36da67375a2d0fa50aa94f5163a6b14bc59de4" + }, + { + "path": "scripts/exclusion_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "aaa99986c4b81c5d4fbe016fd216a4818940bb95", + "size": 8658, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aaa99986c4b81c5d4fbe016fd216a4818940bb95" + }, + { + "path": "scripts/experiments", + "mode": "040000", + "type": "tree", + "sha": "5b65b9e55b947e3d58df1eb57c0fdf50fca394ef", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/5b65b9e55b947e3d58df1eb57c0fdf50fca394ef" + }, + { + "path": "scripts/experiments/affine_vector_screens.py", + "mode": "100644", + "type": "blob", + "sha": "0686b47d4844bedc9dddfacb0bff52ec552120a2", + "size": 6111, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0686b47d4844bedc9dddfacb0bff52ec552120a2" + }, + { + "path": "scripts/experiments/affine_vector_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "0e9a488ac4912cbf2bb83894c1b6c9b607cc02cd", + "size": 76533, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e9a488ac4912cbf2bb83894c1b6c9b607cc02cd" + }, + { + "path": "scripts/experiments/balanced_fano.py", + "mode": "100644", + "type": "blob", + "sha": "136446fa017ae8370c3f069d98ba278f4c5f96ce", + "size": 6111, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/136446fa017ae8370c3f069d98ba278f4c5f96ce" + }, + { + "path": "scripts/experiments/binary_frame_compiler.py", + "mode": "100644", + "type": "blob", + "sha": "f1d1b660677f94e452fab1a0c99c3ad1a49705b9", + "size": 11518, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f1d1b660677f94e452fab1a0c99c3ad1a49705b9" + }, + { + "path": "scripts/experiments/binary_frame_math.py", + "mode": "100644", + "type": "blob", + "sha": "b87855e808802c6b5dbdfb845f2328370ff8a4f0", + "size": 3174, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b87855e808802c6b5dbdfb845f2328370ff8a4f0" + }, + { + "path": "scripts/experiments/binary_frame_profile_prepare.py", + "mode": "100644", + "type": "blob", + "sha": "85ad7b77bda86e5eee0fbe165cc6d5c5bfe4427b", + "size": 3978, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/85ad7b77bda86e5eee0fbe165cc6d5c5bfe4427b" + }, + { + "path": "scripts/experiments/binary_frame_profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "1b52bd057dab5256d012df34b5514aee17686590", + "size": 7175, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b52bd057dab5256d012df34b5514aee17686590" + }, + { + "path": "scripts/experiments/binary_frame_replay.py", + "mode": "100644", + "type": "blob", + "sha": "ea39119bb9069814c0af9bb725c9a5996f0381bd", + "size": 2809, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ea39119bb9069814c0af9bb725c9a5996f0381bd" + }, + { + "path": "scripts/experiments/bit_compression.py", + "mode": "100644", + "type": "blob", + "sha": "1763ac8fd80c79668fd125c566ae074543b6f0e1", + "size": 7011, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1763ac8fd80c79668fd125c566ae074543b6f0e1" + }, + { + "path": "scripts/experiments/block_completion.py", + "mode": "100644", + "type": "blob", + "sha": "aed9deee2f397cfed59a624332777a94ce3d23e4", + "size": 2530, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aed9deee2f397cfed59a624332777a94ce3d23e4" + }, + { + "path": "scripts/experiments/block_core.py", + "mode": "100644", + "type": "blob", + "sha": "971bf31caa06438cf116f96520d538ca71b4d108", + "size": 5148, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/971bf31caa06438cf116f96520d538ca71b4d108" + }, + { + "path": "scripts/experiments/complex_centers.py", + "mode": "100644", + "type": "blob", + "sha": "13be871d501b7ebaaaec7e755ff4834c6cc49dc7", + "size": 3986, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/13be871d501b7ebaaaec7e755ff4834c6cc49dc7" + }, + { + "path": "scripts/experiments/core_limits.py", + "mode": "100644", + "type": "blob", + "sha": "947886b47afc384ab55abb218fbb287c4e15cdb4", + "size": 5474, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/947886b47afc384ab55abb218fbb287c4e15cdb4" + }, + { + "path": "scripts/experiments/cube_core_family.py", + "mode": "100644", + "type": "blob", + "sha": "16f4d56790b2c5f710497b086a8bc8d48057d366", + "size": 5997, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/16f4d56790b2c5f710497b086a8bc8d48057d366" + }, + { + "path": "scripts/experiments/disjoint_tensor.py", + "mode": "100644", + "type": "blob", + "sha": "dd196e67162c349d9b6f7aa27edbed2b1b0b601f", + "size": 12852, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/dd196e67162c349d9b6f7aa27edbed2b1b0b601f" + }, + { + "path": "scripts/experiments/early_sharing.py", + "mode": "100644", + "type": "blob", + "sha": "671df3d5fb4e13d1758edf4efeb7276c65122468", + "size": 3654, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/671df3d5fb4e13d1758edf4efeb7276c65122468" + }, + { + "path": "scripts/experiments/exclusion_greedy.py", + "mode": "100644", + "type": "blob", + "sha": "ed8d290fafb537ca60a65863a7a7cb00ce56e271", + "size": 2119, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed8d290fafb537ca60a65863a7a7cb00ce56e271" + }, + { + "path": "scripts/experiments/fano_completion.py", + "mode": "100644", + "type": "blob", + "sha": "86a0ec6e62fc9a371f03d0e87457a085c9e494f3", + "size": 5314, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/86a0ec6e62fc9a371f03d0e87457a085c9e494f3" + }, + { + "path": "scripts/experiments/fano_permuted_completion.py", + "mode": "100644", + "type": "blob", + "sha": "cc70696bf3c167a3d7110c4f75b0c2c193219495", + "size": 4149, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cc70696bf3c167a3d7110c4f75b0c2c193219495" + }, + { + "path": "scripts/experiments/fano_permuted_routing_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "ae0108f463155c41217c45521fdcb67ff2f3d995", + "size": 32809, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ae0108f463155c41217c45521fdcb67ff2f3d995" + }, + { + "path": "scripts/experiments/fano_routing_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "c4d04ad21c67f6242760b8f3f86289358b7cf2ca", + "size": 4815, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c4d04ad21c67f6242760b8f3f86289358b7cf2ca" + }, + { + "path": "scripts/experiments/inplace_side.py", + "mode": "100644", + "type": "blob", + "sha": "db3de6f1d962ccc3a4eae31f83c72bba995ba44e", + "size": 5273, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db3de6f1d962ccc3a4eae31f83c72bba995ba44e" + }, + { + "path": "scripts/experiments/inplace_side_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "9d9970245a71705da7b84122a8be5b44755b5005", + "size": 48995, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9d9970245a71705da7b84122a8be5b44755b5005" + }, + { + "path": "scripts/experiments/intersection_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "bdcfcd0b3389ec81af3d698decc65c7891e9fbfd", + "size": 4084, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bdcfcd0b3389ec81af3d698decc65c7891e9fbfd" + }, + { + "path": "scripts/experiments/intersection_greedy.py", + "mode": "100644", + "type": "blob", + "sha": "7d8d71dadec0549dfe41810bb2e49180395ed69b", + "size": 2373, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d8d71dadec0549dfe41810bb2e49180395ed69b" + }, + { + "path": "scripts/experiments/joint_dual_compiler.py", + "mode": "100644", + "type": "blob", + "sha": "d799ae9e5c841b4f264fda1f6405f57727fb0335", + "size": 2852, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d799ae9e5c841b4f264fda1f6405f57727fb0335" + }, + { + "path": "scripts/experiments/joint_dual_compose.py", + "mode": "100644", + "type": "blob", + "sha": "1db1f1f606f3b3e7980e794e6e95d2e789aa5092", + "size": 10775, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1db1f1f606f3b3e7980e794e6e95d2e789aa5092" + }, + { + "path": "scripts/experiments/joint_dual_reclaim_compiler.py", + "mode": "100644", + "type": "blob", + "sha": "1eb8dea9fa13033478a5f83b536b7c291c9bc0c8", + "size": 11804, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1eb8dea9fa13033478a5f83b536b7c291c9bc0c8" + }, + { + "path": "scripts/experiments/mixed_point_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "b7f561f416f815d0fd135f0a0464c291a9a68468", + "size": 11029, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b7f561f416f815d0fd135f0a0464c291a9a68468" + }, + { + "path": "scripts/experiments/parity_phase_repair.py", + "mode": "100644", + "type": "blob", + "sha": "abefe12ede95a382b9eeb74906c7c519d94bd705", + "size": 4408, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/abefe12ede95a382b9eeb74906c7c519d94bd705" + }, + { + "path": "scripts/experiments/parity_side.py", + "mode": "100644", + "type": "blob", + "sha": "5a8dc1b84715e914eb6d92b37636b72d6d2f9ebf", + "size": 6575, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5a8dc1b84715e914eb6d92b37636b72d6d2f9ebf" + }, + { + "path": "scripts/experiments/partial_routing.py", + "mode": "100644", + "type": "blob", + "sha": "e0ab64dbbbefe9cc9b3dd6fb81508de09bc60b28", + "size": 2571, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0ab64dbbbefe9cc9b3dd6fb81508de09bc60b28" + }, + { + "path": "scripts/experiments/pin_joint_dual_sources.py", + "mode": "100644", + "type": "blob", + "sha": "94ec6bd77b63babb48f7398973eb7d25958f6d3c", + "size": 2135, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/94ec6bd77b63babb48f7398973eb7d25958f6d3c" + }, + { + "path": "scripts/experiments/positive_side_core.py", + "mode": "100644", + "type": "blob", + "sha": "df3d6d565f2639482b959ecd26a5dffe27c8207f", + "size": 11401, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/df3d6d565f2639482b959ecd26a5dffe27c8207f" + }, + { + "path": "scripts/experiments/prime_core.py", + "mode": "100644", + "type": "blob", + "sha": "ded5b71b4dd886458a352b16c1f5258e451f5f47", + "size": 6028, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ded5b71b4dd886458a352b16c1f5258e451f5f47" + }, + { + "path": "scripts/experiments/prime_subset_limits.py", + "mode": "100644", + "type": "blob", + "sha": "5dfd6ffecff326cebc10edb876d6b142e1a01fc1", + "size": 4265, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5dfd6ffecff326cebc10edb876d6b142e1a01fc1" + }, + { + "path": "scripts/experiments/probe_pair_ranked.py", + "mode": "100644", + "type": "blob", + "sha": "f05fd4ceecc3114ec9fc91dc4b24f22ae8218d24", + "size": 3546, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f05fd4ceecc3114ec9fc91dc4b24f22ae8218d24" + }, + { + "path": "scripts/experiments/quadratic_affine.py", + "mode": "100644", + "type": "blob", + "sha": "271e0a4e0bc077244859009ac2201f172152720b", + "size": 6187, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/271e0a4e0bc077244859009ac2201f172152720b" + }, + { + "path": "scripts/experiments/quadratic_affine_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "134c9255268dd7043138491ad25cb4487e3168b9", + "size": 396953, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/134c9255268dd7043138491ad25cb4487e3168b9" + }, + { + "path": "scripts/experiments/rank_product_core.py", + "mode": "100644", + "type": "blob", + "sha": "e5c093f467aa1edf1fea0e058ccc88806fbc09a1", + "size": 10398, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e5c093f467aa1edf1fea0e058ccc88806fbc09a1" + }, + { + "path": "scripts/experiments/shared_core.py", + "mode": "100644", + "type": "blob", + "sha": "44be9424fc65f7b59eebdaea74de1d7f69b70898", + "size": 3910, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/44be9424fc65f7b59eebdaea74de1d7f69b70898" + }, + { + "path": "scripts/experiments/signed_sparse_core.py", + "mode": "100644", + "type": "blob", + "sha": "724ebd576383b81acfeabfbc6608b22b29196a6f", + "size": 6502, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/724ebd576383b81acfeabfbc6608b22b29196a6f" + }, + { + "path": "scripts/experiments/single_intersection.py", + "mode": "100644", + "type": "blob", + "sha": "c14fdaff1435e90e91049a9e0ee068279f9e112c", + "size": 6999, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c14fdaff1435e90e91049a9e0ee068279f9e112c" + }, + { + "path": "scripts/experiments/single_intersection_witnesses.json", + "mode": "100644", + "type": "blob", + "sha": "f2bb1fb02bd191f954cb2199ee33b856694e466a", + "size": 236176, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f2bb1fb02bd191f954cb2199ee33b856694e466a" + }, + { + "path": "scripts/experiments/skip_frame_README.txt", + "mode": "100644", + "type": "blob", + "sha": "33b615da0571db0b1268340fc4c503ac63868c0e", + "size": 4408, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/33b615da0571db0b1268340fc4c503ac63868c0e" + }, + { + "path": "scripts/experiments/skip_frame_compiler.py", + "mode": "100644", + "type": "blob", + "sha": "2bbb9f2c44ae74df68ace7f6a80fa099688f255d", + "size": 2398, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2bbb9f2c44ae74df68ace7f6a80fa099688f255d" + }, + { + "path": "scripts/experiments/skip_frame_compose.py", + "mode": "100644", + "type": "blob", + "sha": "d9961c9c7f125503e404cccc7174a3dc51f2b2eb", + "size": 7082, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d9961c9c7f125503e404cccc7174a3dc51f2b2eb" + }, + { + "path": "scripts/experiments/subset_core_family.py", + "mode": "100644", + "type": "blob", + "sha": "007e35a943801d5b6f31c343bbbbd931eb6d4ba3", + "size": 8624, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/007e35a943801d5b6f31c343bbbbd931eb6d4ba3" + }, + { + "path": "scripts/experiments/ternary_side.py", + "mode": "100644", + "type": "blob", + "sha": "a50c627e31246aab64af151635a135d4fd7a9f32", + "size": 11467, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a50c627e31246aab64af151635a135d4fd7a9f32" + }, + { + "path": "scripts/experiments/verify_joint_dual.py", + "mode": "100644", + "type": "blob", + "sha": "bb9e7a8d376dc257c53ab09fe7cea1e7c29c38a7", + "size": 4005, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bb9e7a8d376dc257c53ab09fe7cea1e7c29c38a7" + }, + { + "path": "scripts/experiments/verify_skip_frame.py", + "mode": "100644", + "type": "blob", + "sha": "4dbdb25d9f6e24ccd23a01dd0c220f4bf4699c00", + "size": 3268, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4dbdb25d9f6e24ccd23a01dd0c220f4bf4699c00" + }, + { + "path": "scripts/fast_gaussian.py", + "mode": "100644", + "type": "blob", + "sha": "f534b9e894381ddf301d8dda9d4a0f3cb9a2e249", + "size": 8369, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f534b9e894381ddf301d8dda9d4a0f3cb9a2e249" + }, + { + "path": "scripts/fetch_upstream.py", + "mode": "100644", + "type": "blob", + "sha": "fd628c3704806aa19f8d9d73122001f78693ef72", + "size": 2067, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fd628c3704806aa19f8d9d73122001f78693ef72" + }, + { + "path": "scripts/finite_bit_contract.py", + "mode": "100644", + "type": "blob", + "sha": "3b58da79c478d43a6e9ceaebd7f42105eec098c4", + "size": 8729, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3b58da79c478d43a6e9ceaebd7f42105eec098c4" + }, + { + "path": "scripts/general_network_guard.py", + "mode": "100644", + "type": "blob", + "sha": "3fbc230c67a9a57b1439a925d62d863e28dff7d6", + "size": 3458, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3fbc230c67a9a57b1439a925d62d863e28dff7d6" + }, + { + "path": "scripts/incidence_network.py", + "mode": "100644", + "type": "blob", + "sha": "ab0c88c850f05514f7436876bd56abc9d3c0dad2", + "size": 6770, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ab0c88c850f05514f7436876bd56abc9d3c0dad2" + }, + { + "path": "scripts/incidence_rectangles.py", + "mode": "100644", + "type": "blob", + "sha": "2368244337fe923452b7bbd33216a00421ace269", + "size": 4671, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2368244337fe923452b7bbd33216a00421ace269" + }, + { + "path": "scripts/make_batched_patch.py", + "mode": "100644", + "type": "blob", + "sha": "7f56a61ef17da9cc3e9302fa33352dbcf96d0a07", + "size": 16713, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7f56a61ef17da9cc3e9302fa33352dbcf96d0a07" + }, + { + "path": "scripts/make_compact_control_patch.py", + "mode": "100644", + "type": "blob", + "sha": "8c7a209c05d697c84d3fe34d5c0c825c2eb83ee8", + "size": 11183, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8c7a209c05d697c84d3fe34d5c0c825c2eb83ee8" + }, + { + "path": "scripts/make_complex_circuit_patch.py", + "mode": "100644", + "type": "blob", + "sha": "29c79b5d50ff88a418b4d8e21b7dbd2de1a779f9", + "size": 6003, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/29c79b5d50ff88a418b4d8e21b7dbd2de1a779f9" + }, + { + "path": "scripts/make_complex_compression_patch.py", + "mode": "100644", + "type": "blob", + "sha": "c315440d385b8bf2739e8fea8dffb07bd1efd2fb", + "size": 5982, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c315440d385b8bf2739e8fea8dffb07bd1efd2fb" + }, + { + "path": "scripts/make_dag_patch.py", + "mode": "100644", + "type": "blob", + "sha": "cbf4415b662346ca4a0f93b7f12bd47b190a6638", + "size": 2308, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cbf4415b662346ca4a0f93b7f12bd47b190a6638" + }, + { + "path": "scripts/make_fast_gaussian_patch.py", + "mode": "100644", + "type": "blob", + "sha": "7d77ef37bb83fe2015b7f9c08fbb3c81c12118f3", + "size": 15188, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d77ef37bb83fe2015b7f9c08fbb3c81c12118f3" + }, + { + "path": "scripts/make_incidence_patch.py", + "mode": "100644", + "type": "blob", + "sha": "fdf8c92b34d9886c7687d99dcba8ba398eabc5e7", + "size": 2528, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fdf8c92b34d9886c7687d99dcba8ba398eabc5e7" + }, + { + "path": "scripts/make_nonadjacent_patch.py", + "mode": "100644", + "type": "blob", + "sha": "6c54971412d32bf247275ede7384053946310b90", + "size": 9953, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c54971412d32bf247275ede7384053946310b90" + }, + { + "path": "scripts/make_paired_patch.py", + "mode": "100644", + "type": "blob", + "sha": "bee14831486d3f7845196a7e8164f1767748585d", + "size": 5632, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bee14831486d3f7845196a7e8164f1767748585d" + }, + { + "path": "scripts/make_patch.py", + "mode": "100644", + "type": "blob", + "sha": "5dc55fdd16c99f0f044306e24d863d7be32770e0", + "size": 11884, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5dc55fdd16c99f0f044306e24d863d7be32770e0" + }, + { + "path": "scripts/make_prime_field_patch.py", + "mode": "100644", + "type": "blob", + "sha": "064f9b345cedb32303190227089ddb92980ba723", + "size": 4346, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/064f9b345cedb32303190227089ddb92980ba723" + }, + { + "path": "scripts/make_reuse_patch.py", + "mode": "100644", + "type": "blob", + "sha": "db49a60d6cb5b051d5f2bceb03f94c1fea556761", + "size": 7827, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db49a60d6cb5b051d5f2bceb03f94c1fea556761" + }, + { + "path": "scripts/make_shared_point_patch.py", + "mode": "100644", + "type": "blob", + "sha": "28142e5f4d89898d0ccc51b137770df8c0b9d3eb", + "size": 1863, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/28142e5f4d89898d0ccc51b137770df8c0b9d3eb" + }, + { + "path": "scripts/make_ternary_patch.py", + "mode": "100644", + "type": "blob", + "sha": "eaf614c81d6daa7209940965d9a3cb57a0854d90", + "size": 5593, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/eaf614c81d6daa7209940965d9a3cb57a0854d90" + }, + { + "path": "scripts/nonadjacent.py", + "mode": "100644", + "type": "blob", + "sha": "480ecab1456af9293e523f31cabaddcf309ada75", + "size": 4977, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/480ecab1456af9293e523f31cabaddcf309ada75" + }, + { + "path": "scripts/paired_complex.py", + "mode": "100644", + "type": "blob", + "sha": "6cf178467941db8f88b0b0d473824d2a2301ad25", + "size": 825, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6cf178467941db8f88b0b0d473824d2a2301ad25" + }, + { + "path": "scripts/paired_exclusion_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "size": 2289, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/36d1fa2c0235b9b307243a8735e38a3fbf957113" + }, + { + "path": "scripts/paired_network.py", + "mode": "100644", + "type": "blob", + "sha": "910449dd510c89ca24aa56904d225b86abfb3be7", + "size": 4933, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/910449dd510c89ca24aa56904d225b86abfb3be7" + }, + { + "path": "scripts/paired_triple_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "6b10e490b7601c212df889affe06736925f15281", + "size": 5625, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6b10e490b7601c212df889affe06736925f15281" + }, + { + "path": "scripts/partial_swap", + "mode": "040000", + "type": "tree", + "sha": "cfef354523986174e8e1467fb7f71bd48384a2cd", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cfef354523986174e8e1467fb7f71bd48384a2cd" + }, + { + "path": "scripts/partial_swap/README.md", + "mode": "100644", + "type": "blob", + "sha": "3e753db831c6df9bdfb8885042f2aa464ce0d356", + "size": 2584, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3e753db831c6df9bdfb8885042f2aa464ce0d356" + }, + { + "path": "scripts/partial_swap/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "ba99c12519d14b27975fb49fc713d9f109b6535c", + "size": 281, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ba99c12519d14b27975fb49fc713d9f109b6535c" + }, + { + "path": "scripts/partial_swap/binary.py", + "mode": "100644", + "type": "blob", + "sha": "69a398e9afe3b3118f30996aba36e0b733f2f5f7", + "size": 1010, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/69a398e9afe3b3118f30996aba36e0b733f2f5f7" + }, + { + "path": "scripts/partial_swap/binary_io.hpp", + "mode": "100644", + "type": "blob", + "sha": "4058f0f06ef0665d8ac97868298881210482b514", + "size": 1791, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4058f0f06ef0665d8ac97868298881210482b514" + }, + { + "path": "scripts/partial_swap/graph.py", + "mode": "100644", + "type": "blob", + "sha": "ded4462b9f1767a3bc85256ffff8a71855339afe", + "size": 1826, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ded4462b9f1767a3bc85256ffff8a71855339afe" + }, + { + "path": "scripts/partial_swap/match_exported_dag.cpp", + "mode": "100644", + "type": "blob", + "sha": "ea1244ad446169b6b129910de31696d79d2e135f", + "size": 4422, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ea1244ad446169b6b129910de31696d79d2e135f" + }, + { + "path": "scripts/partial_swap/match_positive_dag.cpp", + "mode": "100644", + "type": "blob", + "sha": "af5a6fb432f59318bb9ec08bc2817e68337a48d9", + "size": 4746, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/af5a6fb432f59318bb9ec08bc2817e68337a48d9" + }, + { + "path": "scripts/partial_swap/paired.py", + "mode": "100644", + "type": "blob", + "sha": "b879293977c4705fdc47905cd6c58906161da3e7", + "size": 2608, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b879293977c4705fdc47905cd6c58906161da3e7" + }, + { + "path": "scripts/partial_swap/positive.py", + "mode": "100644", + "type": "blob", + "sha": "5d038b4250a3ee7a04a00573ef666a720cb39cd1", + "size": 4198, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5d038b4250a3ee7a04a00573ef666a720cb39cd1" + }, + { + "path": "scripts/partial_swap/shared.py", + "mode": "100644", + "type": "blob", + "sha": "a2f0190704db83bd8ef48e46e723c49b925804fe", + "size": 8442, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a2f0190704db83bd8ef48e46e723c49b925804fe" + }, + { + "path": "scripts/partial_swap_network.py", + "mode": "100644", + "type": "blob", + "sha": "2e8a834886362b576ad8cff96a639e6e41a00af7", + "size": 10822, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/2e8a834886362b576ad8cff96a639e6e41a00af7" + }, + { + "path": "scripts/partial_swap_producer.py", + "mode": "100644", + "type": "blob", + "sha": "9a450f15fba11c2ad49df346a3e0d3cdb25b1f5e", + "size": 6952, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9a450f15fba11c2ad49df346a3e0d3cdb25b1f5e" + }, + { + "path": "scripts/prepare_layers.py", + "mode": "100644", + "type": "blob", + "sha": "8e17b52f9573135426d7ba6865c8c9bc8da8639a", + "size": 8196, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8e17b52f9573135426d7ba6865c8c9bc8da8639a" + }, + { + "path": "scripts/prime_field_checks.py", + "mode": "100644", + "type": "blob", + "sha": "ac49d44df47e2ac1f6b12a43bcc7d39fffbe6888", + "size": 11244, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ac49d44df47e2ac1f6b12a43bcc7d39fffbe6888" + }, + { + "path": "scripts/prime_field_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "e46911168c06523ded1943a7f026eccfbf2f68ff", + "size": 6255, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e46911168c06523ded1943a7f026eccfbf2f68ff" + }, + { + "path": "scripts/prime_field_network.py", + "mode": "100644", + "type": "blob", + "sha": "3492b2ecb252ba37e704e6263231d415fa9a75e9", + "size": 5605, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3492b2ecb252ba37e704e6263231d415fa9a75e9" + }, + { + "path": "scripts/prime_field_supports.cpp", + "mode": "100644", + "type": "blob", + "sha": "456fd2bf4f836d725b187494f8263de8d9e0b447", + "size": 7331, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/456fd2bf4f836d725b187494f8263de8d9e0b447" + }, + { + "path": "scripts/rank_obstructions.py", + "mode": "100644", + "type": "blob", + "sha": "b913f7c136ce0d955e7ecb731386b7bc9e7e1edb", + "size": 5830, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b913f7c136ce0d955e7ecb731386b7bc9e7e1edb" + }, + { + "path": "scripts/rational_span_frames.py", + "mode": "100644", + "type": "blob", + "sha": "bef0286625989005baf3b5831bc77b1292e18f3f", + "size": 5938, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bef0286625989005baf3b5831bc77b1292e18f3f" + }, + { + "path": "scripts/rational_tensor.py", + "mode": "100644", + "type": "blob", + "sha": "383bad4ac7546877717fce402fbb3650f8cfd796", + "size": 162, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/383bad4ac7546877717fce402fbb3650f8cfd796" + }, + { + "path": "scripts/research_networks.py", + "mode": "100644", + "type": "blob", + "sha": "e8369a4176904e5768f3a4ca645c6ffc3ef49acf", + "size": 4561, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e8369a4176904e5768f3a4ca645c6ffc3ef49acf" + }, + { + "path": "scripts/reuse_network.py", + "mode": "100644", + "type": "blob", + "sha": "50e810a40f9edcb1ddc673e7df56c9bf995838ac", + "size": 7301, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/50e810a40f9edcb1ddc673e7df56c9bf995838ac" + }, + { + "path": "scripts/routing_smt.py", + "mode": "100644", + "type": "blob", + "sha": "21cf37b4a2c6df6cd05b6c3cde5f6ec2b40f113c", + "size": 3287, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/21cf37b4a2c6df6cd05b6c3cde5f6ec2b40f113c" + }, + { + "path": "scripts/run_isolated_tests.py", + "mode": "100644", + "type": "blob", + "sha": "bb4ecc7cd3b2af051175aab1ce9d0440e5cacbf7", + "size": 1013, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bb4ecc7cd3b2af051175aab1ce9d0440e5cacbf7" + }, + { + "path": "scripts/search_incidence_partitions.py", + "mode": "100644", + "type": "blob", + "sha": "b2e5c8bb6f5028e5a35ced203d3f4196afd6bcad", + "size": 3423, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b2e5c8bb6f5028e5a35ced203d3f4196afd6bcad" + }, + { + "path": "scripts/search_network.py", + "mode": "100644", + "type": "blob", + "sha": "f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b", + "size": 4314, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b" + }, + { + "path": "scripts/search_network_variants.py", + "mode": "100644", + "type": "blob", + "sha": "52e59accb980312be48e9d6274473ba7c3145382", + "size": 4987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/52e59accb980312be48e9d6274473ba7c3145382" + }, + { + "path": "scripts/shared_point_circuit.py", + "mode": "100644", + "type": "blob", + "sha": "8347a0bda63fbfb51b86c6c6d10a7bf541816308", + "size": 7447, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8347a0bda63fbfb51b86c6c6d10a7bf541816308" + }, + { + "path": "scripts/shared_point_network.py", + "mode": "100644", + "type": "blob", + "sha": "0ec7e75046fe714968c49178cd7f83e80e9f9d94", + "size": 3119, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0ec7e75046fe714968c49178cd7f83e80e9f9d94" + }, + { + "path": "scripts/small_block_witness.py", + "mode": "100644", + "type": "blob", + "sha": "74f23897e6d64a08209a76fb415711c9067cd013", + "size": 2437, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74f23897e6d64a08209a76fb415711c9067cd013" + }, + { + "path": "scripts/stopped_product", + "mode": "040000", + "type": "tree", + "sha": "c12c21e1fe1cecbc4d3cff5ad8dd515133d21830", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/c12c21e1fe1cecbc4d3cff5ad8dd515133d21830" + }, + { + "path": "scripts/stopped_product/README.md", + "mode": "100644", + "type": "blob", + "sha": "6c18be051fd266f33a3acfa0a7fde0bf534d4d6f", + "size": 1887, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c18be051fd266f33a3acfa0a7fde0bf534d4d6f" + }, + { + "path": "scripts/stopped_product/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "f7a6e9066153e374017a03fc1a6c6f01d1655b5b", + "size": 78, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f7a6e9066153e374017a03fc1a6c6f01d1655b5b" + }, + { + "path": "scripts/stopped_product/complex.py", + "mode": "100644", + "type": "blob", + "sha": "ef1af2550763335e60b8427ba11fccd30025d507", + "size": 10913, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ef1af2550763335e60b8427ba11fccd30025d507" + }, + { + "path": "scripts/stopped_product_network.py", + "mode": "100644", + "type": "blob", + "sha": "5f349a2676419e1002b0d41564d8cf51dd2f1f75", + "size": 7981, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5f349a2676419e1002b0d41564d8cf51dd2f1f75" + }, + { + "path": "scripts/stopped_product_producer.py", + "mode": "100644", + "type": "blob", + "sha": "aefc91d9a773b42c59a807fce323fbfbcf471c62", + "size": 4201, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aefc91d9a773b42c59a807fce323fbfbcf471c62" + }, + { + "path": "scripts/structured_bulk", + "mode": "040000", + "type": "tree", + "sha": "76b31d0cc30bf9b52bdf2767527013348a935080", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/76b31d0cc30bf9b52bdf2767527013348a935080" + }, + { + "path": "scripts/structured_bulk/README.md", + "mode": "100644", + "type": "blob", + "sha": "81eaf6aea30eb0d0b56b1b82ab008c984714afac", + "size": 3325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/81eaf6aea30eb0d0b56b1b82ab008c984714afac" + }, + { + "path": "scripts/structured_bulk/__init__.py", + "mode": "100644", + "type": "blob", + "sha": "423fb75fd37fd52482a60c99589c4e4d7d815a27", + "size": 75, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/423fb75fd37fd52482a60c99589c4e4d7d815a27" + }, + { + "path": "scripts/structured_bulk/complex.py", + "mode": "100644", + "type": "blob", + "sha": "f1e27c6a100c6a8f974f77c4029c92218c9fce9f", + "size": 9987, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f1e27c6a100c6a8f974f77c4029c92218c9fce9f" + }, + { + "path": "scripts/structured_bulk/exactness.py", + "mode": "100644", + "type": "blob", + "sha": "5df0772efe8419b24db18e7dae3c874ed6140658", + "size": 2984, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5df0772efe8419b24db18e7dae3c874ed6140658" + }, + { + "path": "scripts/structured_bulk/rankone_profiles.cpp", + "mode": "100644", + "type": "blob", + "sha": "5c609775faa3f7c65a4069b9fad66673110d853f", + "size": 10099, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5c609775faa3f7c65a4069b9fad66673110d853f" + }, + { + "path": "scripts/structured_bulk_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "b76f9cb5a452fb637f3a8aec0748da6d2d81968a", + "size": 5249, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b76f9cb5a452fb637f3a8aec0748da6d2d81968a" + }, + { + "path": "scripts/structured_bulk_network.py", + "mode": "100644", + "type": "blob", + "sha": "32cb7d3b730675e52916de1b6be15e7899ef2279", + "size": 8742, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/32cb7d3b730675e52916de1b6be15e7899ef2279" + }, + { + "path": "scripts/structured_bulk_producer.py", + "mode": "100644", + "type": "blob", + "sha": "5bda9ddd6e04786b6b08acaf12d5b0f59a328e64", + "size": 7153, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5bda9ddd6e04786b6b08acaf12d5b0f59a328e64" + }, + { + "path": "scripts/ternary_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "0e523bd10cf689cfaec40c28a123ffea9b5dca4b", + "size": 2575, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0e523bd10cf689cfaec40c28a123ffea9b5dca4b" + }, + { + "path": "scripts/tune_routing.py", + "mode": "100644", + "type": "blob", + "sha": "d549bbc6fded9d39d5cbc8755f71ab7b11a2125e", + "size": 4777, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d549bbc6fded9d39d5cbc8755f71ab7b11a2125e" + }, + { + "path": "tests", + "mode": "040000", + "type": "tree", + "sha": "3b2d5d7ea806b73c02d0df94c1d4ab1d0a45dda4", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/3b2d5d7ea806b73c02d0df94c1d4ab1d0a45dda4" + }, + { + "path": "tests/test_additive_labels.py", + "mode": "100644", + "type": "blob", + "sha": "59914c56e6b109bc660250e9e4e54dcdbec3ba6b", + "size": 2709, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/59914c56e6b109bc660250e9e4e54dcdbec3ba6b" + }, + { + "path": "tests/test_affine_vector_screens.py", + "mode": "100644", + "type": "blob", + "sha": "e86139142b74fd33b1a20040f4ad36140d4700e0", + "size": 1850, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e86139142b74fd33b1a20040f4ad36140d4700e0" + }, + { + "path": "tests/test_batched_network.py", + "mode": "100644", + "type": "blob", + "sha": "fb9ac3d98d9c4ba689d0d18770761b4533b9b8b2", + "size": 3106, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fb9ac3d98d9c4ba689d0d18770761b4533b9b8b2" + }, + { + "path": "tests/test_bit_compression.py", + "mode": "100644", + "type": "blob", + "sha": "a021dbf98d06b794e16538bf8c0c6536903086c7", + "size": 6238, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a021dbf98d06b794e16538bf8c0c6536903086c7" + }, + { + "path": "tests/test_block_carry.py", + "mode": "100644", + "type": "blob", + "sha": "fc57c67c857357dccf3b7ce4200366724274759d", + "size": 4376, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/fc57c67c857357dccf3b7ce4200366724274759d" + }, + { + "path": "tests/test_block_core.py", + "mode": "100644", + "type": "blob", + "sha": "decf262010fdfe973fb9c88d201647b02c665fd9", + "size": 2728, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/decf262010fdfe973fb9c88d201647b02c665fd9" + }, + { + "path": "tests/test_block_label_audit.py", + "mode": "100644", + "type": "blob", + "sha": "db23a2935e243db9f26fd6920beaf73ef2421af4", + "size": 2641, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/db23a2935e243db9f26fd6920beaf73ef2421af4" + }, + { + "path": "tests/test_cancellation.py", + "mode": "100644", + "type": "blob", + "sha": "10b7a1d245a5208113d00fa86737d178f9ab5f93", + "size": 6055, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/10b7a1d245a5208113d00fa86737d178f9ab5f93" + }, + { + "path": "tests/test_certificates.py", + "mode": "100644", + "type": "blob", + "sha": "29c16974b1236fb3b29c2e5108b56745e77a2927", + "size": 8178, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/29c16974b1236fb3b29c2e5108b56745e77a2927" + }, + { + "path": "tests/test_climbed_48.py", + "mode": "100644", + "type": "blob", + "sha": "a8fe682012098219de9903378b7e932fbb9a2d7c", + "size": 2285, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a8fe682012098219de9903378b7e932fbb9a2d7c" + }, + { + "path": "tests/test_coded_carries.py", + "mode": "100644", + "type": "blob", + "sha": "a3dac28b7ad97c9ebfd95ff28018b0029565de26", + "size": 5436, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a3dac28b7ad97c9ebfd95ff28018b0029565de26" + }, + { + "path": "tests/test_compact_control_layer.py", + "mode": "100644", + "type": "blob", + "sha": "bca34c9e796ce5483f99ae1bf31acc6b74d32d8c", + "size": 6158, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bca34c9e796ce5483f99ae1bf31acc6b74d32d8c" + }, + { + "path": "tests/test_compact_control_patch.py", + "mode": "100644", + "type": "blob", + "sha": "17c3fc612a43d31724477e7855f65de0932e2430", + "size": 3325, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/17c3fc612a43d31724477e7855f65de0932e2430" + }, + { + "path": "tests/test_compact_controls.py", + "mode": "100644", + "type": "blob", + "sha": "31f7ef3e143889651d5e983a6c5f11f3cba6eb4a", + "size": 2870, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/31f7ef3e143889651d5e983a6c5f11f3cba6eb4a" + }, + { + "path": "tests/test_complex_centers.py", + "mode": "100644", + "type": "blob", + "sha": "d0ab57a3650788bd7a5fef92c339794d2c5fa1b3", + "size": 2242, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d0ab57a3650788bd7a5fef92c339794d2c5fa1b3" + }, + { + "path": "tests/test_complex_compression.py", + "mode": "100644", + "type": "blob", + "sha": "6ca63fe751559a2418dd261bf5b24fe8486ac1b6", + "size": 6554, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6ca63fe751559a2418dd261bf5b24fe8486ac1b6" + }, + { + "path": "tests/test_complex_compression_patch.py", + "mode": "100644", + "type": "blob", + "sha": "443619f279505fcec4639ba4d509c3d79f12d003", + "size": 4067, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/443619f279505fcec4639ba4d509c3d79f12d003" + }, + { + "path": "tests/test_copied_fixed.py", + "mode": "100644", + "type": "blob", + "sha": "0c0a339f137f96834221b43b821cda1acca49587", + "size": 6726, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0c0a339f137f96834221b43b821cda1acca49587" + }, + { + "path": "tests/test_copied_fixed_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "c4dddd7880991bfaaaabdf0e78f57b888fa16ebd", + "size": 3795, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c4dddd7880991bfaaaabdf0e78f57b888fa16ebd" + }, + { + "path": "tests/test_copied_reversed.py", + "mode": "100644", + "type": "blob", + "sha": "70a02eb58b595a0551875727aaca65d291978e56", + "size": 4347, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/70a02eb58b595a0551875727aaca65d291978e56" + }, + { + "path": "tests/test_core_limits.py", + "mode": "100644", + "type": "blob", + "sha": "a219f0bdb9248a6303e474115c1901823486a1fb", + "size": 2833, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a219f0bdb9248a6303e474115c1901823486a1fb" + }, + { + "path": "tests/test_cpp_headers.py", + "mode": "100644", + "type": "blob", + "sha": "16a65fe1d58bbc7484eca309e42865c310cfdd1e", + "size": 1005, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/16a65fe1d58bbc7484eca309e42865c310cfdd1e" + }, + { + "path": "tests/test_cube_core_family.py", + "mode": "100644", + "type": "blob", + "sha": "f26644f70008e927aa3f880907e469c3f04ce418", + "size": 3622, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f26644f70008e927aa3f880907e469c3f04ce418" + }, + { + "path": "tests/test_dag_network.py", + "mode": "100644", + "type": "blob", + "sha": "955ffac31e13c70595366150071b591364cba4ba", + "size": 3731, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/955ffac31e13c70595366150071b591364cba4ba" + }, + { + "path": "tests/test_disjoint_tensor.py", + "mode": "100644", + "type": "blob", + "sha": "da186f79627b0e64af77b9919681c749c8115344", + "size": 2789, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/da186f79627b0e64af77b9919681c749c8115344" + }, + { + "path": "tests/test_early_sharing_and_centers.py", + "mode": "100644", + "type": "blob", + "sha": "3ffc8a0cc74eec187c5381ef945fc99332dd6773", + "size": 4301, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3ffc8a0cc74eec187c5381ef945fc99332dd6773" + }, + { + "path": "tests/test_endpoint_gauge.py", + "mode": "100644", + "type": "blob", + "sha": "be8e2fbbc7615e07f5dd8d4e829f024b1415b0f0", + "size": 2115, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/be8e2fbbc7615e07f5dd8d4e829f024b1415b0f0" + }, + { + "path": "tests/test_fano_completion.py", + "mode": "100644", + "type": "blob", + "sha": "09829ffdc7b541fbae1a190e0c3af45e45b59524", + "size": 5622, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/09829ffdc7b541fbae1a190e0c3af45e45b59524" + }, + { + "path": "tests/test_fano_permutation.py", + "mode": "100644", + "type": "blob", + "sha": "f5940b59181b592c57b28420b4ccd355e7033418", + "size": 4173, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f5940b59181b592c57b28420b4ccd355e7033418" + }, + { + "path": "tests/test_finite_bit_contract.py", + "mode": "100644", + "type": "blob", + "sha": "d26ed2e1eb74332927887fe1423f00feff14b769", + "size": 5763, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d26ed2e1eb74332927887fe1423f00feff14b769" + }, + { + "path": "tests/test_finite_identities.py", + "mode": "100644", + "type": "blob", + "sha": "4baeae0cb246645be03a47b19cc4b3f558e7dda9", + "size": 5405, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4baeae0cb246645be03a47b19cc4b3f558e7dda9" + }, + { + "path": "tests/test_fused_block.py", + "mode": "100644", + "type": "blob", + "sha": "b47ca446e436f416ed5f7ca02917d2f7829088d4", + "size": 3685, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b47ca446e436f416ed5f7ca02917d2f7829088d4" + }, + { + "path": "tests/test_gather_schedules.py", + "mode": "100644", + "type": "blob", + "sha": "f6a9b2d3fa382a83465fe0ea99e1a646d5b0e2a3", + "size": 6563, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f6a9b2d3fa382a83465fe0ea99e1a646d5b0e2a3" + }, + { + "path": "tests/test_general_network_guard.py", + "mode": "100644", + "type": "blob", + "sha": "8855789ad37ad9b7e263de56d8238b8a6474bf19", + "size": 3604, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8855789ad37ad9b7e263de56d8238b8a6474bf19" + }, + { + "path": "tests/test_incidence_network.py", + "mode": "100644", + "type": "blob", + "sha": "7d5251306d8938568533776185d499c9d94f020a", + "size": 4471, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7d5251306d8938568533776185d499c9d94f020a" + }, + { + "path": "tests/test_inplace_side.py", + "mode": "100644", + "type": "blob", + "sha": "3803313fe37acba2906ba6923d75bc1359ac8d56", + "size": 3584, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/3803313fe37acba2906ba6923d75bc1359ac8d56" + }, + { + "path": "tests/test_joint_frames.py", + "mode": "100644", + "type": "blob", + "sha": "e5b42cd94e0234a2925cd143f2b760c4ea1b4b0e", + "size": 4363, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e5b42cd94e0234a2925cd143f2b760c4ea1b4b0e" + }, + { + "path": "tests/test_joint_reclaim.py", + "mode": "100644", + "type": "blob", + "sha": "8be9738ee398d258ed3e7ab92f1709e93c8ad537", + "size": 4333, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/8be9738ee398d258ed3e7ab92f1709e93c8ad537" + }, + { + "path": "tests/test_joint_return.py", + "mode": "100644", + "type": "blob", + "sha": "523205cf45f52230c3745251b33554e189a7c81d", + "size": 4682, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/523205cf45f52230c3745251b33554e189a7c81d" + }, + { + "path": "tests/test_layer_preparation.py", + "mode": "100644", + "type": "blob", + "sha": "ecd9850c02e948285346fefb1fcf4d5d0453f740", + "size": 6031, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ecd9850c02e948285346fefb1fcf4d5d0453f740" + }, + { + "path": "tests/test_lean_sources.py", + "mode": "100644", + "type": "blob", + "sha": "0eff4b875ed66c3708af9fed735e612f3134d656", + "size": 608, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0eff4b875ed66c3708af9fed735e612f3134d656" + }, + { + "path": "tests/test_mixed_point.py", + "mode": "100644", + "type": "blob", + "sha": "1d97e9f9bbcd4d61f618fc562a0e22b58af59ad5", + "size": 4718, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1d97e9f9bbcd4d61f618fc562a0e22b58af59ad5" + }, + { + "path": "tests/test_network_research.py", + "mode": "100644", + "type": "blob", + "sha": "583b17ed035b799a85c595a5147fdd2c899b8f5c", + "size": 3017, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/583b17ed035b799a85c595a5147fdd2c899b8f5c" + }, + { + "path": "tests/test_network_search.py", + "mode": "100644", + "type": "blob", + "sha": "c1368f68def6daa03ab29911546c092ac1bf33c2", + "size": 1476, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c1368f68def6daa03ab29911546c092ac1bf33c2" + }, + { + "path": "tests/test_network_variants.py", + "mode": "100644", + "type": "blob", + "sha": "5962eb38f7371fad358b08928e26d6605e5ed956", + "size": 2802, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5962eb38f7371fad358b08928e26d6605e5ed956" + }, + { + "path": "tests/test_nonadjacent.py", + "mode": "100644", + "type": "blob", + "sha": "a4c708756a175c5a7c59f47f84ee12b3c5e01ee1", + "size": 12658, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a4c708756a175c5a7c59f47f84ee12b3c5e01ee1" + }, + { + "path": "tests/test_open_pr_lean.py", + "mode": "100644", + "type": "blob", + "sha": "c02527e19a97bd649b1747c7adc31b8decbf183a", + "size": 1389, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c02527e19a97bd649b1747c7adc31b8decbf183a" + }, + { + "path": "tests/test_packed_audit.py", + "mode": "100644", + "type": "blob", + "sha": "74850db1a5041e059cb1f189bed6013b091d2e8c", + "size": 1683, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/74850db1a5041e059cb1f189bed6013b091d2e8c" + }, + { + "path": "tests/test_pair_assembly.py", + "mode": "100644", + "type": "blob", + "sha": "bab152be15699c618aa17202d15f60966782784c", + "size": 10368, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bab152be15699c618aa17202d15f60966782784c" + }, + { + "path": "tests/test_paired_circuit_check.py", + "mode": "100644", + "type": "blob", + "sha": "cf54d7486dc0c225755bc7645045d3b77a8e98b0", + "size": 1811, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cf54d7486dc0c225755bc7645045d3b77a8e98b0" + }, + { + "path": "tests/test_paired_network.py", + "mode": "100644", + "type": "blob", + "sha": "555205a695e19e2b63114a7b244519172df4a4f3", + "size": 5714, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/555205a695e19e2b63114a7b244519172df4a4f3" + }, + { + "path": "tests/test_parity_side.py", + "mode": "100644", + "type": "blob", + "sha": "51312c21e92adff87cc30d3f057fdf1911ccae0e", + "size": 1720, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/51312c21e92adff87cc30d3f057fdf1911ccae0e" + }, + { + "path": "tests/test_partial_swap.py", + "mode": "100644", + "type": "blob", + "sha": "704b60f13b7c46d734105f778a76645f5581fccf", + "size": 1705, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/704b60f13b7c46d734105f778a76645f5581fccf" + }, + { + "path": "tests/test_positive_side_core.py", + "mode": "100644", + "type": "blob", + "sha": "643a3020b9b6dbdf2230be7b9bb6c5a3ce2e637d", + "size": 2346, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/643a3020b9b6dbdf2230be7b9bb6c5a3ce2e637d" + }, + { + "path": "tests/test_positive_skip.py", + "mode": "100644", + "type": "blob", + "sha": "0d67920014d8304fadb8e47a2227d39dddeb38b3", + "size": 1613, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0d67920014d8304fadb8e47a2227d39dddeb38b3" + }, + { + "path": "tests/test_prime_core.py", + "mode": "100644", + "type": "blob", + "sha": "427c6bb4d35084fba74f7a7e12be069b0605df7f", + "size": 1936, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/427c6bb4d35084fba74f7a7e12be069b0605df7f" + }, + { + "path": "tests/test_prime_subset_limits.py", + "mode": "100644", + "type": "blob", + "sha": "f9a28c425a8483fb3445c13e72f8074471eef9c8", + "size": 1463, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f9a28c425a8483fb3445c13e72f8074471eef9c8" + }, + { + "path": "tests/test_quadratic_affine.py", + "mode": "100644", + "type": "blob", + "sha": "c69a8e84378e5384cf4f5afee057f4e375f0d15a", + "size": 2407, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c69a8e84378e5384cf4f5afee057f4e375f0d15a" + }, + { + "path": "tests/test_rank_product_core.py", + "mode": "100644", + "type": "blob", + "sha": "d81d43afc2adc9148d1ee57f81de34963bfecfc2", + "size": 6192, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d81d43afc2adc9148d1ee57f81de34963bfecfc2" + }, + { + "path": "tests/test_reuse_network.py", + "mode": "100644", + "type": "blob", + "sha": "1b67777f7d0c27fcdb3b822626dc63e57c0b371b", + "size": 4187, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/1b67777f7d0c27fcdb3b822626dc63e57c0b371b" + }, + { + "path": "tests/test_scratch_pooling.py", + "mode": "100644", + "type": "blob", + "sha": "08191369bce94f3bc965f36c92bf7c839775cb82", + "size": 1021, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/08191369bce94f3bc965f36c92bf7c839775cb82" + }, + { + "path": "tests/test_shared_core.py", + "mode": "100644", + "type": "blob", + "sha": "02463b326f2a5676c913191ef26fe7015f4af1e8", + "size": 2769, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/02463b326f2a5676c913191ef26fe7015f4af1e8" + }, + { + "path": "tests/test_shared_point_network.py", + "mode": "100644", + "type": "blob", + "sha": "bbf18de66f35c36c91701ff1975cdc1c7aacdcee", + "size": 3753, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bbf18de66f35c36c91701ff1975cdc1c7aacdcee" + }, + { + "path": "tests/test_short_guards.py", + "mode": "100644", + "type": "blob", + "sha": "ed24659bbb52ea0fc943bfb99eac16295b7738b6", + "size": 6080, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ed24659bbb52ea0fc943bfb99eac16295b7738b6" + }, + { + "path": "tests/test_signed_sparse_core.py", + "mode": "100644", + "type": "blob", + "sha": "ad44605f0f4ff9838fbee3223ed0518a1e1970aa", + "size": 3177, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ad44605f0f4ff9838fbee3223ed0518a1e1970aa" + }, + { + "path": "tests/test_single_intersection.py", + "mode": "100644", + "type": "blob", + "sha": "abe80a2642d94adff3df06ec3059730b598c74dd", + "size": 4145, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/abe80a2642d94adff3df06ec3059730b598c74dd" + }, + { + "path": "tests/test_skip_clones.py", + "mode": "100644", + "type": "blob", + "sha": "7c76dfbc00a08563348ae1f699685f0cce38279b", + "size": 11172, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7c76dfbc00a08563348ae1f699685f0cce38279b" + }, + { + "path": "tests/test_skip_strips.py", + "mode": "100644", + "type": "blob", + "sha": "36b8d1f49696ce5258bc00dccb9e00e75218495c", + "size": 8615, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/36b8d1f49696ce5258bc00dccb9e00e75218495c" + }, + { + "path": "tests/test_skip_suffix.py", + "mode": "100644", + "type": "blob", + "sha": "0295d3440742cd63c3313deeeb61b12fc3affb22", + "size": 8639, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0295d3440742cd63c3313deeeb61b12fc3affb22" + }, + { + "path": "tests/test_small_block_witness.py", + "mode": "100644", + "type": "blob", + "sha": "c071bfa364b0978f9e31174ed2ad2b80586dbecc", + "size": 1608, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c071bfa364b0978f9e31174ed2ad2b80586dbecc" + }, + { + "path": "tests/test_sparse_fusion.py", + "mode": "100644", + "type": "blob", + "sha": "6c0fa720b4c67db5cee64dba962ec920ea21852c", + "size": 4083, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/6c0fa720b4c67db5cee64dba962ec920ea21852c" + }, + { + "path": "tests/test_split_skip.py", + "mode": "100644", + "type": "blob", + "sha": "d7a7f087373b2791122fd90987f68e5183fb131b", + "size": 4196, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/d7a7f087373b2791122fd90987f68e5183fb131b" + }, + { + "path": "tests/test_stage_pair.py", + "mode": "100644", + "type": "blob", + "sha": "a0a87523fa099b1fdb83a490706ca99da1e0d2f6", + "size": 4724, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a0a87523fa099b1fdb83a490706ca99da1e0d2f6" + }, + { + "path": "tests/test_stronger_screens.py", + "mode": "100644", + "type": "blob", + "sha": "9c2323bc7817183032b39663bb93805db19cf66a", + "size": 5429, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/9c2323bc7817183032b39663bb93805db19cf66a" + }, + { + "path": "tests/test_subset_core_family.py", + "mode": "100644", + "type": "blob", + "sha": "b94d98d43352d6f13805a6f9adcaabaa9e3e08ce", + "size": 5402, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/b94d98d43352d6f13805a6f9adcaabaa9e3e08ce" + }, + { + "path": "tests/test_ternary_patch.py", + "mode": "100644", + "type": "blob", + "sha": "a96c6190728dfc79c94c6f3ff3d86167bf202ee3", + "size": 2548, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a96c6190728dfc79c94c6f3ff3d86167bf202ee3" + }, + { + "path": "tests/test_ternary_side.py", + "mode": "100644", + "type": "blob", + "sha": "402967c381c1861e8ad9cf50bd7897d4fc16d55a", + "size": 2117, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/402967c381c1861e8ad9cf50bd7897d4fc16d55a" + }, + { + "path": "tests/test_tune_routing.py", + "mode": "100644", + "type": "blob", + "sha": "ea395d183cc68effb927238cf19b82cc7577e786", + "size": 3250, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/ea395d183cc68effb927238cf19b82cc7577e786" + }, + { + "path": "upstream", + "mode": "040000", + "type": "tree", + "sha": "e44d39621b58e2b351f9107b9fa170d6a8d4fe1c", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/e44d39621b58e2b351f9107b9fa170d6a8d4fe1c" + }, + { + "path": "upstream/LICENSE", + "mode": "100644", + "type": "blob", + "sha": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "size": 11357, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + { + "path": "upstream/README.md", + "mode": "100644", + "type": "blob", + "sha": "c8cb3c3857907bf3465017b9f7ef1add4df5c29b", + "size": 541, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/c8cb3c3857907bf3465017b9f7ef1add4df5c29b" + }, + { + "path": "upstream/build", + "mode": "040000", + "type": "tree", + "sha": "cc25c0c731b3a003d1ff8af9debac9dd0fec6094", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/cc25c0c731b3a003d1ff8af9debac9dd0fec6094" + }, + { + "path": "upstream/build/figures", + "mode": "040000", + "type": "tree", + "sha": "09de2b75b0567bf3221323d174896bd130aeb5b8", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/09de2b75b0567bf3221323d174896bd130aeb5b8" + }, + { + "path": "upstream/build/figures/multiplication-flow.tex", + "mode": "100644", + "type": "blob", + "sha": "f0297c9cb841ad74a7cee4b541e302073d913236", + "size": 847, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/f0297c9cb841ad74a7cee4b541e302073d913236" + }, + { + "path": "upstream/build/figures/proof-map.tex", + "mode": "100644", + "type": "blob", + "sha": "a2d539e5a794eb8d679c6cad68c6b8d12b0fc880", + "size": 524, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/a2d539e5a794eb8d679c6cad68c6b8d12b0fc880" + }, + { + "path": "upstream/build/main.tex", + "mode": "100644", + "type": "blob", + "sha": "0b11a3feb14714253c1ca06ee561a31dd2fe8662", + "size": 1882, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/0b11a3feb14714253c1ca06ee561a31dd2fe8662" + }, + { + "path": "upstream/build/references.bib", + "mode": "100644", + "type": "blob", + "sha": "bf01cae12597f2777199c8ee74ee9f6933a1b56e", + "size": 9790, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/bf01cae12597f2777199c8ee74ee9f6933a1b56e" + }, + { + "path": "upstream/build/sections", + "mode": "040000", + "type": "tree", + "sha": "37037eaa9ee92cdaaf0f3c29b068668c8c747d72", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/trees/37037eaa9ee92cdaaf0f3c29b068668c8c747d72" + }, + { + "path": "upstream/build/sections/00-introduction.tex", + "mode": "100644", + "type": "blob", + "sha": "aa9048eef857c3e694989f5bb5020109e6422502", + "size": 11515, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/aa9048eef857c3e694989f5bb5020109e6422502" + }, + { + "path": "upstream/build/sections/01-history.tex", + "mode": "100644", + "type": "blob", + "sha": "7c6f033138f97315c80e64afb6cc446a1d590538", + "size": 9689, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/7c6f033138f97315c80e64afb6cc446a1d590538" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "mode": "100644", + "type": "blob", + "sha": "088fceea1867abc76271d7efe7532b779fee9039", + "size": 11311, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/088fceea1867abc76271d7efe7532b779fee9039" + }, + { + "path": "upstream/build/sections/03-motifs.tex", + "mode": "100644", + "type": "blob", + "sha": "cdb0ba527aa8df5d57c151183fd3893c1a7e21ab", + "size": 31874, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/cdb0ba527aa8df5d57c151183fd3893c1a7e21ab" + }, + { + "path": "upstream/build/sections/04-swap.tex", + "mode": "100644", + "type": "blob", + "sha": "951e792b1768e6509561380b8bbfb1d1ccb64c08", + "size": 19884, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/951e792b1768e6509561380b8bbfb1d1ccb64c08" + }, + { + "path": "upstream/build/sections/05-layers.tex", + "mode": "100644", + "type": "blob", + "sha": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "size": 46811, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/5ce8b3c83c455f221bb84858a97230b0285644aa" + }, + { + "path": "upstream/build/sections/06-transforms.tex", + "mode": "100644", + "type": "blob", + "sha": "de073e9292d58573f7065a3cd4f214e0d05f3444", + "size": 33854, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/de073e9292d58573f7065a3cd4f214e0d05f3444" + }, + { + "path": "upstream/build/sections/07-resampling.tex", + "mode": "100644", + "type": "blob", + "sha": "256243bf9416baefb82bf9203f80215b9ebe28f2", + "size": 22053, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/256243bf9416baefb82bf9203f80215b9ebe28f2" + }, + { + "path": "upstream/build/sections/08-assembly.tex", + "mode": "100644", + "type": "blob", + "sha": "337810a1d9a58a2ecf14123420923c039ba322a6", + "size": 46444, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/337810a1d9a58a2ecf14123420923c039ba322a6" + }, + { + "path": "upstream/build/sections/09-exact-arithmetic.tex", + "mode": "100644", + "type": "blob", + "sha": "4c7a1d63c912d081f70f5b166e9cab92d7774ee6", + "size": 6950, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/4c7a1d63c912d081f70f5b166e9cab92d7774ee6" + }, + { + "path": "upstream/build/sections/10-transposition.tex", + "mode": "100644", + "type": "blob", + "sha": "e69cc8276220edb8617a371ae9044a911fbc0767", + "size": 2398, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e69cc8276220edb8617a371ae9044a911fbc0767" + }, + { + "path": "upstream/build/sections/11-grouped-rectangles.tex", + "mode": "100644", + "type": "blob", + "sha": "44439c716c6290cd6e512ffac91253443b37d3ab", + "size": 7405, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/44439c716c6290cd6e512ffac91253443b37d3ab" + }, + { + "path": "upstream/formalization.yaml", + "mode": "100644", + "type": "blob", + "sha": "e0584d4993df01ec08233ab344ebc1b1039bf7f7", + "size": 73925, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/e0584d4993df01ec08233ab344ebc1b1039bf7f7" + }, + { + "path": "upstream/manifest.json", + "mode": "100644", + "type": "blob", + "sha": "01c309e34d36cf3669c43d89c5dfb25cdc31b8af", + "size": 6217, + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/git/blobs/01c309e34d36cf3669c43d89c5dfb25cdc31b8af" + } + ], + "truncated": false +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-dag.json.gz b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-dag.json.gz new file mode 100644 index 0000000000..a5b0598e4c Binary files /dev/null and b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-dag.json.gz differ diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-input.json b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-input.json new file mode 100644 index 0000000000..92f157e958 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-input.json @@ -0,0 +1,55 @@ +{ + "h": 24, + "v": 2024, + "c": 91770, + "q": 8120, + "baseline_R": 99890, + "matched": 71185, + "R": 28705, + "orientation_changes": 51863, + "rank_sum": 690024, + "loss": 552, + "histogram": [ + 16754, + 100041, + 67249, + 17471, + 10036, + 4698, + 2549, + 2766, + 7011, + 878, + 10867, + 2385, + 788, + 493, + 420, + 661, + 140, + 431, + 1365, + 1442, + 565, + 0, + 12, + 24, + 24 + ], + "central_disjoint": 24, + "center_denominator": 21, + "dag_sha256": "3c034d0aae388ef567a454826f4f48b26fd8a94c71e8ffed4835271b349a783b", + "scalar_validation": { + "ordinary_supports_exact": true, + "centers_exact": true, + "center_decoder": "sum A_i / 21", + "scatter_coefficients": [ + "1/21", + "-19/42" + ], + "rational_scalar_identity_exact": true, + "mixed_center_scatter_exact": true, + "binary_frames_nested": true, + "binary_frames_nondegenerate": true + } +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-word.json.gz b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-word.json.gz new file mode 100644 index 0000000000..6426bc17a9 Binary files /dev/null and b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-complex-word.json.gz differ diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-network.json b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-network.json new file mode 100644 index 0000000000..fcd087c9fa --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/certificates/deferred-product-network.json @@ -0,0 +1,478 @@ +{ + "a_complex": "26129/250000000", + "assembly": { + "absorption_gap": "622783629289782438948054313869/12502612894847906576432210511290000000000", + "margins": { + "Gaussian_arithmetic": "156777439829236650689342356778948871/1000209031587832526114576840903200000000", + "bulk_exposure": "26128948871/250000000000000", + "compact_phase_layer": "130644740435657695478948871/1250261289484790657643221051129", + "coordinate_movement": "26128948871/250000000000000", + "dimension": "1249999987500000000000000000000/1250261289484790657643221051129", + "original_prefix": "13065724304855254338552530321051129/125026128948479065764322105112900000000", + "scalar_work": "209040337571236629786183259978948871/1000209031587832526114576840903200000000" + }, + "minimum_margin": "130644740435657695478948871/1250261289484790657643221051129", + "parameters": { + "C0": 19612721086794747362548571317438973216103734289332153416817836032, + "C1": 1, + "a_bit": "26128948871/250000000000000", + "a_complex": "26129/250000000", + "actual_bit_saving": "1240189553/10000000000000", + "alpha_squared_power": "195973362613157669350000000/1250261289484790657643221051129", + "beta": "1/1000000", + "c": "130644743048552530321051129/1250000000000000000000000000000", + "delta": "1/800000000", + "epsilon": "1249999987500000000000000000000/1250261289484790657643221051129", + "eta": "1/100000000", + "kappa": "1044939/10000000000", + "lambda_": "24997387105139028948871/25000000000000000000000", + "lambda_prime": "12498693552582578948871/12500000000000000000000", + "q": "1306447417421051129/12500000000000000000000", + "sigma": "249973871/250000000", + "tau": "249973871051129/250000000000000" + }, + "recurrence": { + "internal": "249973871051129/250000000000000", + "leaf": "249973871026129/250000000000000", + "reservations": "1249869355256951447469678948871/1250000000000000000000000000000" + }, + "strict_constraints": { + "Gaussian_arithmetic_above_kappa": "1306542432585020937219459395582349513/25005225789695813152864421022580000000000", + "K_dominates_log": "13064474174210509983552582578948871/125026128948479065764322105112900000000", + "K_geometry": "13065724304855254338552530321051129/125026128948479065764322105112900000000", + "alpha_below_one": "1250065316122177499973871051129/1250261289484790657643221051129", + "alpha_below_one_fourth": "1249477396034338026965821051129/5001045157939162630572884204516", + "alpha_positive": "195973362613157669350000000/1250261289484790657643221051129", + "artificial_boundary": "7001724524350140919410920910485578948871/1000209031587832526114576840903200000000", + "beta_below_one": "999999/1000000", + "beta_positive": "1/1000000", + "bit_positive": "26128948871/250000000000000", + "bulk_exposure_above_kappa": "5473871/250000000000000", + "c_below_one": "1249869355256951447469678948871/1250000000000000000000000000000", + "c_positive": "130644743048552530321051129/1250000000000000000000000000000", + "cell_above_band": "1249934658877822500026128948871/2500522578969581315286442102258", + "compact_leaf": "1276128948871/12500000000000000000000", + "compact_phase_layer_above_kappa": "622783629289782438948054313869/12502612894847906576432210511290000000000", + "compact_reservations": "1306447417421051129/1250000000000000000000000000000", + "complex_above_bit": "51129/250000000000000", + "complex_below_one_over32": "7786371/250000000", + "coordinate_movement_above_kappa": "5473871/250000000000000", + "delta_below_one_eighth": "99999999/800000000", + "delta_positive": "1/800000000", + "dimension_above_kappa": "12498693428218427052334992950238054313869/12502612894847906576432210511290000000000", + "epsilon_below_one": "261301984790657643221051129/1250261289484790657643221051129", + "epsilon_positive": "1249999987500000000000000000000/1250261289484790657643221051129", + "gamma_sublinear": "65328622177499973871051129/1250261289484790657643221051129", + "guard_width": "261301984790657643221051129/1250261289484790657643221051129", + "lambda_above_internal": "26128948871/25000000000000000000000", + "lambda_above_sigma": "5139028948871/25000000000000000000000", + "lambda_above_tau": "26128948871/25000000000000000000000", + "lambda_prime_above_lambda": "26128948871/25000000000000000000000", + "lambda_prime_below_one": "1306447417421051129/12500000000000000000000", + "leaf_saving_above_bit": "1/10000000000", + "literal_scalar_guard": "1031457655662612293186769340668", + "original_prefix_above_kappa": "125648912577768848203270159426769/12502612894847906576432210511290000000000", + "phase_boundary": "156777439829236650689342356778948871/1000209031587832526114576840903200000000", + "phase_local": "209040337571236629786183259978948871/1000209031587832526114576840903200000000", + "prime_interval_packing": "261301984790657643221051129/1250261289484790657643221051129", + "q_below_internal": "26128948871/12500000000000000000000", + "q_below_leaf": "1276128948871/12500000000000000000000", + "q_below_reservations": "1306447417421051129/1250000000000000000000000000000", + "q_positive": "1306447417421051129/12500000000000000000000", + "record_suffix": "261301984790657643221051129/1250261289484790657643221051129", + "row_product_gap": "1676/5", + "scalar_work_above_kappa": "2613114876135020414640481975582349513/25005225789695813152864421022580000000000", + "short_record_fallback": "312467328861691661374974301811795299482174641/312565322371197664410805262782250000000000000", + "small_field_exposure": "130657244354999947742102258/1250261289484790657643221051129" + } + }, + "assembly_bit": "26128948871/250000000000000", + "binding": "complex", + "bit": { + "counts": { + "B1": 51121686, + "B2": 51121686, + "L": 1792252, + "N": 3136441, + "W": 108516254, + "child_multiplicities": { + "1": 239511811, + "10": 878416, + "11": 1388464, + "12": 1080310, + "13": 945714, + "14": 226688, + "15": 2451064, + "16": 1508892, + "17": 4771074, + "18": 2149994, + "19": 7367360, + "2": 238288050, + "20": 8182020, + "21": 1466388, + "22": 88550, + "3": 53377940, + "4": 46970462, + "484": 6272882, + "5": 23632224, + "506": 61280142, + "507": 545468, + "508": 173558, + "509": 293986, + "510": 580888, + "511": 14168, + "512": 322322, + "513": 17710, + "514": 1129898, + "515": 127512, + "516": 410872, + "517": 99176, + "518": 1186570, + "519": 340032, + "520": 322322, + "521": 106260, + "522": 1583274, + "523": 626934, + "524": 2854852, + "525": 13711082, + "526": 4629394, + "527": 5653032, + "528": 6233920, + "6": 7409864, + "7": 4105178, + "8": 5755750, + "9": 2082696 + }, + "deficit": 1344189, + "dimensions": [ + 23, + 23 + ], + "m": 529, + "maxchild": 528, + "roles": 28866, + "total_rank": 57403754177 + }, + "exponent": "4999379477/5000000000", + "logarithm_upper_bounds": { + "1": "1987355562417364065669439618237/316912650057057350374175801344", + "10": "2515274437229490418617839725263/633825300114114700748351602688", + "11": "4909728867822167960512763283247/1267650600228229401496703205376", + "12": "2399714421777289519579293961239/633825300114114700748351602688", + "13": "4697962657128327885574713503543/1267650600228229401496703205376", + "14": "1151004910436491358992364195459/316912650057057350374175801344", + "15": "2258280393397031167285649759463/633825300114114700748351602688", + "16": "2217374245868088984102352158015/633825300114114700748351602688", + "17": "4357897653501964928993364503311/1267650600228229401496703205376", + "18": "4285440755889660536494207989699/1267650600228229401496703205376", + "19": "1054225602598430741931079593279/316912650057057350374175801344", + "2": "3535376905093068344529747466859/633825300114114700748351602688", + "20": "4151880434975661263617415911297/1267650600228229401496703205376", + "21": "4090031554081046933305076849055/1267650600228229401496703205376", + "22": "4031060428338848386894499744017/1267650600228229401496703205376", + "3": "6556765722521218186395115000937/1267650600228229401496703205376", + "4": "6192085370702817115441231394489/1267650600228229401496703205376", + "484": "28174651752060127777810254067/316912650057057350374175801344", + "5": "1477304328485575102713485747439/316912650057057350374175801344", + "506": "28174651752060127777810254067/633825300114114700748351602688", + "507": "13461634359740358047256265827/316912650057057350374175801344", + "508": "51348702935746093527376467017/1267650600228229401496703205376", + "509": "24427890298974148366428397635/633825300114114700748351602688", + "510": "46367751143251427268642011075/1267650600228229401496703205376", + "511": "1371393606332916105007939035/39614081257132168796771975168", + "512": "20703147159790050056693309941/633825300114114700748351602688", + "513": "19466414474504369438193979723/633825300114114700748351602688", + "514": "36464180456598060831658809501/1267650600228229401496703205376", + "515": "8500082529457066293647807479/316912650057057350374175801344", + "516": "3942657414643595698964051979/158456325028528675187087900672", + "517": "7271737386783571020444791587/316912650057057350374175801344", + "518": "13318691203824549237528752541/633825300114114700748351602688", + "519": "24192539605019349297275627047/1267650600228229401496703205376", + "520": "21752402951213312896107403843/1267650600228229401496703205376", + "521": "19316954363029548999871947393/1267650600228229401496703205376", + "522": "16886175861292832110759445655/1267650600228229401496703205376", + "523": "3615012392514444337161355435/316912650057057350374175801344", + "524": "12038557715820072556759192101/1267650600228229401496703205376", + "525": "9621682626735229657445885033/1267650600228229401496703205376", + "526": "901175841480596175664643281/158456325028528675187087900672", + "527": "2400856280154877413264946061/633825300114114700748351602688", + "528": "2398582740651589757065655499/1267650600228229401496703205376", + "6": "1419524320759474653194212865427/316912650057057350374175801344", + "7": "2741344040614642504793860160533/633825300114114700748351602688", + "8": "5313416931219497541822967855259/1267650600228229401496703205376", + "9": "161378412355405628441014735279/39614081257132168796771975168" + }, + "moment_upper": "5136194762828378914240289797743017789/5136194762833176936965807109635571712", + "rank_moment": "1409269/1409302", + "rounding_denominator": 1267650600228229401496703205376, + "saving": "620523/5000000000", + "stopped_adapter": { + "atom_exponent": "1/1000", + "base_ordinary_saving": "384599/10000000000", + "coarse_toll_exponent": "999/1000", + "coarse_toll_subordinate_gap": "4379477/5000000000", + "effective_saving": "1240189553/10000000000000" + }, + "strict_gap": "4798022725517311892553923/5136194762833176936965807109635571712" + }, + "coarse_bit_saving": "620523/5000000000", + "complex": { + "child_width_multiplicities": [ + [ + 1, + 409159696 + ], + [ + 2, + 272223952 + ], + [ + 3, + 70722608 + ], + [ + 4, + 40625728 + ], + [ + 5, + 19017504 + ], + [ + 6, + 10318352 + ], + [ + 7, + 11196768 + ], + [ + 8, + 28380528 + ], + [ + 9, + 3554144 + ], + [ + 10, + 43989616 + ], + [ + 11, + 9654480 + ], + [ + 12, + 3189824 + ], + [ + 13, + 1995664 + ], + [ + 14, + 1700160 + ], + [ + 15, + 2675728 + ], + [ + 16, + 566720 + ], + [ + 17, + 1744688 + ], + [ + 18, + 5525520 + ], + [ + 19, + 5837216 + ], + [ + 20, + 2287120 + ], + [ + 22, + 48576 + ], + [ + 23, + 16483456 + ], + [ + 529, + 8193152 + ], + [ + 552, + 116197840 + ] + ], + "counts": { + "B1": 58098920, + "B2": 58098920, + "L": 2234496, + "N": 4096576, + "W": 124390992, + "child_multiplicities": { + "1": 409159696, + "10": 43989616, + "11": 9654480, + "12": 3189824, + "13": 1995664, + "14": 1700160, + "15": 2675728, + "16": 566720, + "17": 1744688, + "18": 5525520, + "19": 5837216, + "2": 272223952, + "20": 2287120, + "22": 48576, + "23": 16483456, + "3": 70722608, + "4": 40625728, + "5": 19017504, + "529": 8193152, + "552": 116197840, + "6": 10318352, + "7": 11196768, + "8": 28380528, + "9": 3554144 + }, + "copied_histogram": [ + 16754, + 100065, + 67249, + 17471, + 10036, + 4698, + 2549, + 2766, + 7011, + 878, + 10867, + 2385, + 788, + 493, + 420, + 661, + 140, + 431, + 1365, + 1442, + 565, + 0, + 12, + 24, + 0 + ], + "deficit": 1862080, + "dimensions": [ + 24, + 24 + ], + "m": 576, + "maxchild": 552, + "total_rank": 71647349312 + }, + "enclosure": "1+u+u^2/(2(1-u/3))", + "exponent": "249973871/250000000", + "logarithm_upper_bounds": { + "1": "794513457587/125000000000", + "10": "2026761283851/500000000000", + "11": "1979106193949/500000000000", + "12": "967800252727/250000000000", + "13": "758231660647/200000000000", + "14": "3717050331081/1000000000000", + "15": "1824028729797/500000000000", + "16": "3583518938457/1000000000000", + "17": "22018089479/6250000000", + "18": "8664339757/2500000000", + "19": "341166868153/100000000000", + "2": "707870060017/125000000000", + "20": "1680187693571/500000000000", + "22": "1632532603669/500000000000", + "23": "3220613444767/1000000000000", + "3": "1314373843007/250000000000", + "4": "4969813299577/1000000000000", + "5": "2373334874131/500000000000", + "529": "42559614419/500000000000", + "552": "42559614419/1000000000000", + "6": "1141087047867/250000000000", + "7": "4410197511641/1000000000000", + "8": "4276666119017/1000000000000", + "9": "25993019271/6250000000" + }, + "moment_upper": "18843240374007632787574146016054781874229303372624041422947482220006711301370274429947695208980254489816897240548747611244444368743276004072637922808870935882570128680328818549398102450780713937941962148009502862576404939280830970026757843577492332336646723065488256777720033773146986487763286240909696847125138467987925163899059004260396684485872581710426999541532754583126364150054072115355372997092131814707877644608013845328701623183575197641119070403719972578418991013100838433057297005801/18843240374022188813716544876044281641420198178815568353650892358430937800450226684489565657726081944265605298380567945237895333165146352714403020377768596101653776577083920769047814717414992832443374303453601214673790435903462229418347243029115952440677008837427389056462837546815456700841037075627095025847302610157977652099599444263090864581654224459281481215285979205790016268813393751867892110429718325479806730197277547027518014546582984812428424076074828906144073696000000000000000000000", + "saving": "26129/250000000", + "strict_gap": "14556026142398859989499767190894806191526930703410138424226499079952254541870448745827454448708057831820333993450964421870348641765097568897660219083647896755102219649712266634278894501412155444098352097385496622631259391589399451623620104030285771939132278742803773668470213077750834717398178722164142170052488200540440002694180095781642748854481673753224622663652118759321636512519113337586510771929085589263701698816391363007787171309353672354856327725082682899161566942702994199/18843240374022188813716544876044281641420198178815568353650892358430937800450226684489565657726081944265605298380567945237895333165146352714403020377768596101653776577083920769047814717414992832443374303453601214673790435903462229418347243029115952440677008837427389056462837546815456700841037075627095025847302610157977652099599444263090864581654224459281481215285979205790016268813393751867892110429718325479806730197277547027518014546582984812428424076074828906144073696000000000000000000000" + }, + "complex_row_sha256": "21f957e6d840e027ffdd1d7d3f95fd7d364c2cdef338c4ca79d25194e24179ca", + "finite_bridge": { + "bit_coarse": { + "W": 108516254, + "halving_degree": 367, + "m": 529, + "maxchild": 528, + "wire_bits": 27 + }, + "complex": { + "W": 124390992, + "halving_degree": 17, + "m": 576, + "maxchild": 552, + "s": 71647349312, + "scalar_group_upper": 2401613632, + "scalar_terms": [ + { + "c": 91770, + "copied_center_extra_groups": 48, + "h": 24, + "invocations": 2024, + "local_group_upper": 592224, + "v": 2024 + }, + { + "c": 91770, + "copied_center_extra_groups": 48, + "h": 24, + "invocations": 2024, + "local_group_upper": 592224, + "v": 2024 + } + ], + "wire_bits": 27 + }, + "ordinary_leaf_row_degree": 252, + "rows": { + "coefficient": 10620, + "contract": "W_complex^D_complex * W_coarse^D_coarse * W_old^D_old; one preceding prefix and one padding; sequential reuse", + "degree": 22000, + "degree_gap": "1676/5", + "suffix_slope": 88000 + }, + "semantic": { + "B": 1031531976569127429157544027776, + "C0": 19612721086794747362548571317438973216103734289332153416817836032, + "C1": 1, + "E": 1031531976569127429085896678464, + "exact_grid": "One common dyadic grid times the fixed odd divisor to K=G*(D_complex+1); no child rounding", + "fixed_odd_divisor": 21, + "induction_gap": 48482002898748989170404569305472, + "literal_charge": 74320906515135899127337796, + "strict_literal_gap": 1031457655662612293186769340668 + } + }, + "kappa": "1044939/10000000000", + "next_kappa_rejection": "{'compact_phase_layer_above_kappa': '-31373883009750410934758336863/625130644742395328821610525564500000000'}", + "ordinary_bit_saving": "1240189553/10000000000000", + "status": "Conditional stopped product-ring multiplication witness: deferred bit word, selected complex row" +} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/complex-circuit-construction.tex b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/complex-circuit-construction.tex new file mode 100644 index 0000000000..a5887b38d4 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/complex-circuit-construction.tex @@ -0,0 +1,218 @@ +\subsection{A compressed side circuit for the complex network} +\label{sec:complex-side-circuit} +Keep the complex motif of Section~\ref{sec:independent-complex}: $h=25$, +$v=\binom{25}3=2300$, $N=v^3$, $m=h^3=15625$, scalars in +$\mathbb Z[i,1/2]$, labels in $F=\mathbb F_2^{25}$ with the dot product, the +$h+1$ central wires, and the gather and scatter maps. For a triple $S$ write +$t_S$ for its indicator. The original side wires add +\begin{equation}\label{eq:complex-side-map} + \frac12\sum_{T\cap S=\varnothing}x_T-\frac12\sum_{|T\cap S|=2}x_T +\end{equation} +to $y_S$. With the central coefficient $(|S\cap T|-1)/2$ this gives +$y\gets y+x$. They use one wire per ordered neighbor pair, that is +$vz_{\rm c}=3693800$ side wires per invocation. We compute the same map with +shared sums. + +All sums below are formal sums of inputs $x_T$ whose two summands have +disjoint supports, so a source contributes to a node exactly when a directed +path joins them. Equal supports are identified within each of the two +families below, and nodes that feed no injected piece are removed. + +\paragraph{Disjoint sums.} +Order the points $0,\ldots,24$. For a list of nodes indexed by distinct +points and $k\le3$, the routine $\mathrm{vec}$ returns, for every set $E$ of +at most $k$ of these points, the sum of the nodes whose points avoid $E$. It +splits the list at $\lfloor n/2\rfloor$, recurses, and forms each output by one +addition of a left and a right output whose exclusion sets have total size at +most $k$. For a point list $X$ and weights $w(u,v)$ on its pairs, the routine +$\mathrm{pairs}$ returns the sums over pairs avoiding $E$, $|E|\le3$: split $X$ +into halves $L,R$, recurse on both, apply $\mathrm{vec}$ to each cross row +$(w(u,r))_{r\in R}$, then apply $\mathrm{vec}$ down the columns of these +row outputs with the remaining exclusion budget, and add the three disjoint +regions. The routine $\mathrm{tri}$ does the same for triple sums: with halves +$L,R$ of $X$, put +\[ + P_r=\mathrm{pairs}\bigl(L,(u,v)\mapsto x_{uvr}\bigr),\qquad + P'_u=\mathrm{pairs}\bigl(R,(a,b)\mapsto x_{uab}\bigr), +\] +apply $\mathrm{vec}$ over $r\in R$ to $P_r[E_L]$ and over $u\in L$ to +$P'_u[E_R]$, and add the four disjoint regions: triples in $L$, triples in $R$, +two points in $L$ with one in $R$, and one point in $L$ with two in $R$. + +At the top level $L=\{0,\ldots,11\}$ and $R=\{12,\ldots,24\}$. For a target +$S$ with $S_L=S\cap L$ and $S_R=S\cap R$ the disjoint pieces are +\[ + \mathrm{tri}(L)[S_L],\qquad \mathrm{tri}(R)[S_R], +\] +the two $\mathrm{vec}$ outputs over the halves $R_1=\{12,\ldots,17\}$ and +$R_2=\{18,\ldots,24\}$ of the family $P_r[S_L]$, and the two $\mathrm{vec}$ +outputs over the halves $L_1=\{0,\ldots,5\}$ and $L_2=\{6,\ldots,11\}$ of +the family $P'_u[S_R]$. These six pieces partition the triples disjoint from +$S$. They are internal nodes of the full computations because +$\mathrm{vec}$ splits at the same halves. + +\paragraph{Pair stars.} +For a pair $a(14/10^9)(966/100)$ give, by $e^{-x}>1-x$, +\begin{equation}\label{eq:compressed-complex-exponent} + s_{\rm c}/W_{\rm c}500000000^{10}$ and +$899^9<460^{10}$ give $m^\rho>500000000$ and +$899^{\rho-1}<460$. +If a path has one large child $t$, its moment is at most +\[ + (t/m)^\rho+(q-t)899^{\rho-1}/m^\rho. +\] +This expression increases over the large-child range, since its +numerator derivative is $\rho t^{\rho-1}-899^{\rho-1}>0$. +Use $t=m-b$ and the concavity bound +$(1-x)^{19/10}\le1-19x/10+9x^2/10$ to obtain +\[ + \sum_{\rm path}(r/m)^\rho + <1-\frac{19}{12800}+\frac9{10\cdot1280^2} + +\frac{1194\cdot460}{500000000} + =\frac{51180270301}{51200000000}<\gamma. +\] +Without a large macro the bound is $227493/6250000<\gamma$. + +For coefficient-depth accounting take $E_0=128(W+m+1)^3$. +There are at most $s$ positive-rank residual calls and $W$ endpoint +normalizations. Combining the quadratic phases with the $S$ factors, +each uses at most two diagonal phase passes and one scalar phase. +The inherited gate and remainder count is therefore bounded conservatively by +\[ + 36W^3+16s+16W+8m+42r_j^{t_j}$ gives depth at most +$t_j\lceil\log_2\max(2,e)\rceil$ plus a fixed constant. +The new coarse bit family has $(t_j,\operatorname{bitlength}W_j)=(16,28)$, +the ordinary leaf family $(9,28)$, and the complex family $(17,28)$. +The required reserve is the product of all three stocks: +\[ + Q=W_c^{D_c}W_b^{D_b}W_{\rm old}^{D_{\rm old}}. +\] +After the complex and coarse divisions, the old stock remains available +to every peeled-atom or stopped-leaf call. Sequential copies and outer +ordinary wrappers reuse restored rows; they introduce no independent +row factor. The combined coefficient is +\[ + 16\cdot28+9\cdot28+17\cdot28=1176, + \qquad4000-\frac{51}{25}\,1176=\frac{40024}{25}>0. +\] +Thus the retained logarithmic comparison, for eventual $e\le Cp$, +supplies a sufficient $p^{4000}$ stock including the fixed constants. +Use one physically preceding transformed prefix and one complete-row +padding, as in \path{notes/structured-bulk-assembly.tex}. Complete +spectators and parked fields are preserved by every descendant. +The suffix condition +$b_{\rm in}^{1-\epsilon}>16000(\log_2b_{\rm in}+8)$ is eventual +for every fixed $\epsilon<1$. + +\subsection{Analytic transfer and selected parameters} +The retained analytic proof map in +\path{notes/structured-bulk-assembly.tex} supplies the active-masked +arbitrary-source router with paid repair scans, the rounded phase-cell +inverse, persistent bulk halos with original period cuts, sequential +overlap tapes and factor pages, prime packing and exact recovery. +The new ordinary bit primitive has precisely the arbitrary-width, +complete-spectator and restored-row contract consumed by that router. +The new complex primitive supplies the exact completed tensor contract +on one common grid. Its outer grid conversions add only logarithmic +work. The changed finite implementations therefore meet the same +analytic interfaces, including the full bulk bound +\[ + O\!\left(Tp\left[p^\tau\operatorname{polylog}p+ + d\operatorname{polylog}p+dp^\delta+w_G^2p^\delta+ + dw_G^2p^\delta/L\right]\right)+n^{o(1)}, +\] +where $L=2^{\lceil8\log_2p\rceil}$, Gaussian band width +$w_G^2=O(p^{1-r})$, and normalization retains $\epsilon+r<1$. +Here $w_G$ is unrelated to the address atom width. + +Use the proved ordinary bit saving $a_b=803380799/10^{13}$ and complex +saving $b=1949/25000000$. To instantiate the retained assembly, weaken +the bit parameter explicitly to +\[ + \beta=10^{-6},\qquad + a=(1-\beta)b-10^{-10}=\frac{1948995551}{25000000000000}6.6129027953\times10^{-11}>0. +\] +The strict gaps absorb fixed logarithms, including the common-grid +conversions. The stopped atom recurrence supplies the ordinary +interchange interface, the rational-center construction supplies the +exact complex interface, and the product stock supports all nested +recursions. The unchanged analytic transfer then proves the stated +bound, with its constructive setup, descriptor and catalogue domination, +prime-existence and exact-recovery thresholds retained as eventual +conditions. +\end{proof} diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-complex.tex b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-complex.tex new file mode 100644 index 0000000000..4a9037137c --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-complex.tex @@ -0,0 +1,137 @@ +\subsection{All-disjoint retained centers} +Use two factors $h=24$. For triple inputs write $G=\sum_TX_T$, +$T_i=\sum_{T\ni i}X_T$, and retain all $A_i=G-T_i$. +Each input triple avoids exactly 21 points, so +\[ + \sum_{i=1}^{24}A_i=21G,\qquad G=\frac1{21}\sum_i A_i. +\] +For a target triple $S$ the central correction is +\[ + G-\frac12\sum_{i\in S}A_i + =\frac{\sum_{i\in S}T_i-G}{2}. +\] +An input triple meeting $S$ in $j$ points has central coefficient +$(j-1)/2$. Adding half the disjoint sum and subtracting half the +intersection-two sum leaves coefficient one exactly when $j=3$. +The scalar source-to-scatter transfer is therefore the identity. +The transparent old-value subtraction and new-value addition use this +identity only on fresh contributions and restore arbitrary old values. + +The base-two paired exclusion and aligned pair-star producer retains +nested binary labels: common-pair supports have their orthonormal triple +span, other ordinary sums have their coordinate cover. Each retained +$A_i$ has the nondegenerate coordinate hyperplane excluding $i$, +of dimension 23. Hence all copied-center arguments and general +nondegenerate binary residuals of the preceding proof apply. The +selected local counts are +\[ + v=2024,\quad c_h=45764,\quad q_h=8120,\quad + |\mathcal M|=8966,\quad R=44918,\quad\ell=552. +\] +The old internal histogram, starting at rank zero, is +\begin{small}\begin{align*} +[&8930,49042,30844,15972,11883,8272,6399,4356,6682,2263,\\ + &5109,1808,5317,1733,5391,1757,4908,3290,6233,4363,\\ + &4056,264,564,24,24]. +\end{align*}\end{small} +It has rank mass $24R+2\ell$. Replace 24 rank-24 original transitions +by 24 rank-one transitions; all rank-23 copied transforms remain. +The new mass is $24R+\ell$. + +\subsection{Physical endpoints and strict complex moment} +The copied-center two-stage complex contract in +\path{notes/copied-centers-complex.tex} is unchanged by the scalar +center decoding. For the tensor triple line $U$, let +$T=C_U$, $F=C_I$, $E=C_{U^\perp}=FT^{-1}$. +The two data outputs are $A=-Fy$ and $B=FT^{-2}x+Ey$. +Add $T^{-1}$ applied to a copy of $A$ into $B$, paying one rank-one +child per data pair. The inherited input/output $Z$ phases and +$i^{9f}$ scalar normalize $FT^{-2}$ to $F$; sign and bank corrections +complete the exact tensor $C$. Auxiliary source/sink operators remain +$C_{D_0}$ and $FC_{D_0}$ in the second stage. Every original role +therefore returns the exact selected-axis tensor operation on arbitrary +inputs. This algebraic statement holds over $\mathbb Q(i)$ as well as +over Gaussian dyadics. + +With $m_c=576$, $N_c=v^2=4096576$, $B_c=vR=90914032$, put +\[ + W_c=2N_c+2B_c=190021216,\quad L_c=2v\ell=2234496, +\] +\[ + s_c=W_cm_c-N_c+L_c=109450358336,\qquad N_c-L_c=1862080. +\] +The complete list is $2B_c$ width-552 auxiliary exteriors, +$2N_c$ width-529 data macros, $2vH'_r$ width-$r$ internal children, +$4N_c$ width-23 data fronts, and $N_c$ width-one endpoint copies. +These disjoint classes include both kinds of paid copies and sum to +$s_c$. All binary residuals, including alternating forms, use the retained +one-child Gauss normal form with paid bit adapters and unit phases. +At $a_c=1949/25000000$ the exact rational enclosure gives +\[ + \sum_r\frac{n_r}{W_c}(r/m_c)^{1-a_c} + <1-1.3338373969\times10^{-10}. +\] + +\subsection{One exact odd-denominator grid} +The only new odd divisor is 21. Let $d$ bound the root axis count, +$D$ bound its maximum complex recursion depth, and $G_0$ bound the +number of grouped scalar operations per node. Choose +\[ + K=G_0(D+1),\qquad \text{common grid }2^{-P}21^{-K}. +\] +Root inputs and arbitrary dirty auxiliaries start Gaussian dyadic. +Multiply their integer numerators by $21^K$ once at the outer boundary. +Every local coefficient contains at most one factor 21 in its denominator, +so a local finite program adds at most $G_0$ to the odd-denominator +exponent. A completed $u$-axis child has Gaussian-dyadic coefficients +and therefore preserves its input's existing odd-denominator exponent; +it adds no new odd factor. Only the active chain of unfinished calls +can accumulate new factors. Its length is at most $D+1$, proving that +all intermediates lie on the common grid and every local division by +21 is an exact integer division of its encoded numerator. + +This divisibility claim uses the root dyadic-input invariant, not an +assumption about arbitrary numerators on the finest grid. Internal values +may have odd denominators. They are neither rounded nor re-encoded when +a child returns. At the completed outer return the operator is the exact +Gaussian-dyadic tensor on root dyadic inputs, so the final numerators +are divisible by $21^K$; exact unscaling restores dyadic encoding. + +Since the largest child is $552<576$, $D=O(\log d)$ and +$K=O(\log d)$ with fixed constants. Constant-divisor long division +is linear in numerator length. Initial and final scaling by $K$ +successive constant multiplications/divisions cost $O(V\log d)$ and +occur only at the outer boundary. The extra numerator length is +$O(\log d)$, preserving the retained $O(p)$ word bound. This overhead +is subordinate to the positive-power complex layer bound. + +For explicit semantic constants use +\[ + g_h=4(c_h+v)+10v+4hv+4h^2+8h+8=408200, +\] +\[ + G_0=N_c+2v(g_h+2h)=1656684480, +\] +where endpoint additions and copied-center scalar work are included. +The complete child contributes at most $u$ binary denominator bits +and row-norm factor $2^u$, with no additional odd exponent. A local +21-division contributes fewer than five denominator-height bits, +covered by the fixed scalar charge. Set +\[ +\begin{aligned} + E_0&=64(W_c+m_c+G_0+1)^3=403063477262941121443761178688,\\ + \mathcal E&=2G_0W_c^2+8s_c+4W_c+4+32m_c\\ + &=1196393335930350962702877484.2909639537\times10^{-10}. +\] +It uses the retained 24-term positive atanh-series logarithm enclosure, +its geometric tail, range reduction and upward rational exponential +bound. Also $\mu_1=s_b/(W_bm_b)<1$. These are the two gaps used below. diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-interface.tex b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-interface.tex new file mode 100644 index 0000000000..20c44ce486 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/stopped-product-interface.tex @@ -0,0 +1,95 @@ +\subsection{Paid atom adapters and remainders} +Expand each fixed lower-triangular formal factor into unit scalings and +additions from earlier to later formal fields. Execute intrabank targets +in descending formal-field order, so earlier controls still have their +required original values. Every atom update reads only physically earlier +controls. In a cross-bank shear the update is +\[ + D_{i,t}\leftarrow D_{i,t}+k_{ij}H_{j,f-1-t}. +\] +Even with the reversed source index, the source lies in the earlier head +bank. The retained ordered-affine streaming primitive applies to each +ordinary width-$w$ atom update, costing $O(V)$ per pass. +There are $O(f)$ passes per fixed matrix and thus $O(Vn)$ per finite +node. The reversed control is an indexed earlier atom, not a reversed +field operation. Atom loops use binary descriptors on a fixed tape set; +all inactive digits remain complete spectators. The inherited parking +schedule never scans through parked ancestors, and polynomial descriptor +work is absorbed by the complete stream volume. + +For $n=m_bf+\delta$, $0\le\deltaa_b$, the paid adapter term is strictly lower order. +All bounded widths use the old interface. Numerical padding of a binary +chunk range to the least suitable radix-$q$ range has volume factor +below $q^2$; it preserves numerical order and is removed after the +completed ordinary wrapper, whose endpoint is ordinary interchange. + +If external rows are unavailable, use the inherited ordinary high-digit +borrowing construction from \path{notes/batched-bit-rows.tex}. +Borrow $O(\log e)$ high digits, exchange and join them into a preceding +row field, pad that field once, act on the body, and separate the high +parts. It applies literally to the completed ordinary wrapper; no claim +about borrowed high positions is made for an unwrapped reversed call. +Single-digit moves cost $O(V\log e)$, and small widths use the old +algorithm. Atom indices and rational coefficients are finitely specified; +the algorithm uses the same fixed tape set and complete spectator ranges. diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/structured-bulk-complex.tex b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/structured-bulk-complex.tex new file mode 100644 index 0000000000..53868b41b2 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/notes/structured-bulk-complex.tex @@ -0,0 +1,129 @@ +\subsection{Mixed centers with dyadic scatter} +The complex payload is Gaussian dyadic; its address labels are binary. +For an even axis dimension $h$ define +\[ + T=\sum_U X_U,\qquad G_i=\sum_{U\ni i}X_U,\qquad D_i=T-G_i. +\] +Choose a point set $\mathcal D$ of size $d_0$ with $|3-d_0|$ a +nonzero power of two. Retain $D_i$ for $i\in\mathcal D$ and +$B_i=2G_i$ for $i\notin\mathcal D$. Since $\sum_iG_i=3T$, +\[ + T=\frac{\sum_{i\notin\mathcal D}B_i-2\sum_{i\in\mathcal D}D_i} + {2(3-d_0)}. +\] +The required central correction at triple $S$ is +\[ + \frac{\sum_{i\in S}G_i-T}{2} + =\sum_{i\in S\setminus\mathcal D}\frac{B_i}{4} + -\sum_{i\in S\cap\mathcal D}\frac{D_i}{2} + +\frac{|S\cap\mathcal D|-1}{2}T. +\] +Substitute the expression for $T$ to obtain one fixed dyadic scatter +on exactly $h$ retained centers. Adding half the disjoint sum and +subtracting half the intersection-two sum gives coefficient one on +$X_S$ and zero on all other source triples. There is no global-total +role. The transparent wrapper subtracts the old scatter and adds the +new scatter after source copying, then restores the auxiliaries. +Only the fresh contribution must satisfy the identity; arbitrary old +auxiliary values are permitted. + +Label $B_i$ by $E_i=\{x:\sum_{j\ne i}x_j=0\}$ and $D_i$ by the +coordinate space omitting $i$. Both are nondegenerate of dimension +$h-1$: the normal of $E_i$ has odd norm because $h$ is even. +Every contributing triple line lies in its assigned frame. +Hence center loss is $h(h-1)$. Use $d_0=19$ when $h=30$, and +$d_0=35$ when $h=40$, choosing the first $d_0$ points in the fixed +producer order. The expanded scatter denominators divide 128. + +The base-two paired exclusion producer retains complete disjoint sums, +full pair-star sums, and their leave-one-out side sums, sharing by +actual source support. A support with at least two common points has +its orthonormal common-pair-star span; otherwise use the coordinate +space of its union. The central $B_i$ additions use $E_i$. These +labels are nested and nondegenerate, so the inherited deterministic +carrier compiler applies. Its selected counts are +\[ +\begin{array}{c|rrrrrrr} +h&d_0&v_h&c_h&q_h&|\mathcal M_h|&R_h&\text{loss}_h\\\hline +30&19&4060&98674&16270&15850&99094&870\\ +40&35&9880&250358&39560&37271&252647&1560 +\end{array} +\] +The internal histograms satisfy $\sum_r rH_{h,r}=hR_h+2h(h-1)$. +They exclude all external macros and physical-data frontiers. + +\subsection{General residuals and translated endpoints} +The general normal form of \path{notes/endpoint-gauge-complex.tex} +remains applicable, including alternating residuals. For clarity, if +$V$ is a binary residual basis, $G=V^tV$ nonsingular, and +$q(z)=\operatorname{wt}(VG^{-1}z)\pmod4$, then +\[ + K(x,y)=2^{-r}S_q i^{-q(Gx)}(-1)^{x^tGy}i^{-q(Gy)},\qquad + S_q=\sum_z i^{q(z)}. +\] +This follows by completing the square in the Fourier kernel; the polar +form is $2G^{-1}$. With $b_0=(1-i)/2$ and $S_0=\operatorname{diag}(1,i)$, +\[ + \tfrac12\begin{pmatrix}1&1\\1&-1\end{pmatrix}=b_0 S_0CS_0. +\] +The Gauss sums of odd one-dimensional blocks are $1\pm i$ and those +of alternating two-dimensional blocks are $\pm2$, so $S_qb_0^r$ is +a fourth root of unity. Therefore one rank-$r$ child, binary address +permutations and unit fourth-root phases implement the residual. +Mixed signs retain the same nonsingular polar form. Tensoring over +$f$ parallel columns gives one width-$rf$ child. No orthonormal basis +of the whole residual or new non-dyadic coefficient primitive is used. + +Adopt the translated sink of PR21 \cite{pr21}. For stage-two background +$D_0$ and active space $A$, write $D_1=D_0\mathbin{\perp}A$. +Choose source $C_{D_0}$ and sink $C_FC_{D_0}$. Their endpoint product +is $C_F$ on every arbitrary restored auxiliary input. With the retained +refined copy schedule the entrance is identity, and the last edge is +\[ + (C_FC_{D_0})C_{D_1}^{-1}=C_FC_A^{-1}=C_{A^\perp}. +\] +It is a single residual of rank $m_c-b$. Data endpoint corrections +remain the inherited ones. Each completed call, forward or inverse, +is exactly the selected-axis tensor $C$ operation on every physical +role, with identity on the other coordinates. This all-role contract +is needed by the semantic precision and row-padding arguments. + +\subsection{Complete complex child list} +Use $(a,b,k)=(30,30,40)$ and $m_c=36000$. With the complex counts set +$N_c=v_{30}^2v_{40}=162857968000$, +$B_1=B_2=N_cR_{30}/v_{30}$ and $B_3=N_cR_{40}/v_{40}$. Then +\[ +\begin{aligned} + W_c&=2N_c+B_2+B_3=8465185828400,\\ + L_c&=2(N_c/v_{30})870+(N_c/v_{40})1560=95510688000,\\ + s_c&=W_cm_c-2N_c+2L_c=304746555127840000. +\end{aligned} +\] +The external whole-residual list is +\[ +\begin{array}{c|rrrrr} +t&35930&35960&35970&35061&841\\\hline +n_t&B_1&B_3-B_1&B_2&2N_c&2N_c +\end{array} +\] +For each axis, add $(N_c/v_h)H_{h,r}$ children of width $r$. +Finally the three physical-data fronts contribute $2N_c$ copies of +29, 29 and 39, respectively. Their frames are unchanged by the auxiliary +endpoint choice or linear change of center coordinates, and the general +residual lemma batches each whole front. Their total rank is exactly +$2N_c[(a-1)+(b-1)+(k-1)]$, exhausting the former singleton remainder. +Thus the external, internal, and data-front classes are disjoint and +sum to $s_c$; no uncharged physical rank remains. + +Set $a_c=131/5000000$, $\sigma=1-a_c$. The same logarithm enclosure +as above, now for $m_c/t$, and $e^u\le(1-u)^{-1}$ for $0\le u<1$ +give the exact rational certificate +\[ + \Psi_c(\sigma)=\frac1{W_c}\sum_tn_t(t/m_c)^\sigma + \le\sum_t\frac{n_tt}{W_cm_c(1-a_c\ell_t)} + <1-1.0940382\times10^{-9}. +\] +Every child is narrower than its parent; the largest has numerator +$r_c=35970$. The selected precision proof is the linear semantic +argument below, which uses this actual largest child and the complete +physical rank mass. diff --git a/research/completed-core-sharing/inputs/research/pr117-public/tree/references/semantic-bulk/pr21/translated-partial-complex.tex b/research/completed-core-sharing/inputs/research/pr117-public/tree/references/semantic-bulk/pr21/translated-partial-complex.tex new file mode 100644 index 0000000000..1b8fb41963 --- /dev/null +++ b/research/completed-core-sharing/inputs/research/pr117-public/tree/references/semantic-bulk/pr21/translated-partial-complex.tex @@ -0,0 +1,234 @@ +\section{Translated auxiliary phase frames for the complex layer} +\label{sec:translated-partial-complex} +We use the retained $h=28$ paired complex producer and its original +three-stage schedule, with the changed endpoints below. This replaces, +rather than combines with, the different complex data-entrance regrouping +in the partial-swap package. The finite producer and its complete frame +checks come from PR~7; whole-residual recursion and the fixed-tape transfer +come from icekylinx's PR~10. The freedom to move auxiliary endpoint frames +is inspired by \emph{eumemic}'s Claude-assisted PR~13. The transfer to +phase operators, complete physical audit, explicit phase certificate, and +enlarged precision guard below are the present contribution. All inherited +conditional hypotheses remain in force. + +\subsection{An operator identity for arbitrary dirty auxiliary inputs} +\label{sec:translated-complex-source} +Let $F=\mathbb F_2^{28}$ with its standard dot product. For a nondegenerate +binary space $U$, let $P_U$ be its orthogonal projector and $C_U$ its +retained phase operator. In common Hadamard coordinates, $C_U$ is diagonal +with entries $i^{\operatorname{wt}(P_Ux)}$. These operators commute and +are invertible over the Gaussian dyadic ring. If $U\perp V$, then +$C_{U\mathbin\perp V}=C_UC_V$: the correction in +$\operatorname{wt}(u+v)=\operatorname{wt}(u)+\operatorname{wt}(v) +-2|\operatorname{supp}(u)\cap\operatorname{supp}(v)|$ is divisible by +four when $u\cdot v=0$ over $\mathbb F_2$. + +For a stage-two invocation let $P,Q$ be its norm-one triple lines. Put +\[ + D_0=P^\perp\otimes F\otimes Q,\qquad D_1=F\otimes F\otimes Q, + \qquad E=P\otimes F\otimes Q. +\] +Then $D_1=D_0\mathbin\perp E$, with dimensions $756,784,28$ respectively. +Each stage-two auxiliary role, including all 29 centers, has first common +gate frame $C_{D_0}$ and last common gate frame $C_{D_1}$. +Give it source operator $C_{D_0}$ and sink operator $C_I C_{D_0}$, +leaving every common gate unchanged. For arbitrary physical input $f$, +interpret the logical input as $g=C_{D_0}^{-1}f$. The scalar identity +restores every auxiliary $g$, so its physical output remains +$C_I C_{D_0}g=C_If$. This is a proof invariant, not executed source +preprocessing: formal denominators of $g$ are never stored. Scalar +cancellation holds for arbitrary arrays over the Gaussian dyadic ring. +Data endpoints, signed scalar exchange, and their corrections are unchanged. + +The first edge is identity; the final edge is exactly +\begin{equation} + (C_I C_{D_0})C_{D_1}^{-1}=C_I C_E^{-1}=C_{E^\perp}. + \label{eq:translated-complex-exit} +\end{equation} +This is multiplicative operator cancellation. Replacing $C_I C_{D_0}$ +by a binary projector expression would incorrectly discard repeated phases. +The common-frame invariant and arbitrary-input scratch restoration permit +this independent endpoint choice on each auxiliary role. + +\subsection{Residual basis and a phase certificate on all addresses} +\label{sec:translated-complex-phases} +Coordinate permutations in the first and third factors reduce every +actual pair $P,Q$ to $t=e_0+e_1+e_2$. They preserve inner products and +integer Hamming weights. An explicit orthonormal basis of $t^\perp$ is +\[ + e_3+e_0+e_1,\ e_3+e_1+e_2,\ e_3+e_0+e_2,\ e_4,\ldots,e_{27}. +\] +An orthonormal basis of $E^\perp$ is the disjoint union +\[ + (\mathcal B_{P^\perp}\otimes\mathcal E_F\otimes\mathcal E_F) + \ \cup\ (t_P\otimes\mathcal E_F\otimes\mathcal B_{Q^\perp}). +\] +The two orthogonal parts have dimensions 21168 and 756. Their total +$21924=m-28$ is proper and nonalternating. Of the basis vectors, 18900 +have weight $1\bmod4$ and 3024 have weight $3\bmod4$. The whole-residual +identity uses one width-$21924f$ child, two parity-sign passes, and +constant phase $(-i)^{3024f}=1$. The sign passes remain necessary. +Inverse orientations use the inverse signed wrappers; all other residual +bases and both orientations retain their previous complete checks. + +The control additionally proves the phase equality on every binary address. +Set +\[ + \delta(x)=\operatorname{wt}(x)+\operatorname{wt}(P_{D_0}x) + -\operatorname{wt}(P_{D_1}x)-\operatorname{wt}(P_{E^\perp}x)\pmod4. +\] +Its polarization is +$2x^t(I+P_{D_0}+P_{D_1}+P_{E^\perp})y=0\pmod4$, by the symmetric +idempotent projector identities. Hence $\delta$ is additive. +On the 21952 coordinate vectors the weight triples are $(0,0,1)$, +$(3,3,1)$, $(6,3,8)$, with counts 19600, 2100, 252. The script checks +every coordinate and obtains zero in each case. Additivity proves +$\delta=0$ on all $2^{21952}$ addresses. Tensor Gram identities and the +coordinate-permutation reduction cover every actual invocation. + +\subsection{Every physical edge and the exact time moment} +\label{sec:translated-complex-edges} +The retained parameters are +\[ + h=28,\quad v=3276,\quad R=93838,\quad m=21952, + \quad B=v^2(R+29)=1007397164592, +\] +\[ + W=2v^2(v+R+29)=2085111546336,\quad + D=2v^3-6v^2h(h+1)=18030055680, +\] +\[ + s=Wm-D=45772350635112192. +\] +Each of the $B$ changed roles replaces ranks $756,21168$ by $0,21924$. +Width, total rank, and deficit are unchanged. The complete histogram is +$3v^2$ times the following local histogram, plus four external classes: +\begin{small}\[ +\begin{split} +(H_1,\ldots,H_{28})={}&(93912,23891,21224,31667,13552,9128,9240,10912,\\ + &5656,8456,4284,7598,4872,7448,4536,7803,4228,8232,\\ + &4872,7482,7224,5901,8400,11550,1512,5180,6552,87). +\end{split} +\]\end{small} +\[ +\begin{array}{c|rrrr} +\text{rank}&21896&21924&729&21141\\\hline +\text{copies}&B&B&2v^3&2v^3 +\end{array} +\] +These are respectively the shared auxiliary join, new auxiliary exit, +and the stage-two and stage-three data entrances. No rank-$m$ edge occurs. + +The audit executes the actual compiled forward and inverse/complement +schedules at global tensor dimensions. It counts every incident wire, +including unchanged controls, every carrier, all data boundaries, and the +shared bank. A separate count from DAG degrees and label dimensions plus +the four macro classes gives exactly the same histogram. The gate offset +in stage $j$ is $(h^{j-1}-1)h$. Stage one ends its auxiliary bank at $h$; +stage three starts the shared bank there, so no endpoint or join is counted +twice. The dimension-27 local entries include both physical data frontiers. + +Let $n_r$ be the complete histogram. Put $a_c=18/10^6$ and +$\sigma=1-a_c$. Exact rational upper bounds $\ell_r\ge\log(m/r)$, +obtained from the atanh series with powers-of-two range reduction, give +\[ + \frac1W\sum_r n_r(r/m)^\sigma + \le\sum_r\frac{n_rr}{Wm}\frac1{1-a_c\ell_r}<1. +\] +All denominators are positive. The exact certified gap exceeds +$6.6652\times10^{-9}$; this decimal only reports a lower bound on the +rational certificate. The rank weights sum exactly to $1-D/(Wm)$. + +\subsection{A precision guard across endpoints and stage boundaries} +\label{sec:translated-complex-guard} +Keep the original common-gate dimension potential. Give a changed source +potential $756$ and its sink the formal potential $m+756=22708$. +The latter is bookkeeping, not a binary subspace: its difference from the +last actual gate dimension $784$ is precisely the new rank $21924$. +Every physical edge rank is the absolute change in potential; a scalar +gate permits a path to change role without changing its common potential. +The only decreasing edges are the retained central returns, losing $h$ +each. Invocations in one stage are disjoint, so a path meets at most one +return per stage. Telescoping across the entire physical path gives +\[ + \sum_i r_i\le q'=m+(h^2-h)+6h=22876. +\] +This includes paths entering stage-two auxiliaries from data. The old +$m+6h$ cannot be reused, because such a path may reach the enlarged exit +without traversing the removed auxiliary entrance. + +The finite audit conservatively connects every incident input at each +gate to every incident output. At each tensor-stage data boundary it uses +the maximum over the entire incoming data bank, covering all coordinate +permutations. For the shared bank it preserves the exact per-role depths +from stage one into stage three: the local programs and zero initial +depth are identical, and the bank matching preserves local role indices. +It bounds the maximum rank sum by 22820 and the maximum squared-rank sum +by 481197866. These are conservative envelopes, not claimed realizable +maximizing paths. + +Every recursive child stays within its parent role. Frame basis changes, +row splitting, and parking permute addresses without creating cross-role +arithmetic dependencies. Therefore physical coefficient paths project to +scalar paths with $\sum r_i\le q'$ and $r_i\le M=m-h=21924$. +Since $M