diff --git a/research/centre-polynomial-cache-limits/NOTICE.md b/research/centre-polynomial-cache-limits/NOTICE.md new file mode 100644 index 0000000000..b0262bd4f2 --- /dev/null +++ b/research/centre-polynomial-cache-limits/NOTICE.md @@ -0,0 +1,42 @@ +# Credit, source pins, and limits + +The source is the historical selected construction at commit +`bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. Its selected archive is +[retained here at the source commit](https://github.com/CrocSwap/integer-mult-bounds/blob/bce54fb3f895cbe5cd4c0eb477c3afeed100190f/research/community-frontier1042-audit/selected-replay.tar.gz). +The two needed archive members are copied without edits. Their original +compressed digests and the complete archive digest are in SOURCES.json. + +The original supplier notices are retained under `notices/`. They identify +the source work, compiler work, and earlier contributor lineage. In +particular, the [Gauge44 notice](https://github.com/CrocSwap/integer-mult-bounds/blob/bce54fb3f895cbe5cd4c0eb477c3afeed100190f/research/gauge44-slots-t16/NOTICE.md) +credits icekylinx and retains the upstream notices. This package does not +infer contributor identity from a PR submitter account. + +The circuit-interface lane derived the actual R. The history-encoding +lane supplied the Bell certificate. The interface-proof lane supplied +the separate sparse replay, the all-size extension, and the inverse +corollary. The native-encoding lane supplied the scalar-cache theorem. +These are OpenAI Codex research roles under Ali Romman's direction. +They are not independent human authors or reviewers. Substantial +OpenAI Codex assistance was used for research, checks, and packaging. + +[PR #1719](https://github.com/CrocSwap/integer-mult-bounds/pull/1719) +published the historical doubled Walsh lift at commit +`3ae9a6f3ac74ded022ab3b4872a7357a621af6fb`. This package uses the doubled +port representation to study one weighted Gram; it does not re-publish +that lift as a new construction. + +The actual query source is already retained by +[PR #4720](https://github.com/CrocSwap/integer-mult-bounds/pull/4720) at +[this exact source path](https://github.com/CrocSwap/integer-mult-bounds/blob/cb102a57254748651ce16aa4454bb611f6380e53/research/actual-query-information-bounds/payload/lanes/circuit-interface/INTERFACE.json). +That PR also publishes the separate scalar source-span theorem. +[PR #4750](https://github.com/CrocSwap/integer-mult-bounds/pull/4750) +publishes the [fixed-code projector criterion](https://github.com/CrocSwap/integer-mult-bounds/blob/3c6a768e5391e6bc8355fe2bc849d2978afef8f6/research/phase-coded-callers/annexes/fixed-code-interface/PROOF.md). +The new package does not claim those results again. + +The 22 October cleanup audit found these two notes outside the fixed +469-observation closure. It checked the exact published source objects +and found no equivalent adopted statement in the 15 campaign packages. +A bounded source search is not a universal literature novelty check. + +Apache-2.0 applies. Original notices and license text are unchanged. diff --git a/research/centre-polynomial-cache-limits/PACKAGE-MANIFEST.json b/research/centre-polynomial-cache-limits/PACKAGE-MANIFEST.json new file mode 100644 index 0000000000..47a2f1ca0d --- /dev/null +++ b/research/centre-polynomial-cache-limits/PACKAGE-MANIFEST.json @@ -0,0 +1,164 @@ +{ + "files": [ + { + "path": "NOTICE.md", + "bytes": 2804, + "sha256": "4dde831dc40b31d0edc23adbcd0aaeec3aa573eef6f4f27fcdb53d24eab173e8" + }, + { + "path": "PROOF.md", + "bytes": 5655, + "sha256": "ebcd0912e990c71f3b29b87674c1b5e3efa8f5ea37ed20f4fd06d80ce27f6382" + }, + { + "path": "README.md", + "bytes": 3420, + "sha256": "7569c606042bacf8c36b75fbbd1dfef9a8861d194659c4a93dfa68fddc7c044f" + }, + { + "path": "SOURCES.json", + "bytes": 5809, + "sha256": "b3ad9ed33fda0ffb64d50ed6d026168651b9351a16a21ca0b9821c179b474d3d" + }, + { + "path": "check_phase_cache.py", + "bytes": 5314, + "sha256": "16ed9b27047d065c7a7648ebc8dc46438ec93c7cfbc530f9cc996e878d1ffe5d" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py", + "bytes": 8966, + "sha256": "33b6b73303275e481f12cc2f946d1273ca9ac03d9294600016f03e84e6921088" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json", + "bytes": 23232, + "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md", + "bytes": 4001, + "sha256": "bc3a72690735230e8d9995df1a343f69fe8afed7dce056a82505efc83a884698" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json", + "bytes": 10174, + "sha256": "4b198523d498b85b96445681fdcd8020402b1abb31c6a27e7d2a45d5df2217e2" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md", + "bytes": 1058, + "sha256": "d1d3011e26d5768edc10ac234aeb9cb80c721addc28f9aabc784f56383ca4fe3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py", + "bytes": 5140, + "sha256": "8604d1665862593efc146644fbf47a85c4a2aca88106284096d723853a064e45" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json", + "bytes": 1996, + "sha256": "4f48be6cfd0f7ab316d1dc957ba18668b56a4feed55ef8cae5c205560e13b16a" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md", + "bytes": 3113, + "sha256": "3a670ff14be1db7109d12d1fc6c28704543d3a19ad2e9d4ac6431a0a86a57d9f" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py", + "bytes": 9719, + "sha256": "0d9983c288292f568c1f1595b944ca81131f79119855b7ad5c64e28c3cbfd899" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md", + "bytes": 7975, + "sha256": "bd53f0c38ac06e20b8361543086bb5f6310bdeb552fb692dc29978434cd4dc84" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz", + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz", + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + { + "path": "notices/LICENSE", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "notices/research/gauge44-slots-t16/NOTICE.md", + "bytes": 1964, + "sha256": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf" + }, + { + "path": "notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "bytes": 6406, + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610" + }, + { + "path": "notices/research/gauge44-slots-t16/construction/NOTICE.md", + "bytes": 950, + "sha256": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816" + }, + { + "path": "notices/research/gauge44-slots-t16/t16/NOTICE.md", + "bytes": 2245, + "sha256": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + { + "path": "replay.py", + "bytes": 3216, + "sha256": "20f3436ba77856ba233650bd04a42daad6c597bb19b439e5291cc3226057e98c" + }, + { + "path": "requirements.txt", + "bytes": 12, + "sha256": "a83a2a4ed7ab2e022b9b8a83cfa2b8cf52cc243006c597e8b96f90a8365590ac" + }, + { + "path": "validation/PHASE-CACHE-CHECK.json", + "bytes": 1376, + "sha256": "34386095a77c0aa3008e652fb2dc982a654b17b525dd0f85bf3b72c8867d3556" + }, + { + "path": "validation/REPLAY.json", + "bytes": 2075, + "sha256": "7898245ca60369fcae643ce6f5bec5065e2e2aa0d46c1658b8e5f5ca56253779" + }, + { + "path": "validation/bell-producer-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/bell-producer-stdout.txt", + "bytes": 200, + "sha256": "b8a03214ced2b88ff097a6a7f5ba55f40dd931299b1fe75cb6d62d2108877b29" + }, + { + "path": "validation/bell-review-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/bell-review-stdout.txt", + "bytes": 135, + "sha256": "04001332aac6a4120ebb33bc8a6f1946fe96094f7ef6bd2d8ea73ed52f60c1e8" + }, + { + "path": "validation/phase-cache-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/phase-cache-stdout.txt", + "bytes": 39, + "sha256": "3fad44ed5923785fcc2c7534cd9887c315168ffbcd5d9f1c5935a461585d7622" + } + ] +} diff --git a/research/centre-polynomial-cache-limits/PROOF.md b/research/centre-polynomial-cache-limits/PROOF.md new file mode 100644 index 0000000000..98e070a4e3 --- /dev/null +++ b/research/centre-polynomial-cache-limits/PROOF.md @@ -0,0 +1,126 @@ +# Exact scope of the retained results + +The input is the actual eight-by-112 rational query matrix R at historical +source commit `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. It satisfies +`R R^T = 56 I`. Its 112 labels q are distinct, nonzero, odd vectors in +`F_2^9`. Each column has four entries in `{1,-1}`. This package does not +replace these columns with the completed 120-root system. + +## 1. Scalar-polynomial degree + +Let `H_q = (X_q+Z_q)/sqrt(2)` and `Gamma_q = H_q tensor H_q` on the +doubled binary payload. A common scalar phase does not change the +conjugation used below. Define, for each positive integer lambda, + +```text +A_lambda = (1/4) sum_q r_q r_q^T tensor Gamma_q^tensor(lambda). +``` + +Here r_q is the corresponding column of R. The root coefficient occurs +once. It is not raised to a tensor power. + +Identify doubled payload vectors with Pauli matrices `X^b Z^a`. The +four-term expansion of conjugation by H_q gives + +```text +|a,b> -> (-1)^(q dot a) |a,b> if q dot (a+b) = 0, +|a,b> -> |a+q,b+q> if q dot (a+b) = 1. +``` + +Thus c=a+b is fixed. On the a coordinate in the block c=11, the port +operator is Z_q when `q dot c=0` and X_q otherwise. The resulting block +A has dimension 4,096 and entries in `Z[1/2]`. + +The [retained certificate](frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json) +fixes integer vectors v,w by SHAKE256 seeds and gives 817 moments +`s_j=w^T A^j v` modulo 65,537. The 409-by-409 Hankel matrix +`H[i,j]=s_(i+j)` has determinant 2,984 modulo 65,537. The separate +[review](frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md) +derives R from the original word, builds the sparse integer matrix 4A, +and checks the same determinant by fraction-free elimination in the +prime field. It also checks every Bell sign and the common fixed vector. + +This determinant belongs to `Z[1/2]`, and its reduction is nonzero, +so the determinant itself is nonzero. The first +409 Krylov vectors are therefore independent. No scalar polynomial of +degree below 409 annihilates A. The nonzero minor remains nonzero over +any characteristic-zero field extension. + +The Bell identity vector is fixed by every Gamma_q. Tensor the certified +block with this vector in all remaining tensor slots. The restriction of +A_lambda to that invariant subspace is exactly A. The degree bound holds +at every positive lambda, including when the proposed polynomial depends +on lambda. + +If `aI+bA_lambda` is invertible, `b != 0`, and +`q(A_lambda)=(aI+bA_lambda)^-1`, then +`(a+bt)q(t)-1` is a nonzero annihilating polynomial. It has degree at most +`degree(q)+1`. Therefore `degree(q) >= 408`. + +The result does not give the exact minimal polynomial. It does not bound +rational expressions, matrix-valued encodings, general scalar ADD +circuits, or the native cost of a decoder. + +## 2. The least scalar cache for diagonal updates + +Let R be any complex matrix with finitely many columns. Let D_1,...,D_t +be diagonal matrices. Put two columns in the same fiber F when all D_j +have the same diagonal entries at those columns. Then the smallest row +space E that contains row(R) and satisfies `E D_j subset E` for every j +is + +```text +E = direct_sum_F row(R restricted to F), +dim(E) = sum_F rank(R restricted to F). +``` + +Each summand has support only on F. This direct sum contains row(R) and +is invariant under every D_j. Conversely, choose a linear combination D +of the D_j whose diagonal values distinguish the finitely many fibers. +Such coefficients exist over C: a finite union of proper hyperplanes +does not fill the coefficient space. Polynomial interpolation in D gives +each fiber projector. Any invariant E that contains row(R) must contain +the projection of every row onto every fiber. The supports are disjoint, +so their dimensions add. A basis in each fiber attains the bound. + +For the historical R, use sign characters `D_s[p,p]=(-1)^(q_p dot s)`. +For the ordered normal directions + +```text +42, 7, 25, 52, 82, 127, 97, 76 +``` + +the successive dimensions, including the empty family, are + +```text +8, 15, 28, 44, 44, 56, 56, 56, 56. +``` + +The final fibers are fourteen eight-column groups of rank four. For the +first zero through nine coordinate characters the dimensions are + +```text +8, 16, 31, 53, 85, 101, 112, 112, 112, 112. +``` + +Thus six specified coordinate characters already require all 112 source +directions in this cache model. The 56-row cache does not support the +full source-phase family. The exact rank histogram of the two-demand +stack `[R; R D_s]`, over all 512 sign characters, is two of rank eight, +sixteen of rank fifteen, and 494 of rank sixteen. + +The original [phase-cache note](frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md) +contains this argument and these counts. The package check independently +reconstructs the counts from R and the labels. It checks the row-basis +construction directly. This is a scalar representation result. It permits +redundant cache rows, but does not permit a source-dependent payload +operator before the cache unless the input contract is changed. + +The related fixed-code graph theorem in +[PR #4750](https://github.com/CrocSwap/integer-mult-bounds/pull/4750) +tests whether one given code is invariant. The result here gives the +smallest invariant enlargement of a specified query space. The +[source-span theorem in PR #4720](https://github.com/CrocSwap/integer-mult-bounds/pull/4720) +uses a different payload-query grammar and independently gives 112 scalar +source directions. These earlier published results are not new claims +of this package. No universal novelty claim is made. diff --git a/research/centre-polynomial-cache-limits/README.md b/research/centre-polynomial-cache-limits/README.md new file mode 100644 index 0000000000..85f1b44f48 --- /dev/null +++ b/research/centre-polynomial-cache-limits/README.md @@ -0,0 +1,71 @@ +# Two limits for historical centre encodings + +This package retains two results that were outside the 22 October campaign +publication closure. It adds no native supplier and does not change the +complete kappa calculation. + +- The actual doubled centre Gram has scalar minimal-polynomial degree at + least 409 at every positive tensor size. An exact scalar-polynomial + inverse of `aI+bA`, when it exists and `b != 0`, has degree at least 408. +- The smallest scalar row space that contains a query and is closed under + specified diagonal updates has dimension equal to the sum of its fiber + ranks. The historical query needs 56 rows for the stated normal-character + family and 112 rows for six specified coordinate characters. + +These are different models. The first result does not bound general ADD +circuits or native decoder cost. The second result assumes a common scalar +input representation. It does not supply or price native source access. +Neither result closes the physical caller, helper, terminal, precision, +hosting, or recursive admission obligations of the historical campaign. + +Read [the proof and claim limits](PROOF.md), [source pins](SOURCES.json), and +[credit and predecessor comparison](NOTICE.md). The original proof, +certificate, checker, and independent Bell review are retained without edits +under `frozen/`. Other statements in those historical notes are context. +This package adopts only the two results stated above. + +## Replay + +Use Python 3.10 or later with NumPy. The source check uses exact rational +and integer arithmetic. No Git checkout, source archive download, or +network service is needed at runtime. Use a new output directory. + +```sh +env OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python3 -I -B replay.py --out /tmp/centre-polynomial-cache-check +``` + +Expected final line: + +```text +PASS_CENTRE_POLYNOMIAL_CACHE_LIMITS +``` + +The replay checks every frozen source digest. It runs the retained Bell +producer and the separate sparse-operator reviewer. Their receipts must +equal the retained receipts byte for byte. The reviewer derives the query +matrix from the original scalar word, checks 57,344 Bell columns, reproduces +all 817 moments, and uses separate determinant arithmetic. The producer +rejects a duplicate row. The reviewer rejects a duplicate column. + +The scalar-cache check uses rational elimination. It checks both dimension +sequences and the 512-character rank histogram. It also checks an explicit +fiber row basis and rejects a basis with one necessary row removed. The +written proof supplies the general theorem. A finite check does not prove +the general theorem by itself. + +No full supplier, native decoder, selected frontier, or outer kappa replay +is part of this check. No human review or formal-kernel proof is claimed. + +## Open next questions + +- Does the historical Gram have minimal-polynomial degree exactly 409? + The first step is to find and check an annihilating polynomial for the + full operator. The present certificate proves only a lower bound from + one invariant block. No annihilator is supplied here. +- Can the 56-row scalar cache be loaded, updated, and cleared within a + useful native bill? The first step is to specify the physical source + access and helper contract. The current row-space theorem does not + supply those operations or their cost. + +These questions are outside this package. This replay does not perform +either proposed investigation. diff --git a/research/centre-polynomial-cache-limits/SOURCES.json b/research/centre-polynomial-cache-limits/SOURCES.json new file mode 100644 index 0000000000..212008b21c --- /dev/null +++ b/research/centre-polynomial-cache-limits/SOURCES.json @@ -0,0 +1,116 @@ +{ + "historical_source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "historical_selected_archive": { + "path": "research/community-frontier1042-audit/selected-replay.tar.gz", + "sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754" + }, + "files": [ + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md", + "source_path": "work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md", + "bytes": 4001, + "sha256": "bc3a72690735230e8d9995df1a343f69fe8afed7dce056a82505efc83a884698" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md", + "source_path": "work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md", + "bytes": 1058, + "sha256": "d1d3011e26d5768edc10ac234aeb9cb80c721addc28f9aabc784f56383ca4fe3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json", + "source_path": "work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json", + "bytes": 10174, + "sha256": "4b198523d498b85b96445681fdcd8020402b1abb31c6a27e7d2a45d5df2217e2" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py", + "source_path": "work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py", + "bytes": 5140, + "sha256": "8604d1665862593efc146644fbf47a85c4a2aca88106284096d723853a064e45" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md", + "source_path": "work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md", + "bytes": 3113, + "sha256": "3a670ff14be1db7109d12d1fc6c28704543d3a19ad2e9d4ac6431a0a86a57d9f" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json", + "source_path": "work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json", + "bytes": 1996, + "sha256": "4f48be6cfd0f7ab316d1dc957ba18668b56a4feed55ef8cae5c205560e13b16a" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py", + "source_path": "work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py", + "bytes": 9719, + "sha256": "0d9983c288292f568c1f1595b944ca81131f79119855b7ad5c64e28c3cbfd899" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py", + "source_path": "work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py", + "bytes": 8966, + "sha256": "33b6b73303275e481f12cc2f946d1273ca9ac03d9294600016f03e84e6921088" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json", + "source_path": "work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json", + "bytes": 23232, + "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md", + "source_path": "work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md", + "bytes": 7975, + "sha256": "bd53f0c38ac06e20b8361543086bb5f6310bdeb552fb692dc29978434cd4dc84" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz", + "source_path": "work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz", + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz", + "source_path": "work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz", + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + { + "path": "notices/LICENSE", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "source_path": "LICENSE", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "notices/research/gauge44-slots-t16/NOTICE.md", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "source_path": "research/gauge44-slots-t16/NOTICE.md", + "bytes": 1964, + "sha256": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf" + }, + { + "path": "notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "source_path": "research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "bytes": 6406, + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610" + }, + { + "path": "notices/research/gauge44-slots-t16/t16/NOTICE.md", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "source_path": "research/gauge44-slots-t16/t16/NOTICE.md", + "bytes": 2245, + "sha256": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + { + "path": "notices/research/gauge44-slots-t16/construction/NOTICE.md", + "source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "source_path": "research/gauge44-slots-t16/construction/NOTICE.md", + "bytes": 950, + "sha256": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816" + } + ] +} diff --git a/research/centre-polynomial-cache-limits/check_phase_cache.py b/research/centre-polynomial-cache-limits/check_phase_cache.py new file mode 100644 index 0000000000..2d874f2065 --- /dev/null +++ b/research/centre-polynomial-cache-limits/check_phase_cache.py @@ -0,0 +1,121 @@ +"""Check the stated scalar-cache dimensions with rational arithmetic.""" + +import argparse +from collections import Counter, defaultdict +from fractions import Fraction +from hashlib import sha256 +import json +from pathlib import Path + + +PIN = "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" +NORMALS = [42, 7, 25, 52, 82, 127, 97, 76] + + +def require(condition, reason): + if not condition: + raise ValueError(reason) + + +def basis(rows): + """Return an echelon basis over Q.""" + pivots = {} + for source in rows: + row = list(map(Fraction, source)) + for column, pivot in sorted(pivots.items()): + factor = row[column] + if factor: + row = [a - factor * b for a, b in zip(row, pivot)] + column = next((i for i, value in enumerate(row) if value), None) + if column is not None: + factor = row[column] + pivots[column] = [value / factor for value in row] + return [row for _, row in sorted(pivots.items())] + + +def fibers(labels, directions): + groups = defaultdict(list) + for column, label in enumerate(labels): + key = tuple((label & direction).bit_count() % 2 for direction in directions) + groups[key].append(column) + return groups + + +def fiber_dimension(rows, labels, directions): + return sum(len(basis([[row[i] for i in group] for row in rows])) + for group in fibers(labels, directions).values()) + + +def main(args): + raw = args.interface.read_bytes() + require(sha256(raw).hexdigest() == PIN, "The interface digest must match") + data = json.loads(raw) + labels = data["ports"] + rows = [[int(row.get(str(i), 0)) for i in range(112)] for row in data["R"]] + require(len(rows) == 8 and len(labels) == len(set(labels)) == 112, + "The query must have eight rows and112 distinct columns") + normal_dimensions = [fiber_dimension(rows, labels, NORMALS[:k]) for k in range(9)] + coordinate_dimensions = [fiber_dimension(rows, labels, [1 << j for j in range(k)]) + for k in range(10)] + require(normal_dimensions == [8, 15, 28, 44, 44, 56, 56, 56, 56], + "The normal-character dimensions must match") + require(coordinate_dimensions == [8, 16, 31, 53, 85, 101, 112, 112, 112, 112], + "The coordinate-character dimensions must match") + histogram = Counter() + for direction in range(512): + signs = [1 - 2 * ((label & direction).bit_count() % 2) for label in labels] + phased = [[a * b for a, b in zip(row, signs)] for row in rows] + histogram[len(basis(rows + phased))] += 1 + require(histogram == {8: 2, 15: 16, 16: 494}, "The two-demand ranks must match") + + cache = [] + projected_rows = [] + fiber_sizes_and_ranks = [] + for group in fibers(labels, NORMALS).values(): + local_basis = basis([[row[i] for i in group] for row in rows]) + fiber_sizes_and_ranks.append([len(group), len(local_basis)]) + for local_row in local_basis: + row = [Fraction(0)] * 112 + for i, value in zip(group, local_row): + row[i] = value + cache.append(row) + for source in rows: + projected_rows.append([source[i] if i in group else 0 for i in range(112)]) + require(fiber_sizes_and_ranks == [[8, 4]] * 14, "The final fibers must have rank four") + require(len(basis(cache)) == 56 and len(basis(cache + rows)) == 56, + "The cache basis must be independent and contain the query rows") + for row in cache: + support = [i for i, value in enumerate(row) if value] + for direction in NORMALS: + signs = {1 - 2 * ((labels[i] & direction).bit_count() % 2) for i in support} + require(len(signs) == 1, "Each cache row must be an eigenvector for each update") + reduced = cache[1:] + require(len(basis(reduced)) == 55, "The reduced cache must have rank55") + rejected_projection = next((i for i, row in enumerate(projected_rows) + if len(basis(reduced + [row])) == 56), None) + require(rejected_projection is not None, "A required projection must fail in the reduced cache") + report = { + "status": "PASS_EXACT_MINIMAL_SCALAR_CACHE_COUNTS", + "interface_sha256": PIN, + "arithmetic": "fractions.Fraction over Q", + "normal_directions": NORMALS, + "normal_dimensions": normal_dimensions, + "coordinate_dimensions": coordinate_dimensions, + "stacked_rank_histogram": dict(sorted(histogram.items())), + "normal_fiber_sizes_and_ranks": fiber_sizes_and_ranks, + "explicit_cache_rank": 56, + "query_rows_in_cache": True, + "cache_invariant_under_all_normal_directions": True, + "removed_row_control_rejected": True, + "missing_projection_index": rejected_projection, + "scope": "Finite counts and a basis construction for the pinned query. The written proof gives the general theorem. No native cost or kappa claim.", + } + args.out.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(report["status"]) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--interface", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + main(parser.parse_args()) diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py new file mode 100644 index 0000000000..60111b7d6a --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py @@ -0,0 +1,226 @@ +"""Review the centre-free word by an exact transpose replay.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import gzip +import io +import json +import subprocess +import tarfile + +BASE = 'bce54fb3f895cbe5cd4c0eb477c3afeed100190f' +ARCHIVE = 'research/community-frontier1042-audit/selected-replay.tar.gz' +ARCHIVE_HASH = '22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754' +WORD_HASH = '4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c' +PROGRAM_HASH = '9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3' + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def load_source(repo): + proc = subprocess.Popen(['git', 'show', BASE + ':' + ARCHIVE], cwd=repo, stdout=subprocess.PIPE) + digest = sha256() + while chunk := proc.stdout.read(65536): + digest.update(chunk) + require(proc.wait() == 0 and digest.hexdigest() == ARCHIVE_HASH, 'archive pin') + proc = subprocess.Popen(['git', 'show', BASE + ':' + ARCHIVE], cwd=repo, stdout=subprocess.PIPE) + payload = {} + with tarfile.open(fileobj=proc.stdout, mode='r|gz') as archive: + for item in archive: + if item.name in ('slots/local/CANONICAL-WORD.json.gz', 'slots/local/LOCAL-PROGRAMS.json.gz'): + payload[item.name] = gzip.decompress(archive.extractfile(item).read()) + require(proc.wait() == 0, 'source extraction') + word_raw = payload['slots/local/CANONICAL-WORD.json.gz'] + program_raw = payload['slots/local/LOCAL-PROGRAMS.json.gz'] + require(sha256(word_raw).hexdigest() == WORD_HASH, 'word pin') + require(sha256(program_raw).hexdigest() == PROGRAM_HASH, 'program pin') + return json.loads(word_raw), program_raw + + +def index(register): + require(register[0] in ('L', 'C'), 'register kind') + return register[1] + (704 if register[0] == 'C' else 0) + + +def scalar(event): + gate = event[1] + tag, target = gate[0], index(gate[1]) + if tag == 'clear': + return tag, target, -1, Q(0) + if tag == 'scale': + return tag, target, -1, Q(gate[2], gate[3]) + require(tag in ('add', 'copy'), 'scalar kind') + return tag, target, index(gate[2]), Q(1) if tag == 'copy' else Q(gate[3], gate[4]) + + +def plus(target, source, scale): + for j, v in source.items(): + z = target.get(j, Q(0)) + scale*v + if z: + target[j] = z + else: + target.pop(j, None) + + +def transpose(program, size=712): + cols = [{i: Q(1)} for i in range(size)] + for tag, target, source, coef in reversed(program): + if tag == 'clear': + cols[target] = {} + elif tag == 'scale': + cols[target] = {j: coef*v for j, v in cols[target].items() if coef*v} + else: + plus(cols[source], cols[target], coef) + if tag == 'copy': + cols[target] = {} + return cols + + +def clean_rows(old, word): + prefix = [scalar(e) for e in old[:old.index(['phase', 'centers'])] if e[0] == 'scalar'] + rows = [] + for centre in word['centers']: + row = {centre: Q(1)} + for tag, target, source, coef in reversed(prefix): + x = row.get(target, Q(0)) + if tag == 'clear': + row.pop(target, None) + elif tag == 'scale': + if coef*x: + row[target] = coef*x + else: + row.pop(target, None) + else: + value = row.get(source, Q(0)) + coef*x + if value: + row[source] = value + else: + row.pop(source, None) + if tag == 'copy': + row.pop(target, None) + rows.append([row.get(j, Q(0)) for j in range(112)]) + require([[sum(a*b for a, b in zip(r, s)) for s in rows] for r in rows] + == [[Q(56 if i == j else 0) for j in range(8)] for i in range(8)], 'independent R Gram') + return rows + + +def check_frames(events, word): + frames = word['start'].copy() + [None]*8 + live = set() + peak = 0 + for event in events: + if event[0] == 'center': + raise ValueError('a centre child remains') + if event[0] == 'climb': + require(frames[event[2]] == event[3], 'climb entry') + frames[event[2]] = event[4] + if event[0] != 'scalar': + continue + tag, target, source, coef = scalar(event) + frame = event[2] + if tag == 'clear': + frames[target] = frame + live.discard(target) + else: + require(frames[target] == frame, 'scalar target frame') + if source >= 0: + require(frames[source] == frame, 'scalar source frame') + if target >= 704: + live.add(target) + peak = max(peak, len(live)) + require(frames[:704] == word['final'], 'persistent final frames') + require(frames[704:] == [0]*8 and not live, 'private final frames and lifetime') + return peak + + +def one_vector(gates, source, omit): + state = [Q(0)]*712 + state[source] = Q(1) + for site, (tag, target, arg, coef) in enumerate(gates): + if site == omit: + continue + if tag == 'clear': + state[target] = Q(0) + elif tag == 'scale': + state[target] *= coef + elif tag == 'copy': + state[target] = state[arg] + else: + state[target] += coef*state[arg] + return state + + +def review(repo, changed, orientation): + word, raw = load_source(repo) + old = json.loads(raw)[orientation] + del raw + # Derive R from the selected forward word, regardless of the reviewed direction. + if orientation == 'forward': + R = clean_rows(old, word) + else: + _, raw = load_source(repo) + R = clean_rows(json.loads(raw)['forward'], word) + del raw + raw = gzip.decompress(changed.read_bytes()) + changed_hash = sha256(raw).hexdigest() + new = json.loads(raw)[orientation] + del raw + native = lambda events: [e for e in events if e[0] in ('climb', 'adapter', 'residual_adapter')] + old_native, new_native = native(old), native(new) + require(old_native == new_native, 'persistent native stream changed') + native_hash = sha256(json.dumps(new_native, separators=(',', ':')).encode()).hexdigest() + old_paid = Counter(e[5] for e in old if e[0] == 'climb') + old_paid.update(e[4] for e in old if e[0] == 'center') + new_paid = Counter(e[5] for e in new if e[0] == 'climb') + require(old_paid - new_paid == {8: 8} and not new_paid - old_paid, 'paid centre difference') + peak = check_frames(new, word) + require(peak == 1, 'private peak') + J = [[Q(i == j) - sum(r[i]*r[j] for r in R)/4 for j in range(112)] for i in range(112)] + gates = [scalar(e) for e in new if e[0] == 'scalar'] + del new, old, new_native, old_native, word + actual = transpose(gates) + for j, column in enumerate(actual): + expected = {j: Q(1)} if j < 704 else {} + if orientation == 'forward' and j < 112: + expected.update({112+i: J[i][j] for i in range(112) if J[i][j]}) + if orientation == 'backward' and 112 <= j < 224: + expected.update({i: -J[j-112][i] for i in range(112) if J[j-112][i]}) + require(column == expected, 'transpose column ' + str(j)) + first_clear = next(i for i, e in enumerate(gates) if e[:2] == ('clear', 704)) + bad_private = one_vector(gates, 704, first_clear) + require(any(bad_private[:704]), 'private clear control') + first_add = next(i for i in range(first_clear, len(gates)) if gates[i][0] == 'add') + source = gates[first_add][2] + correct = one_vector(gates, source, -1) + bad_add = one_vector(gates, source, first_add) + require(correct != bad_add, 'dirty correction control') + return { + 'status': 'PASS_INDEPENDENT_TRANSPOSE_CENTRE_FREE_INTERFACE', + 'orientation': orientation, + 'base': BASE, + 'archive_sha256': ARCHIVE_HASH, + 'changed_payload_sha256': changed_hash, + 'full_columns': 712, + 'full_rows': 712, + 'persistent_native_events': 5056, + 'persistent_native_stream_sha256': native_hash, + 'removed_paid_profile': {'8': 8}, + 'remaining_paid_profile': dict(sorted(new_paid.items())), + 'private_peak_live': peak, + 'negative_controls': ['omit first private clear', 'omit first dirty correction add'], + 'scope': 'Exact scalar and common-frame lift premises. No physical owner/controller or recursive supplier admission.', + } + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--repo', type=Path, required=True) + parser.add_argument('--changed', type=Path, required=True) + parser.add_argument('--orientation', choices=('forward', 'backward'), required=True) + args = parser.parse_args() + print(json.dumps(review(args.repo, args.changed, args.orientation), indent=2)) diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json new file mode 100644 index 0000000000..4201e9a04c --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json @@ -0,0 +1,1441 @@ +{ + "D": [ + { + "0": "1/4", + "1": "1/4" + }, + { + "4": "1/4", + "7": "1/4" + }, + {}, + { + "4": "1/4", + "6": "-1/4" + }, + { + "5": "1/4", + "7": "1/4" + }, + { + "1": "1/4", + "3": "1/4" + }, + { + "1": "1/4", + "2": "1/4" + }, + { + "2": "1/4", + "3": "-1/4" + }, + { + "1": "1/4", + "3": "-1/4" + }, + {}, + { + "4": "1/4", + "5": "-1/4" + }, + {}, + { + "0": "1/4", + "2": "1/4" + }, + { + "2": "1/4", + "3": "1/4" + }, + {}, + { + "2": "1/4", + "3": "1/4" + }, + { + "2": "1/4", + "3": "-1/4" + }, + { + "0": "1/4", + "2": "-1/4" + }, + { + "0": "1/4", + "2": "-1/4" + }, + { + "5": "1/4", + "7": "-1/4" + }, + { + "4": "1/4", + "5": "-1/4" + }, + {}, + { + "0": "1/4", + "3": "-1/4" + }, + { + "5": "1/4", + "6": "1/4" + }, + { + "4": "1/4", + "7": "-1/4" + }, + {}, + { + "4": "1/4", + "6": "1/4" + }, + { + "2": "1/4", + "3": "1/4" + }, + { + "4": "1/4", + "7": "-1/4" + }, + { + "5": "1/4", + "6": "1/4" + }, + { + "1": "1/4", + "2": "-1/4" + }, + { + "4": "1/4", + "6": "1/4" + }, + { + "4": "1/4", + "7": "-1/4" + }, + { + "5": "1/4", + "6": "1/4" + }, + { + "0": "1/4", + "3": "1/4" + }, + { + "4": "1/4", + "7": "1/4" + }, + { + "4": "1/4", + "5": "1/4" + }, + {}, + { + "4": "1/4", + "6": "-1/4" + }, + { + "5": "1/4", + "7": "1/4" + }, + { + "0": "1/4", + "2": "-1/4" + }, + {}, + { + "2": "1/4", + "3": "-1/4" + }, + {}, + { + "6": "1/4", + "7": "-1/4" + }, + { + "0": "1/4", + "3": "-1/4" + }, + { + "6": "1/4", + "7": "-1/4" + }, + {}, + { + "0": "1/4", + "3": "1/4" + }, + { + "0": "1/4", + "3": "1/4" + }, + { + "5": "1/4", + "6": "-1/4" + }, + { + "6": "1/4", + "7": "1/4" + }, + {}, + { + "4": "1/4", + "5": "1/4" + }, + { + "0": "1/4", + "2": "1/4" + }, + { + "5": "1/4", + "7": "1/4" + }, + { + "4": "1/4", + "6": "-1/4" + }, + { + "0": "1/4", + "1": "-1/4" + }, + { + "1": "1/4", + "2": "-1/4" + }, + { + "1": "1/4", + "2": "-1/4" + }, + { + "5": "1/4", + "6": "-1/4" + }, + {}, + { + "0": "1/4", + "1": "-1/4" + }, + {}, + { + "1": "1/4", + "3": "-1/4" + }, + { + "5": "1/4", + "7": "1/4" + }, + { + "4": "1/4", + "6": "-1/4" + }, + { + "1": "1/4", + "3": "1/4" + }, + { + "1": "1/4", + "3": "1/4" + }, + { + "5": "1/4", + "7": "-1/4" + }, + { + "0": "1/4", + "1": "1/4" + }, + {}, + { + "0": "1/4", + "1": "1/4" + }, + { + "1": "1/4", + "2": "1/4" + }, + { + "5": "1/4", + "6": "1/4" + }, + { + "4": "1/4", + "7": "-1/4" + }, + {}, + { + "4": "1/4", + "6": "1/4" + }, + {}, + { + "6": "1/4", + "7": "-1/4" + }, + { + "1": "1/4", + "3": "1/4" + }, + {}, + { + "1": "1/4", + "2": "1/4" + }, + { + "1": "1/4", + "2": "1/4" + }, + { + "5": "1/4", + "6": "-1/4" + }, + { + "4": "1/4", + "7": "1/4" + }, + { + "4": "1/4", + "7": "1/4" + }, + {}, + { + "4": "1/4", + "6": "1/4" + }, + { + "6": "1/4", + "7": "1/4" + }, + {}, + { + "4": "1/4", + "5": "1/4" + }, + {}, + { + "1": "1/4", + "2": "-1/4" + }, + { + "0": "1/4", + "1": "-1/4" + }, + { + "1": "1/4", + "3": "-1/4" + }, + { + "1": "1/4", + "3": "-1/4" + }, + { + "5": "1/4", + "7": "-1/4" + }, + { + "0": "1/4", + "3": "1/4" + }, + {}, + { + "0": "1/4", + "2": "1/4" + }, + { + "0": "1/4", + "2": "1/4" + }, + { + "5": "1/4", + "7": "-1/4" + }, + { + "0": "1/4", + "2": "-1/4" + }, + {}, + { + "4": "1/4", + "5": "-1/4" + }, + {}, + { + "0": "1/4", + "3": "-1/4" + }, + { + "0": "1/4", + "3": "-1/4" + }, + { + "5": "1/4", + "6": "-1/4" + }, + {}, + { + "6": "1/4", + "7": "1/4" + } + ], + "H": [ + { + "225": "1", + "226": "-1", + "227": "2", + "229": "1", + "230": "1", + "233": "1", + "234": "-1", + "235": "2", + "237": "1", + "238": "1", + "240": "1", + "241": "1", + "242": "1", + "243": "2", + "245": "1", + "246": "1", + "249": "1", + "250": "-1", + "251": "2", + "253": "1", + "254": "1", + "256": "1", + "257": "1", + "258": "1", + "259": "2", + "261": "1", + "262": "1", + "265": "1", + "266": "-1", + "267": "2", + "269": "1", + "270": "1", + "272": "1", + "276": "1", + "280": "-1", + "283": "2", + "286": "1", + "287": "-2", + "288": "1", + "292": "1", + "296": "-1", + "299": "2", + "302": "1", + "303": "-2", + "304": "1", + "308": "1", + "312": "-1", + "315": "2", + "318": "1", + "319": "-2", + "320": "1", + "324": "1", + "331": "2", + "334": "1", + "335": "-1" + }, + { + "224": "2", + "225": "-1", + "226": "1", + "229": "1", + "230": "1", + "233": "-1", + "234": "-1", + "237": "-1", + "238": "1", + "239": "-2", + "240": "1", + "241": "-1", + "242": "1", + "245": "1", + "246": "1", + "249": "-1", + "250": "-1", + "253": "-1", + "254": "1", + "255": "-2", + "256": "1", + "257": "-1", + "258": "1", + "261": "1", + "262": "1", + "265": "-1", + "266": "-1", + "269": "-1", + "270": "1", + "271": "-2", + "336": "1", + "340": "1", + "347": "2", + "350": "1", + "351": "-1", + "352": "1", + "356": "1", + "363": "2", + "366": "1", + "367": "-1", + "368": "1", + "372": "1", + "379": "2", + "382": "1", + "383": "-1", + "384": "1", + "388": "1", + "395": "2", + "398": "1", + "399": "-1" + }, + { + "224": "2", + "225": "-1", + "226": "-1", + "227": "2", + "229": "-1", + "230": "-1", + "233": "1", + "234": "1", + "237": "-1", + "238": "-1", + "272": "1", + "276": "1", + "280": "-1", + "283": "-2", + "286": "1", + "287": "-2", + "288": "1", + "292": "1", + "296": "-1", + "299": "-2", + "302": "1", + "303": "-2", + "336": "1", + "340": "1", + "347": "-2", + "350": "1", + "351": "-1", + "352": "1", + "356": "1", + "363": "-2", + "366": "1", + "367": "-1", + "400": "1", + "401": "1", + "402": "-1", + "403": "2", + "405": "1", + "406": "1", + "409": "1", + "410": "-1", + "411": "2", + "413": "1", + "414": "1", + "416": "1", + "417": "1", + "418": "-1", + "419": "2", + "421": "1", + "422": "1", + "425": "1", + "426": "-1", + "427": "2", + "429": "1", + "430": "1" + }, + { + "225": "1", + "226": "-1", + "229": "1", + "230": "-1", + "233": "1", + "234": "1", + "235": "-2", + "237": "1", + "238": "1", + "239": "-2", + "304": "1", + "308": "1", + "312": "-1", + "315": "-2", + "318": "1", + "319": "-2", + "320": "1", + "324": "1", + "331": "-2", + "334": "1", + "335": "-1", + "368": "1", + "372": "1", + "379": "-2", + "382": "1", + "383": "-1", + "384": "1", + "388": "1", + "395": "-2", + "398": "1", + "399": "-1", + "400": "1", + "401": "-1", + "402": "1", + "405": "1", + "406": "1", + "409": "-1", + "410": "-1", + "413": "-1", + "414": "1", + "415": "-2", + "416": "1", + "417": "-1", + "418": "1", + "421": "1", + "422": "1", + "425": "-1", + "426": "-1", + "429": "-1", + "430": "1", + "431": "-2" + }, + { + "240": "1", + "241": "-1", + "242": "1", + "243": "2", + "245": "-1", + "246": "-1", + "249": "1", + "250": "1", + "253": "-1", + "254": "-1", + "272": "1", + "276": "-1", + "280": "-1", + "286": "-1", + "287": "-2", + "304": "1", + "308": "-1", + "312": "-1", + "318": "-1", + "319": "-2", + "336": "1", + "340": "-1", + "350": "-1", + "351": "-1", + "368": "1", + "372": "-1", + "382": "-1", + "383": "-1", + "400": "1", + "401": "-1", + "402": "-1", + "403": "2", + "405": "-1", + "406": "-1", + "409": "1", + "410": "1", + "413": "-1", + "414": "-1", + "433": "1", + "434": "-1", + "435": "2", + "437": "1", + "438": "1", + "441": "1", + "442": "-1", + "443": "2", + "445": "1", + "446": "1" + }, + { + "240": "1", + "241": "1", + "242": "-1", + "245": "1", + "246": "-1", + "249": "1", + "250": "1", + "251": "-2", + "253": "1", + "254": "1", + "255": "-2", + "288": "1", + "292": "-1", + "296": "-1", + "302": "-1", + "303": "-2", + "320": "1", + "324": "-1", + "334": "-1", + "335": "-1", + "352": "1", + "356": "-1", + "366": "-1", + "367": "-1", + "384": "1", + "388": "-1", + "398": "-1", + "399": "-1", + "400": "1", + "401": "1", + "402": "-1", + "405": "1", + "406": "-1", + "409": "1", + "410": "1", + "411": "-2", + "413": "1", + "414": "1", + "415": "-2", + "432": "2", + "433": "-1", + "434": "1", + "437": "1", + "438": "1", + "441": "-1", + "442": "-1", + "445": "-1", + "446": "1", + "447": "-2" + }, + { + "256": "1", + "257": "-1", + "258": "1", + "259": "2", + "261": "-1", + "262": "-1", + "265": "1", + "266": "1", + "269": "-1", + "270": "-1", + "272": "-1", + "276": "1", + "280": "1", + "286": "1", + "287": "-2", + "320": "-1", + "324": "1", + "334": "1", + "335": "-3", + "352": "-1", + "356": "1", + "366": "1", + "367": "-3", + "368": "-1", + "372": "1", + "382": "1", + "383": "-3", + "416": "1", + "417": "-1", + "418": "-1", + "419": "2", + "421": "-1", + "422": "-1", + "425": "1", + "426": "1", + "429": "-1", + "430": "-1", + "432": "2", + "433": "-1", + "434": "-1", + "435": "2", + "437": "-1", + "438": "-1", + "441": "1", + "442": "1", + "445": "-1", + "446": "-1" + }, + { + "256": "1", + "257": "1", + "258": "-1", + "261": "1", + "262": "-1", + "265": "1", + "266": "1", + "267": "-2", + "269": "1", + "270": "1", + "271": "-2", + "288": "-1", + "292": "1", + "296": "1", + "302": "1", + "303": "-2", + "304": "-1", + "308": "1", + "312": "1", + "318": "1", + "319": "-2", + "336": "-1", + "340": "1", + "350": "1", + "351": "-3", + "384": "-1", + "388": "1", + "398": "1", + "399": "-3", + "416": "1", + "417": "1", + "418": "-1", + "421": "1", + "422": "-1", + "425": "1", + "426": "1", + "427": "-2", + "429": "1", + "430": "1", + "431": "-2", + "433": "1", + "434": "-1", + "437": "1", + "438": "-1", + "441": "1", + "442": "1", + "443": "-2", + "445": "1", + "446": "1", + "447": "-2" + } + ], + "J_row_support_distribution": { + "52": 112 + }, + "R": [ + { + "0": "1", + "10": "1", + "100": "1", + "101": "1", + "102": "1", + "103": "1", + "107": "1", + "108": "1", + "109": "1", + "11": "1", + "12": "1", + "17": "1", + "18": "1", + "19": "1", + "2": "1", + "22": "1", + "23": "1", + "24": "1", + "25": "1", + "27": "1", + "31": "1", + "32": "1", + "33": "1", + "34": "1", + "35": "1", + "38": "1", + "39": "1", + "40": "1", + "45": "1", + "48": "1", + "49": "1", + "50": "1", + "54": "1", + "55": "1", + "56": "1", + "57": "1", + "61": "1", + "62": "1", + "63": "1", + "7": "1", + "70": "1", + "71": "1", + "72": "1", + "76": "1", + "77": "1", + "79": "1", + "81": "1", + "85": "1", + "87": "1", + "89": "1", + "9": "1", + "90": "1", + "91": "1", + "92": "1", + "94": "1", + "98": "1" + }, + { + "0": "1", + "1": "1", + "10": "-1", + "11": "-1", + "2": "1", + "25": "1", + "26": "1", + "27": "1", + "28": "1", + "29": "1", + "3": "1", + "30": "1", + "4": "1", + "5": "1", + "57": "-1", + "58": "1", + "59": "1", + "6": "1", + "60": "1", + "61": "-1", + "62": "-1", + "63": "-1", + "64": "1", + "65": "1", + "66": "1", + "67": "1", + "68": "1", + "69": "1", + "7": "-1", + "70": "1", + "71": "1", + "72": "1", + "73": "1", + "74": "1", + "75": "1", + "76": "1", + "79": "-1", + "8": "1", + "80": "1", + "81": "-1", + "82": "1", + "83": "1", + "84": "1", + "86": "1", + "87": "1", + "88": "1", + "89": "1", + "9": "-1", + "90": "1", + "91": "1", + "92": "-1", + "93": "1", + "94": "-1", + "95": "1", + "96": "1", + "97": "1" + }, + { + "0": "1", + "1": "1", + "100": "1", + "101": "1", + "102": "1", + "103": "-1", + "104": "1", + "105": "1", + "106": "1", + "12": "1", + "13": "1", + "14": "1", + "15": "1", + "16": "1", + "17": "-1", + "18": "-1", + "19": "-1", + "27": "-1", + "28": "-1", + "29": "-1", + "30": "-1", + "31": "1", + "38": "-1", + "39": "-1", + "40": "-1", + "41": "1", + "42": "1", + "43": "1", + "44": "1", + "51": "1", + "52": "1", + "53": "1", + "54": "1", + "55": "1", + "56": "1", + "57": "1", + "58": "-1", + "59": "-1", + "6": "1", + "60": "-1", + "7": "-1", + "73": "1", + "74": "1", + "75": "1", + "76": "1", + "77": "-1", + "78": "1", + "81": "-1", + "82": "1", + "83": "1", + "84": "1", + "86": "-1", + "87": "-1", + "92": "1", + "93": "-1", + "99": "1" + }, + { + "0": "1", + "104": "-1", + "105": "-1", + "106": "-1", + "107": "-1", + "108": "-1", + "109": "-1", + "13": "1", + "14": "1", + "15": "1", + "16": "-1", + "22": "-1", + "23": "-1", + "24": "-1", + "26": "-1", + "27": "-1", + "3": "1", + "32": "1", + "33": "1", + "34": "1", + "35": "-1", + "4": "1", + "41": "-1", + "42": "-1", + "43": "-1", + "44": "-1", + "45": "-1", + "48": "1", + "49": "1", + "5": "1", + "50": "1", + "51": "1", + "52": "1", + "53": "1", + "57": "-1", + "64": "-1", + "65": "-1", + "66": "-1", + "67": "1", + "68": "1", + "69": "1", + "7": "1", + "76": "-1", + "78": "1", + "8": "-1", + "80": "1", + "81": "-1", + "85": "1", + "87": "1", + "88": "1", + "92": "1", + "95": "-1", + "96": "-1", + "97": "-1", + "98": "1", + "99": "1" + }, + { + "1": "-1", + "10": "-1", + "100": "1", + "103": "1", + "105": "-1", + "106": "-1", + "107": "1", + "11": "-1", + "110": "1", + "111": "1", + "12": "1", + "14": "1", + "15": "1", + "17": "1", + "20": "1", + "21": "1", + "24": "-1", + "26": "-1", + "28": "-1", + "3": "-1", + "31": "-1", + "32": "-1", + "35": "-1", + "36": "1", + "37": "1", + "38": "-1", + "41": "1", + "42": "1", + "45": "1", + "46": "1", + "47": "1", + "48": "1", + "52": "-1", + "53": "-1", + "56": "-1", + "58": "1", + "6": "1", + "62": "1", + "63": "1", + "66": "-1", + "67": "1", + "70": "1", + "71": "1", + "75": "-1", + "77": "-1", + "8": "1", + "80": "1", + "82": "1", + "85": "-1", + "86": "-1", + "88": "-1", + "90": "-1", + "91": "-1", + "93": "1", + "95": "1", + "98": "1" + }, + { + "10": "1", + "101": "1", + "102": "-1", + "105": "1", + "106": "-1", + "108": "1", + "109": "-1", + "11": "-1", + "110": "-1", + "111": "1", + "14": "-1", + "15": "1", + "18": "1", + "19": "-1", + "20": "-1", + "21": "1", + "22": "1", + "23": "-1", + "29": "-1", + "30": "1", + "33": "-1", + "34": "1", + "36": "1", + "37": "-1", + "39": "-1", + "4": "-1", + "40": "1", + "41": "1", + "42": "-1", + "46": "-1", + "47": "1", + "49": "1", + "5": "1", + "50": "-1", + "52": "1", + "53": "-1", + "54": "1", + "55": "-1", + "59": "1", + "60": "-1", + "62": "-1", + "63": "1", + "64": "1", + "65": "-1", + "68": "1", + "69": "-1", + "70": "1", + "71": "-1", + "73": "1", + "74": "-1", + "83": "1", + "84": "-1", + "90": "1", + "91": "-1", + "96": "1", + "97": "-1" + }, + { + "100": "-1", + "103": "1", + "104": "-1", + "108": "1", + "109": "1", + "110": "-1", + "111": "-1", + "12": "1", + "13": "1", + "16": "1", + "17": "-1", + "2": "1", + "20": "1", + "21": "1", + "22": "-1", + "23": "-1", + "25": "-1", + "26": "-1", + "29": "-1", + "3": "1", + "30": "-1", + "31": "-1", + "33": "-1", + "34": "-1", + "36": "1", + "37": "1", + "38": "1", + "43": "1", + "44": "-1", + "46": "-1", + "47": "-1", + "49": "1", + "50": "1", + "51": "-1", + "56": "1", + "59": "1", + "60": "1", + "61": "1", + "66": "1", + "67": "-1", + "72": "1", + "73": "-1", + "74": "-1", + "77": "-1", + "78": "1", + "79": "-1", + "8": "1", + "80": "1", + "83": "1", + "84": "1", + "88": "-1", + "89": "-1", + "9": "-1", + "94": "1", + "95": "-1", + "99": "-1" + }, + { + "1": "-1", + "101": "1", + "102": "1", + "104": "-1", + "107": "-1", + "110": "-1", + "111": "-1", + "13": "1", + "16": "-1", + "18": "1", + "19": "1", + "2": "-1", + "20": "-1", + "21": "-1", + "24": "1", + "25": "1", + "28": "1", + "32": "1", + "35": "-1", + "36": "1", + "37": "1", + "39": "-1", + "4": "-1", + "40": "-1", + "43": "1", + "44": "1", + "45": "1", + "46": "1", + "47": "1", + "48": "-1", + "5": "-1", + "51": "-1", + "54": "-1", + "55": "-1", + "58": "-1", + "6": "1", + "61": "1", + "64": "-1", + "65": "-1", + "68": "1", + "69": "1", + "72": "1", + "75": "1", + "78": "-1", + "79": "1", + "82": "-1", + "85": "-1", + "86": "-1", + "89": "-1", + "9": "-1", + "93": "1", + "94": "-1", + "96": "1", + "97": "1", + "98": "1", + "99": "1" + } + ], + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "base": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "centre_removed_paid_rank": 64, + "column_support_distribution": { + "4": 112 + }, + "corrected_map_backward": "(x,y,h,c) -> (x-J^T y,y,h,0)", + "corrected_map_forward": "(x,y,h,c) -> (x,y+Jx,h,0)", + "corrected_program_checks": { + "backward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198814, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + }, + "forward": { + "all_scalar_frame_access_checked": true, + "first_correction_add_omission_rejected": true, + "initial_private_clear_omission_rejected": true, + "old_primitive_bound_real_components": 198766, + "prefix_add": 580, + "prefix_clear": 16, + "primitive_bound_real_components": 202138, + "scalar_macros": 20089, + "unchanged_persistent_native_events": 5056 + } + }, + "corrected_program_payload_sha256": "fa60b4af013dd8b8db289845e3ed597720ff955751ad270c3d58236b64080877", + "dirty_correction_site": "After entry adapters and before A; targets and all helpers in H have canonical frame zero.", + "full_input_columns": 712, + "full_output_rows": 712, + "identities": [ + "R R^T = 56 I8", + "P = R^T R/4", + "P^2 = 14 P", + "J = I112-P", + "J^2+12J-13I112=0", + "J^-1 = (12I112+J)/13" + ], + "map": "(x,y,h,c) -> (x, y + J x - R^T H h/4, h, 0)", + "not_claimed": [ + "Native centre-free supplier admission", + "Free endpoint J^-1", + "Changed global controller", + "Kappa improvement" + ], + "ports": [ + 11, + 19, + 35, + 67, + 131, + 259, + 13, + 21, + 37, + 69, + 133, + 261, + 41, + 73, + 137, + 265, + 49, + 81, + 145, + 273, + 161, + 289, + 193, + 321, + 385, + 14, + 22, + 38, + 70, + 134, + 262, + 26, + 74, + 138, + 266, + 50, + 146, + 274, + 98, + 162, + 290, + 194, + 322, + 386, + 28, + 44, + 140, + 268, + 84, + 148, + 276, + 100, + 164, + 292, + 196, + 324, + 388, + 56, + 88, + 152, + 280, + 104, + 168, + 296, + 200, + 328, + 392, + 112, + 176, + 304, + 208, + 336, + 400, + 224, + 352, + 416, + 448, + 508, + 506, + 502, + 494, + 478, + 446, + 382, + 254, + 505, + 501, + 493, + 477, + 445, + 381, + 253, + 499, + 491, + 475, + 443, + 379, + 251, + 487, + 471, + 439, + 375, + 247, + 463, + 431, + 367, + 239, + 415, + 351, + 223, + 319, + 191 + ], + "program_sha256": "9f41d53659e9be84e20c661560c5687abbf5cd0660cdecbe01ad5eb29e6b8ee3", + "scope": "Exact scalar interface only. Native endpoint mixing and a changed controller are not admitted.", + "status": "PASS_CENTRE_FREE_SCALAR_INTERFACE", + "target_endpoint": "T_q = F C_q^-1; distinct q have distinct frames", + "word_sha256": "4ddb29fb9bc6f27e0c0fbfcf19a2a93a3496ad900d0f6d89059d0305c9576c0c" +} diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md new file mode 100644 index 0000000000..6e4dd3f8b3 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md @@ -0,0 +1,79 @@ +# A scalar-polynomial limit for the actual doubled centre Gram + +For every positive tensor size, the actual 112-port doubled centre Gram +has no annihilating scalar polynomial of degree less than 409. This +result rules out a short +polynomial identity for that operator. It does not bound the cost of +general weighted ADD circuits, matrix-valued encodings, or native +decoders. + +The source is `circuit-interface/INTERFACE.json`, SHA-256 +`5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3`. +It gives the actual eight-by-112 matrix R and its port labels. No eight +normal columns are added. In particular, `RR^T=56I`. + +The exact Bell action was proved in +`residual-syndrome/physical-algebra/review-gauss/bell-compression/BELL-COMPRESSION.md`. +For one doubled tensor copy, the invariant Bell label is `c=a+b`. +On the a coordinate of the block with fixed c, the involution at port q +is `P_q(c)=X_q` when `q dot c=1` and `P_q(c)=Z_q` otherwise. Thus the +centre Gram on this block is the 4,096-dimensional rational matrix + + A_c = (1/4) sum_(q in the actual112 ports) r_q r_q^T P_q(c). + +Choose `c=11` and the prime `p=65537`. The entries of A lie in +`Z[1/2]`, so reduction modulo p is defined. The vectors v and w are +integer vectors. Their 4,096 entries are the little-endian unsigned +16-bit words of 8,192 SHAKE256 bytes, from the UTF-8 seeds +`actual-bell-gram-c11-trial0` and +`actual-bell-gram-c11-trial0-observer`, respectively. Reshape them as +eight rows of 512 entries. + +Form moments `s_j=w^T A_c^j v` and the 409-by-409 Hankel matrix +`H[i,j]=s_(i+j)` for indices from zero through 408. The exact modular +calculation gives + + det(H) = 2984 modulo65537. + +In particular, the determinant is nonzero over Q. It follows that +`v,A_c v,...,A_c^408 v` are linearly independent: any dependence among +them would give the same dependence among the columns of H. Therefore +the minimal polynomial of A_c over Q has degree at least 409. + +The full doubled centre operator contains this invariant block. There +is also an exact embedding at every positive tensor size lambda. In +Bell coordinates the vector `e_(a=0,b=0)` is a common positive-one +eigenvector of every `Gamma_q`. Restrict + + A_lambda=(1/4) sum_q r_q r_q^T Gamma_q^tensor(lambda) + +to the first `c=11` block tensored with `e_0^tensor(lambda-1)`. The +restriction is exactly `A_1,c=11`; the root coefficient is applied once, +not once per tensor slot. Thus every individual positive tensor size +has minimal-polynomial degree at least 409. This also rules out a +lower-degree polynomial identity proposed uniformly for all sizes. +Scalar extension to the Gaussian rationals or complex numbers does not +remove a nonzero rational determinant. + +`certify_bell_gram_degree.py` reproduces the 817 moments and the +determinant. It uses signed integer root coefficients and exact modular +arithmetic. All vector and matrix products fit in signed 64-bit integers +before reduction. The moment list and its SHA-256 are in +`BELL-GRAM-DEGREE.json`; the hash is +`a438880f142ea5c0a53120246fa5aed60c36db1d8052c911b485345fcb332150`. +A duplicate-row negative control must fail the same determinant check. +The certificate does not use a guessed recurrence or a characteristic +polynomial. Independent review passed in +`interface-proof/BELL-GRAM-DEGREE-REVIEW.json`. It derived R from the +original word, built the integer sparse operator `4A`, checked all +57,344 Bell monomial columns and all 817 moments, and used a separate +fraction-free Bareiss determinant calculation. A duplicate-column +control gave zero. The reviewer also supplied the invariant-subspace +extension to every positive tensor size. + +The earlier degree-39 experiment concerned a different operator: the +paired single-Walsh construction. It cannot be transferred to this +doubled Bell representation. Conversely, this lower bound does not +invalidate that experiment or rule out a direct circuit for the weighted +sum. It narrows the short scalar-polynomial approach only. This work +used AI assistance. diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json new file mode 100644 index 0000000000..1ad1e82b79 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json @@ -0,0 +1,842 @@ +{ + "arithmetic_bound": "Every int64 product is below2^33 and every moment sum is below2^45; all reductions are exact.", + "bell_action": "P_q(c)=X_q if parity(q&c)=1, else Z_q", + "bell_constant": 11, + "dependent_row_control_rejected": true, + "elimination_row_swaps": 0, + "field_prime": 65537, + "hankel_definition": "H[i,j]=observer^T A_c^(i+j) initial, 0<=i,j<409", + "hankel_determinant_mod_prime": 2984, + "hankel_size": 409, + "initial_seed": "actual-bell-gram-c11-trial0", + "moments": [ + 39521, + 17040, + 32464, + 26822, + 6432, + 30693, + 16772, + 58508, + 45969, + 8328, + 43232, + 11880, + 33457, + 12710, + 36758, + 55991, + 36910, + 11260, + 3118, + 10376, + 26507, + 10332, + 18756, + 13167, + 1957, + 44953, + 11405, + 62864, + 60292, + 43817, + 48107, + 49864, + 42493, + 38541, + 47382, + 37634, + 20391, + 48955, + 44255, + 9520, + 4435, + 45657, + 46486, + 33632, + 32642, + 61465, + 54472, + 55786, + 10923, + 25169, + 32754, + 11386, + 2910, + 17592, + 53455, + 54624, + 64267, + 8403, + 29668, + 29961, + 1582, + 34719, + 22182, + 22276, + 14341, + 64557, + 23518, + 13471, + 63651, + 36975, + 37499, + 2458, + 19555, + 25569, + 51938, + 48677, + 46877, + 59429, + 62716, + 56220, + 39667, + 22162, + 56159, + 32487, + 62451, + 63590, + 34340, + 21151, + 1842, + 51520, + 15702, + 47474, + 62723, + 10270, + 45099, + 31337, + 55700, + 8459, + 56304, + 35783, + 23017, + 41422, + 15821, + 22314, + 17250, + 16103, + 64088, + 24754, + 40648, + 53575, + 15178, + 18894, + 48892, + 27097, + 43909, + 22972, + 65157, + 51595, + 46724, + 30279, + 9717, + 33773, + 44840, + 23456, + 1385, + 46100, + 28528, + 28833, + 49434, + 7008, + 55031, + 56046, + 17579, + 56478, + 58210, + 57252, + 62945, + 24626, + 6849, + 26336, + 25390, + 33864, + 7513, + 282, + 34489, + 9771, + 25586, + 62803, + 36664, + 49276, + 48464, + 5296, + 24823, + 15450, + 13615, + 31654, + 42064, + 10255, + 51909, + 64953, + 48396, + 57536, + 10528, + 7424, + 15855, + 52505, + 57832, + 58738, + 37173, + 1148, + 9608, + 43311, + 35945, + 33344, + 28139, + 11413, + 61554, + 53553, + 6275, + 33986, + 22113, + 25984, + 31099, + 53392, + 34985, + 42432, + 40834, + 6356, + 60513, + 22740, + 16964, + 39256, + 49188, + 59016, + 22747, + 61300, + 9407, + 64222, + 53914, + 35115, + 6402, + 18469, + 42992, + 52765, + 60831, + 50026, + 26588, + 51777, + 43946, + 24221, + 17123, + 64076, + 54109, + 9895, + 30163, + 6472, + 8007, + 30900, + 35536, + 62828, + 25243, + 11799, + 28606, + 8177, + 37989, + 29158, + 31536, + 46645, + 56966, + 42141, + 58347, + 1558, + 17658, + 42138, + 61085, + 15896, + 52133, + 56816, + 5022, + 21787, + 40403, + 11838, + 57057, + 38936, + 65482, + 1025, + 1953, + 24819, + 47770, + 8434, + 59138, + 23417, + 38384, + 13029, + 61793, + 30479, + 3185, + 64285, + 65211, + 61527, + 39415, + 31175, + 30238, + 47290, + 8280, + 3333, + 800, + 2684, + 24721, + 59760, + 45178, + 54730, + 63766, + 19941, + 25503, + 34896, + 36400, + 48800, + 51053, + 46971, + 42422, + 14970, + 4030, + 14834, + 19086, + 48993, + 17934, + 45514, + 43869, + 19373, + 42181, + 54858, + 7136, + 58983, + 6433, + 53432, + 13460, + 7294, + 18212, + 43020, + 51540, + 46474, + 21567, + 63224, + 52362, + 57601, + 22028, + 45547, + 33155, + 27661, + 33917, + 34577, + 17893, + 12565, + 41087, + 63362, + 56177, + 59357, + 43036, + 55690, + 58593, + 15503, + 56726, + 35655, + 62529, + 3719, + 57083, + 27525, + 1438, + 33421, + 6832, + 47411, + 16141, + 16467, + 33901, + 17988, + 29299, + 11055, + 37730, + 39315, + 45608, + 43857, + 64913, + 12839, + 51638, + 40317, + 50216, + 31786, + 11362, + 28001, + 45237, + 40851, + 1947, + 48567, + 58375, + 24863, + 55984, + 30426, + 29524, + 16916, + 44295, + 11532, + 6398, + 53297, + 37122, + 43588, + 22981, + 53452, + 6546, + 21445, + 43375, + 61137, + 32566, + 26303, + 58901, + 43603, + 51633, + 63613, + 19499, + 45528, + 40834, + 16332, + 33898, + 52335, + 8867, + 13616, + 48325, + 20275, + 47068, + 11564, + 29878, + 44677, + 60046, + 27356, + 10155, + 12905, + 64293, + 46343, + 35404, + 1989, + 31547, + 56880, + 30091, + 40379, + 5539, + 32540, + 56096, + 40383, + 47746, + 59124, + 48686, + 48265, + 669, + 10840, + 48300, + 3677, + 33653, + 17094, + 47859, + 64761, + 56879, + 4257, + 48516, + 1873, + 64194, + 62041, + 31728, + 4603, + 16705, + 42422, + 44848, + 48548, + 19287, + 44089, + 37986, + 26279, + 21527, + 56068, + 39728, + 55487, + 63735, + 59830, + 61131, + 59778, + 42907, + 58565, + 11227, + 58962, + 54374, + 30014, + 8589, + 35979, + 22619, + 24907, + 27806, + 44349, + 1843, + 24399, + 43688, + 30444, + 9126, + 1329, + 51979, + 554, + 52818, + 21352, + 42891, + 19596, + 10531, + 31283, + 43885, + 3473, + 43182, + 34373, + 1144, + 17194, + 9151, + 7178, + 17703, + 721, + 62730, + 34913, + 49331, + 11526, + 31348, + 473, + 29793, + 21626, + 19399, + 9588, + 31068, + 28280, + 61396, + 46738, + 38738, + 8598, + 4139, + 37136, + 11489, + 5392, + 59161, + 8004, + 904, + 9543, + 38471, + 48335, + 49348, + 33233, + 39574, + 39161, + 18367, + 41774, + 21645, + 32862, + 794, + 59975, + 9859, + 54443, + 19651, + 41197, + 42807, + 37643, + 1065, + 9796, + 56760, + 61574, + 12326, + 64858, + 34999, + 61675, + 41226, + 44409, + 38068, + 38980, + 47241, + 55814, + 51635, + 2849, + 42654, + 26595, + 14437, + 2756, + 22715, + 32046, + 13972, + 20314, + 62768, + 30989, + 31619, + 46562, + 40545, + 47407, + 38405, + 21597, + 20846, + 4516, + 4203, + 14251, + 60879, + 55967, + 15690, + 50389, + 32109, + 61555, + 3819, + 44672, + 23558, + 38972, + 55381, + 28776, + 11907, + 23765, + 45254, + 37875, + 45022, + 17790, + 10295, + 60919, + 64276, + 49329, + 17879, + 29626, + 13557, + 50800, + 50678, + 52714, + 48293, + 64202, + 1180, + 318, + 64758, + 30898, + 62622, + 60336, + 17339, + 56413, + 36305, + 8376, + 12827, + 38766, + 22006, + 42109, + 16168, + 58695, + 31126, + 60102, + 2560, + 32839, + 25535, + 61952, + 11764, + 58991, + 2657, + 54795, + 63354, + 60701, + 9358, + 34813, + 51694, + 32042, + 23132, + 55076, + 2322, + 2346, + 41667, + 34793, + 34526, + 59694, + 39476, + 39152, + 3943, + 47130, + 5643, + 61719, + 54627, + 26401, + 44548, + 53227, + 56183, + 55044, + 13719, + 49077, + 51554, + 14484, + 9164, + 15321, + 54416, + 49188, + 63376, + 38441, + 30205, + 42117, + 58204, + 2827, + 26265, + 48508, + 60505, + 4406, + 18119, + 19003, + 24358, + 36115, + 3189, + 6502, + 47128, + 54940, + 8109, + 5104, + 10587, + 56762, + 56323, + 15799, + 10202, + 17352, + 25315, + 58931, + 18994, + 7216, + 47126, + 33091, + 37003, + 29749, + 49651, + 8026, + 18788, + 39682, + 39548, + 16197, + 39817, + 46028, + 53270, + 56755, + 16808, + 44598, + 27946, + 50059, + 6088, + 13698, + 56054, + 25293, + 43977, + 5806, + 17537, + 24518, + 42046, + 7079, + 4118, + 46243, + 28083, + 13428, + 29715, + 5398, + 39004, + 50367, + 63719, + 61175, + 9207, + 37864, + 31043, + 16638, + 34716, + 10244, + 7889, + 15726, + 29228, + 12528, + 42524, + 37102, + 5908, + 54356, + 31357, + 556, + 40676, + 171, + 45782, + 28402, + 54672, + 46921, + 39400, + 11351, + 62750, + 34027, + 16148, + 49006, + 46880, + 10368, + 44635, + 38941, + 49312, + 58810, + 6476, + 64669, + 8743, + 8372, + 60245, + 37622, + 28300, + 10847, + 60056, + 55885, + 45851, + 10856, + 5631, + 23235, + 60558, + 59666, + 33882, + 51209, + 63880, + 20000, + 3303, + 25888, + 20307, + 58346, + 20370, + 20463, + 50701, + 7884, + 10890, + 32419, + 30210, + 61345, + 50140, + 7940, + 58140, + 16901, + 49694, + 5912, + 36183, + 60119, + 46039, + 48553, + 29022, + 60143, + 49739, + 28836, + 37602, + 62831, + 60961, + 27350, + 65184, + 14724, + 47711, + 15039, + 38451, + 13311, + 42863, + 32892, + 47119, + 26618, + 15092, + 47819, + 42572, + 40574, + 6323, + 61149, + 48425 + ], + "moments_count": 817, + "moments_sha256": "a438880f142ea5c0a53120246fa5aed60c36db1d8052c911b485345fcb332150", + "observer_seed": "actual-bell-gram-c11-trial0-observer", + "operator": "A_c=(1/4) sum actual112 r_q r_q^T P_q(c)", + "operator_dimension": 4096, + "proved_minimal_polynomial_degree_lower_bound_over_Q": 409, + "scope": "One actual doubled-Walsh Bell block forces degree at least409 for any annihilating scalar polynomial in characteristic zero. This does not bound general weighted ADD circuits, matrix-valued encodings, or native decoder cost.", + "seed_expansion": "SHAKE2568192bytes, little-endian unsigned16, reshape8by512", + "source_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "status": "PASS_EXACT_CHARACTERISTIC_ZERO_GRAM_DEGREE_LOWER_BOUND", + "tensor_size": 1 +} diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md new file mode 100644 index 0000000000..2073e7ed71 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md @@ -0,0 +1,22 @@ +# A limit for scalar-polynomial inverse formulas + +`BELL-GRAM-DEGREE-PROOF.md` and its independent review prove that the +actual doubled centre Gram A_lambda has minimal-polynomial degree at +least 409 for every positive tensor size lambda. + +Let `aI+bA_lambda` be invertible over a characteristic-zero coefficient +field, with `b!=0`. If a scalar polynomial q satisfies + + q(A_lambda)=(aI+bA_lambda)^-1, + +then q has degree at least 408. Indeed, the nonzero polynomial +`(a+bt)q(t)-1` annihilates A_lambda. Its degree is at most `deg(q)+1`, +so the degree lower bound gives the claim. The polynomial is nonzero +because a nonconstant linear polynomial has no polynomial reciprocal. + +This result concerns exact scalar-polynomial representations only. It +does not rule out a rational expression, a factorized matrix-valued +encoding, an algorithm that uses native frame access, or a direct ADD +circuit for the weighted Gram. It does not assign a native cost to one +polynomial evaluation. The interface-proof lane supplied this corollary. +The work used AI assistance. diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py new file mode 100644 index 0000000000..a0b27474f8 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py @@ -0,0 +1,123 @@ +"""Certify a characteristic-zero Gram degree lower bound by one minor.""" + +from hashlib import sha256, shake_256 +from pathlib import Path +import argparse +import json +import numpy as np + + +PIN = '5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3' +PRIME = 65537 +CONSTANT = 11 +DEGREE = 409 + + +def require(condition, reason): + if not condition: + raise ValueError(reason) + + +def vector(seed): + data = shake_256(seed.encode()).digest(8192) + return np.frombuffer(data, dtype=' 0, 'Hankel minor has a nonzero pivot') + row = column+int(candidates[0]) + if row != column: + values[[row, column]] = values[[column, row]] + swaps += 1 + pivot = int(values[column, column]) + answer = answer*pivot % PRIME + normalized = values[column, column+1:]*pow(pivot, -1, PRIME) % PRIME + values[column+1:, column+1:] = ( + values[column+1:, column+1:] + - values[column+1:, column, None]*normalized[None, :]) % PRIME + values[column+1:, column] = 0 + return answer*(-1)**swaps % PRIME, swaps + + +def main(args): + raw = args.interface.read_bytes() + require(sha256(raw).hexdigest() == PIN, 'Actual supplier interface pin') + source = json.loads(raw) + R = np.zeros((8, 112), dtype=np.int64) + for k, row in enumerate(source['R']): + for port, value in row.items(): + R[k, int(port)] = int(value) + require(np.array_equal(R@R.T, 56*np.eye(8, dtype=np.int64)), 'Actual Gram normalization') + require(all(PRIME % d for d in range(2, 257)), 'Prime modulus') + inverse4 = pow(4, -1, PRIME) + addresses = np.arange(512, dtype=np.int64) + targets, signs = [], [] + for q in source['ports']: + translation = (q & CONSTANT).bit_count() % 2 + targets.append(addresses ^ (q if translation else 0)) + signs.append([1 if translation else 1-2*((q & a).bit_count() % 2) + for a in range(512)]) + targets = np.asarray(targets, dtype=np.int64) + signs = np.asarray(signs, dtype=np.int64) + + def apply(value): + lifted = (R.T@value) % PRIME + acted = np.take_along_axis(lifted, targets, axis=1)*signs + return ((R@acted) % PRIME)*inverse4 % PRIME + + seed = 'actual-bell-gram-c11-trial0' + initial = vector(seed) + observer = vector(seed+'-observer') + value = initial.copy() + moments = [] + for _ in range(2*DEGREE-1): + moments.append(int(np.sum(observer*value) % PRIME)) + value = apply(value) + hankel = np.asarray([[moments[i+j] for j in range(DEGREE)] + for i in range(DEGREE)], dtype=np.int64) + det, swaps = determinant(hankel) + require(det != 0, 'Nonzero exact Hankel determinant') + # A duplicate last row makes the same elimination detect dependence. + control = hankel.copy() + control[-1] = control[0] + try: + determinant(control) + except ValueError: + control_rejected = True + else: + control_rejected = False + require(control_rejected, 'Dependent-row control') + report = { + 'status': 'PASS_EXACT_CHARACTERISTIC_ZERO_GRAM_DEGREE_LOWER_BOUND', + 'source_sha256': PIN, 'field_prime': PRIME, 'bell_constant': CONSTANT, + 'operator': 'A_c=(1/4) sum actual112 r_q r_q^T P_q(c)', + 'bell_action': 'P_q(c)=X_q if parity(q&c)=1, else Z_q', + 'operator_dimension': 4096, 'tensor_size': 1, + 'initial_seed': seed, 'observer_seed': seed+'-observer', + 'seed_expansion': 'SHAKE2568192bytes, little-endian unsigned16, reshape8by512', + 'hankel_definition': 'H[i,j]=observer^T A_c^(i+j) initial, 0<=i,j<409', + 'hankel_size': DEGREE, 'hankel_determinant_mod_prime': det, + 'elimination_row_swaps': swaps, 'moments_count': len(moments), + 'moments': moments, + 'moments_sha256': sha256(json.dumps(moments).encode()).hexdigest(), + 'dependent_row_control_rejected': control_rejected, + 'proved_minimal_polynomial_degree_lower_bound_over_Q': DEGREE, + 'arithmetic_bound': 'Every int64 product is below2^33 and every moment sum is below2^45; all reductions are exact.', + 'scope': 'One actual doubled-Walsh Bell block forces degree at least409 for any annihilating scalar polynomial in characteristic zero. This does not bound general weighted ADD circuits, matrix-valued encodings, or native decoder cost.'} + args.out.write_text(json.dumps(report, indent=2, sort_keys=True)+'\n') + print(report['status']) + print(json.dumps({key: report[key] for key in ('hankel_size', 'hankel_determinant_mod_prime', + 'moments_sha256')}, sort_keys=True)) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--interface', type=Path, required=True) + parser.add_argument('--out', type=Path, required=True) + main(parser.parse_args()) diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json new file mode 100644 index 0000000000..ed21e91197 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json @@ -0,0 +1,33 @@ +{ + "all_positive_tensor_sizes": "Tensor the certified block with the common fixed Pauli-identity Bell vector in every remaining tensor block. The resulting invariant subspace carries the same4096-dimensional operator.", + "arithmetic": "Signed int64 only; row sums below2^24, moment sums below2^44, elimination products below2^33", + "bell_constant": 11, + "certificate_sha256": "4b198523d498b85b96445681fdcd8020402b1abb31c6a27e7d2a45d5df2217e2", + "determinant_method": "Fraction-free Bareiss elimination in the prime field", + "duplicated_column_control_rejected": true, + "exact_Bell_Pauli_columns": 57344, + "field_prime": 65537, + "hankel_determinant_mod_prime": 2984, + "hankel_size": 409, + "independent_operator": "Sparse coordinate matrix4A, built from original-word R", + "integer_operator_maximum_absolute_row_sum": 164, + "integer_operator_nonzero_entries": 499072, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "moments_count": 817, + "moments_sha256": "a438880f142ea5c0a53120246fa5aed60c36db1d8052c911b485345fcb332150", + "not_claimed": [ + "An exact minimal polynomial", + "A lower bound for general scalar ADD circuits", + "A native decoder cost bound", + "A lower bound for matrix-valued or multiple-state encodings" + ], + "original_source_pins": { + "CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + "proof": "A rational annihilator of degree below409 makes the rational Hankel minor singular. Its entries lie in Z[1/2], so its nonzero reduction modulo65537 proves it is nonzero overQ.", + "proved_minimal_polynomial_degree_lower_bound_over_Q": 409, + "scope": "The actual112-port weighted operator at every positive tensor size; the certificate uses its invariant k1 Bell blockc11", + "status": "PASS_INDEPENDENT_EXACT_BELL_GRAM_DEGREE_CERTIFICATE", + "tensor_size": 1 +} diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md new file mode 100644 index 0000000000..037b750c7a --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md @@ -0,0 +1,63 @@ +# Independent review of the Bell Gram degree bound + +The degree bound of 409 is proved for the actual 112-port weighted +operator at every positive tensor size. This is a scalar-polynomial +bound. It is not a lower bound for general weighted ADD circuits, +matrix-valued state, or native decoder cost. + +The reviewed proof is +`../history-encoding/BELL-GRAM-DEGREE-PROOF.md`, SHA-256 +`bc3a72690735230e8d9995df1a343f69fe8afed7dce056a82505efc83a884698`. +The exact producer certificate has SHA-256 +`4b198523d498b85b96445681fdcd8020402b1abb31c6a27e7d2a45d5df2217e2`. + +The independent checker derives R from the original local word through +the separate transpose review. It checks equality with the recorded +interface and its label order. It then builds the integer coordinate +matrix `4 A_11`. That matrix has 499,072 nonzero entries. Its largest +absolute row sum is at most 224. This construction does not use the +producer's factored application of R and its transpose. + +An exact four-term Pauli expansion checks all 57,344 Bell basis columns. +This binds both the invariant label and every sign. A separate check +shows that the Pauli identity is a common fixed vector of all 112 source +involutions. + +The independent sparse map reproduces all 817 moments. Fraction-free +Bareiss elimination gives the same determinant, 2984 modulo 65537. +A duplicate-column control gives determinant zero. The computations +use signed 64-bit integer arithmetic, with explicit bounds that prevent +overflow. The checker does not import the producer or its determinant +function. + +The rational Hankel determinant lies in `Z[1/2]`. Its nonzero reduction +modulo 65537 proves that it is nonzero over Q. A scalar annihilating +polynomial of degree below 409 would make the first 409 Krylov vectors, +and hence this Hankel matrix, dependent. The same nonzero minor remains +nonzero after scalar extension. + +For the all-size extension, tensor the certified `c=11` block with the +common fixed Bell vector in every other tensor block. This subspace is +invariant. The root coefficient is applied once, so the restricted +operator is the same `A_11`. It follows that the lower bound holds at +each positive tensor size, even if the proposed polynomial is allowed +to depend on that size. + +There is also a direct inverse corollary. If `a I+b A_lambda` is +invertible and b is nonzero, a scalar polynomial q with +`q(A_lambda)=(a I+b A_lambda)^-1` must have degree at least 408. +Otherwise `(a+b t)q(t)-1` is a nonzero annihilating polynomial of degree +below 409. This corollary concerns that polynomial representation only. +It does not assert that the inverse needs 408 general circuit gates. + +Run from the workspace root: + +```sh +env OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 work/autonomous-kappa-run/venv/bin/python -I -O -B work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py +``` + +The expected status is +`PASS_INDEPENDENT_EXACT_BELL_GRAM_DEGREE_CERTIFICATE`. +The deterministic receipt is `BELL-GRAM-DEGREE-REVIEW.json`. +This review and the all-size extension used OpenAI Codex assistance. +No independent human review is claimed. diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py new file mode 100644 index 0000000000..28654913e6 --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py @@ -0,0 +1,197 @@ +"""Review one exact Bell Gram degree certificate by a separate sparse map.""" + +from hashlib import sha256, shake_256 +from pathlib import Path +import gzip +import importlib.util +import json +import numpy as np + + +P = 65537 +N = 4096 + + +def require(condition, reason): + if not condition: + raise ValueError(reason) + + +def pauli_product(first, second): + x, z = first + y, w = second + return (x ^ y, z ^ w), 1-2*((z & y).bit_count() % 2) + + +def bareiss_mod(matrix): + """Use fraction-free elimination, with division in the prime field.""" + a = matrix.copy() + previous = 1 + sign = 1 + for k in range(len(a)-1): + if a[k, k] == 0: + rows = np.flatnonzero(a[k+1:, k]) + if not len(rows): + return 0 + row = k+1+int(rows[0]) + a[[k, row]] = a[[row, k]] + sign = -sign + pivot = int(a[k, k]) + a[k+1:, k+1:] = ((pivot*a[k+1:, k+1:] + - a[k+1:, k, None]*a[None, k, k+1:]) % P + * pow(previous, -1, P)) % P + a[k+1:, k] = 0 + previous = pivot + return sign*int(a[-1, -1]) % P + + +def main(): + here = Path(__file__).resolve().parent + lanes = here.parent + workspace = here.parents[3] + history = lanes/"history-encoding" + certificate_raw = (history/"BELL-GRAM-DEGREE.json").read_bytes() + certificate = json.loads(certificate_raw) + interface_raw = (lanes/"circuit-interface/INTERFACE.json").read_bytes() + require(sha256(interface_raw).hexdigest() == certificate["source_sha256"], + "The exact interface source is pinned") + interface = json.loads(interface_raw) + frozen = workspace/"work/five-pr-sprint-20261013/lanes/centre-sharing" + pinned = { + "CANONICAL-WORD.json.gz": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219", + "LOCAL-PROGRAMS.json.gz": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a", + } + source = {} + for name, pin in pinned.items(): + raw = (frozen/name).read_bytes() + require(sha256(raw).hexdigest() == pin, "The original word is pinned") + source[name] = json.loads(gzip.decompress(raw)) + spec = importlib.util.spec_from_file_location( + "independent_transpose", lanes/"bounds-review/review_centre_free.py") + scalar = importlib.util.module_from_spec(spec) + spec.loader.exec_module(scalar) + word = source["CANONICAL-WORD.json.gz"] + rows = scalar.clean_rows(source["LOCAL-PROGRAMS.json.gz"]["forward"], word) + R = np.asarray(rows, dtype=np.int64) + labels = word["ports"] + require(labels == interface["ports"], "The label order matches the original word") + given = np.asarray([[int(row.get(str(p), 0)) for p in range(112)] + for row in interface["R"]], dtype=np.int64) + require(np.array_equal(R, given), "The original word gives the recorded R") + require(np.array_equal(R@R.T, 56*np.eye(8, dtype=np.int64)), "R R^T=56 I") + require(all(P % d for d in range(2, 257)), "65537 is prime") + require(certificate["field_prime"] == P and certificate["bell_constant"] == 11, + "The selected field and Bell block are fixed") + c = 11 + # Expand H P H as four Pauli products. Its scalar is one half. + for q in labels: + require(q.bit_count() % 2 == 1, "Every source line is odd") + identity_image = {} + for left in ((q, 0), (0, q)): + for right in ((q, 0), (0, q)): + target, sign = pauli_product(left, right) + identity_image[target] = identity_image.get(target, 0)+sign + identity_image = {key: value for key, value in identity_image.items() if value} + require(identity_image == {(0, 0): 2}, "The Pauli identity is fixed by every port") + for a in range(512): + b = a ^ c + output = {} + for left in ((q, 0), (0, q)): + middle, first_sign = pauli_product(left, (b, a)) + for right in ((q, 0), (0, q)): + target, second_sign = pauli_product(middle, right) + output[target] = output.get(target, 0)+first_sign*second_sign + output = {key: value for key, value in output.items() if value} + odd = (q & c).bit_count() % 2 + target = (b ^ q, a ^ q) if odd else (b, a) + sign = 1 if odd else 1-2*((q & a).bit_count() % 2) + require(output == {target: 2*sign}, "The exact Bell action and sign") + + # Build the integer matrix 4 A from its coordinate entries, then + # combine equal entries. This does not use the producer's R-factor map. + addresses = np.arange(512, dtype=np.int64) + keys = np.empty(112*16*512, dtype=np.int64) + coefficients = np.empty(len(keys), dtype=np.int64) + offset = 0 + for port, q in enumerate(labels): + support = np.flatnonzero(R[:, port]) + require(len(support) == 4 and all(abs(int(R[k, port])) == 1 for k in support), + "Every R column has four signed unit entries") + odd = (q & c).bit_count() % 2 + targets = addresses ^ (q if odd else 0) + signs = np.ones(512, dtype=np.int64) if odd else np.asarray( + [1-2*((q & int(a)).bit_count() % 2) for a in addresses], dtype=np.int64) + for i in support: + for j in support: + keys[offset:offset+512] = (512*i+targets)*N+512*j+addresses + coefficients[offset:offset+512] = int(R[i, port]*R[j, port])*signs + offset += 512 + order = np.argsort(keys) + keys = keys[order] + coefficients = coefficients[order] + starts = np.flatnonzero(np.r_[True, keys[1:] != keys[:-1]]) + coefficients = np.add.reduceat(coefficients, starts) + keys = keys[starts] + keep = coefficients != 0 + keys, coefficients = keys[keep], coefficients[keep] + row, column = keys//N, keys % N + row_starts = np.flatnonzero(np.r_[True, row[1:] != row[:-1]]) + require(np.array_equal(row[row_starts], np.arange(N)), "All output rows are present") + max_row_sum = int(np.max(np.add.reduceat(abs(coefficients), row_starts))) + require(max_row_sum <= 224, "Each integer row has absolute sum at most224") + inverse4 = pow(4, -1, P) + + def seed_vector(seed): + data = shake_256(seed.encode()).digest(8192) + return np.asarray([int.from_bytes(data[k:k+2], "little") + for k in range(0, 8192, 2)], dtype=np.int64) + + initial = seed_vector(certificate["initial_seed"]) + observer = seed_vector(certificate["observer_seed"]) + value = initial.copy() + moments = [] + degree = certificate["hankel_size"] + require(degree == 409, "The claimed minor has order409") + for _ in range(2*degree-1): + moments.append(int(np.dot(observer, value) % P)) + value = (np.add.reduceat(coefficients*value[column], row_starts) % P)*inverse4 % P + require(moments == certificate["moments"], "All817 independent sparse moments agree") + moments_pin = sha256(json.dumps(moments).encode()).hexdigest() + require(moments_pin == certificate["moments_sha256"], "The moment digest agrees") + hankel = np.asarray([[moments[i+j] for j in range(degree)] + for i in range(degree)], dtype=np.int64) + determinant = bareiss_mod(hankel) + require(determinant == 2984 == certificate["hankel_determinant_mod_prime"], + "A separate fraction-free determinant agrees and is nonzero") + dependent = hankel.copy() + dependent[:, -1] = dependent[:, 0] + require(bareiss_mod(dependent) == 0, "The duplicated-column control is singular") + report = { + "status": "PASS_INDEPENDENT_EXACT_BELL_GRAM_DEGREE_CERTIFICATE", + "certificate_sha256": sha256(certificate_raw).hexdigest(), + "original_source_pins": pinned, + "interface_sha256": sha256(interface_raw).hexdigest(), + "independent_operator": "Sparse coordinate matrix4A, built from original-word R", + "integer_operator_nonzero_entries": len(keys), + "integer_operator_maximum_absolute_row_sum": max_row_sum, + "exact_Bell_Pauli_columns": 112*512, + "field_prime": P, "bell_constant": c, "tensor_size": 1, + "moments_count": len(moments), "moments_sha256": moments_pin, + "hankel_size": degree, "hankel_determinant_mod_prime": determinant, + "determinant_method": "Fraction-free Bareiss elimination in the prime field", + "duplicated_column_control_rejected": True, + "arithmetic": "Signed int64 only; row sums below2^24, moment sums below2^44, elimination products below2^33", + "proved_minimal_polynomial_degree_lower_bound_over_Q": degree, + "proof": "A rational annihilator of degree below409 makes the rational Hankel minor singular. Its entries lie in Z[1/2], so its nonzero reduction modulo65537 proves it is nonzero overQ.", + "all_positive_tensor_sizes": "Tensor the certified block with the common fixed Pauli-identity Bell vector in every remaining tensor block. The resulting invariant subspace carries the same4096-dimensional operator.", + "scope": "The actual112-port weighted operator at every positive tensor size; the certificate uses its invariant k1 Bell blockc11", + "not_claimed": ["An exact minimal polynomial", "A lower bound for general scalar ADD circuits", + "A native decoder cost bound", "A lower bound for matrix-valued or multiple-state encodings"], + } + (here/"BELL-GRAM-DEGREE-REVIEW.json").write_text(json.dumps(report, indent=2, sort_keys=True)+"\n") + print(report["status"]) + print(json.dumps({key: report[key] for key in ("integer_operator_nonzero_entries", "hankel_determinant_mod_prime")}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md new file mode 100644 index 0000000000..309377a52c --- /dev/null +++ b/research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md @@ -0,0 +1,71 @@ +# Exact phase cache and native tensor limits + +Status: a mathematical cache theorem and exact local calculations. There is no new native encoder, supplier, or kappa value. The theorem gives an encoder when the inputs already have one common coordinate representation. It does not pay to obtain that representation. + +## The minimum cache for specified diagonal updates + +Let R be a matrix over C, with one column per source. Let D_1,...,D_t be diagonal matrices. Partition the source columns into fibers F. Two columns have the same fiber if every D_j has the same diagonal entry at those columns. + +The smallest subspace E of source row vectors which contains row(R) and is closed under every D_j is + + E = direct_sum_F row(R restricted to F). + +Thus its dimension is + + dim(E) = sum_F rank(R restricted to F). + +This is both a lower bound and a construction. In each fiber, cache a basis of the rows of R restricted to that fiber. A diagonal update multiplies each such cache row by the corresponding fiber scalar. Add the fiber contributions to recover R. All these operations are scalar operations in the common representation. + +Proof. Every stated fiber space is invariant and their direct sum contains row(R). Conversely, choose a linear combination D of the D_j whose diagonal entries distinguish the finitely many fibers. Such a choice exists over C: each forbidden equality is one proper linear hyperplane in the coefficient space. Lagrange interpolation gives each fiber projector as a polynomial in D. Hence every invariant E that contains row(R) contains each row of R restricted to each fiber. These spaces have disjoint supports. Their dimensions add. This proves minimality and the stated encoder. + +For sign characters D_s[p,p]=(-1)^(q_p dot s), the fibers are the values of q_p on span(s). The same theorem applies to inverse-C eigenvalues, since 1 and i are a nonconstant affine function of the sign character. Tensor products introduce products of these eigenvalues; a cache that is invariant under the generators is invariant under all those products. + +This theorem concerns exact linear scalar caches. It permits redundant rows and arbitrary diagonal eigenvalues. It does not claim a lower bound on a native encoder whose input maps have source-dependent address operators. + +## Binding to the selected clean centre matrix + +The source pin is bce54fb3f895cbe5cd4c0eb477c3afeed100190f. The input archive is research/community-frontier1042-audit/selected-replay.tar.gz, SHA-256 22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754. The full native map and its frame convention are derived in the earlier centre-sharing handoff. This lane uses the same forward boundary R. + +Exact calculations give R R^T = 56 I_8. Each of the 112 columns has four nonzero entries, each 1 or -1. Their supports form fourteen tetrads. Each tetrad contains eight columns and has row rank four. The eight centre-frame normal vectors are + + 42, 7, 25, 52, 82, 127, 97, 76. + +They span a binary space N of dimension four. Two ports have the same values against N if and only if their R columns have the same tetrad support. The exact minimum cache closed under these sixteen sign characters therefore has 14*4 = 56 rows. For the listed order of normals, the successive cache dimensions are + + 8, 15, 28, 44, 44, 56, 56, 56, 56. + +For the first d coordinate characters, the dimensions are + + 8, 16, 31, 53, 85, 101, 112, 112, 112, 112. + +The latter sequence proves that six particular independent character directions already force all 112 source rows in this cache model. In particular, the 56-row cache is not closed under the full native source phase family. + +Within each tetrad, choose its first nonzero coordinate as sign reference. The other three signs form all of F_2^3. The source label q is an affine function of those three sign bits. Its eight labels form an affine three-flat which does not contain zero. Their linear span has dimension four. These facts give a compact cube model for a possible joint native encoder. They do not give such an encoder by themselves. + +## Why the eight totals cannot receive a nonconstant phase update alone + +Let W = row(R). The orthogonal projector on W is P=R^T R/56. Form a graph on the 112 columns, joining p and q when their inner product is nonzero. The graph is connected; each vertex has 52 neighbors. + +If a diagonal complex matrix D preserves W, then it commutes with P. Indeed, the spectral projections of a diagonal matrix are polynomials in D. W is invariant under them, so W is a direct sum of its intersections with their orthogonal coordinate subspaces. Therefore W is reducing for D. For each nonzero P[p,q], commutation gives D[p,p]=D[q,q]. Connectivity forces D to be scalar. + +Consequently an exact update B R = R D on only the eight totals exists only when D is scalar. This statement permits arbitrary complex 8-by-8 B; it does not assume that B is unitary or diagonal. For native sign characters the only scalar cases are s=0 and s=511, because the 112 labels are odd and their differences span the even-parity hyperplane. The finite ranks are eight for those two characters, fifteen for sixteen characters, and sixteen for the remaining 494. + +This excludes a proposed eight-register phase update. It does not exclude a larger cache, rereads, or a source-dependent native encoder. + +## A tensor test for proposed native identities + +Let A_1,...,A_r be nonzero pairwise nonproportional matrices over C. Their tensor powers A_i^(tensor lambda) are linearly independent for every lambda >= r-1. + +Proof. For each fixed i and each j != i, choose a linear functional l_ij with l_ij(A_j)=0 and l_ij(A_i)!=0. Apply the tensor product of these r-1 functionals to the first r-1 factors. If lambda is larger, use a functional that is nonzero on A_i on every additional factor. This functional annihilates every A_j^(tensor lambda) except the i-th one. Apply it for every i. + +A fixed finite linear native circuit expands into finitely many paths. Each path carries a scalar coefficient times the tensor power of a product of its base native matrices. Group projectively equal path matrices and apply the lemma. Thus cancellations between different base native operators at lambda=1 cannot be used as an all-size identity. A proposed joint encoder must either have the correct projective native path operators, cancel each unwanted operator class separately, or use a mechanism outside this fixed tensor-path model. + +For example C_q^-1 = ((1-i)/2) I + ((1+i)/2) X_q at lambda=1 does not imply the same two-term formula for C_q^(-tensor lambda). At lambda=2 there are two additional mixed translations, with nonzero coefficient 1/2. A zero-rank scalar implementation based on the two-term formula is invalid. + +## Cost boundary and next step + +The 56-row phase cache can be formed with scalar operations only if the required source values are already in a common representation. Starting at the actual local C_q entrances, copying all sources to frame zero costs 112 rank units before storage and scalar work. Forming four separate queries in each tetrad's rank-four frame costs 224 rank units. Neither method beats the retained 64 centre rank units for one call. + +The useful remaining construction question is whether actual repeated calls provide a common-frame birth or an existing native computation which can form this cache once and keep its phase updates within N. A second possible route is a joint native cube encoder which is cheaper than four separate rank-four queries in each tetrad. No such route has been admitted here. The exact cache theorem supplies the representation and its compatibility test; a complete supplier cost remains open. + +Research and implementation: OpenAI Codex under the user's direction, with substantial AI assistance. The selected supplier, its exact Clifford compiler, and the preceding centre-sharing native-map calculation supply the inputs. No independent human review is claimed. diff --git a/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz b/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz new file mode 100644 index 0000000000..5f9ef68098 Binary files /dev/null and b/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz differ diff --git a/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz b/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz new file mode 100644 index 0000000000..4eed995798 Binary files /dev/null and b/research/centre-polynomial-cache-limits/frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz differ diff --git a/research/centre-polynomial-cache-limits/notices/LICENSE b/research/centre-polynomial-cache-limits/notices/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/centre-polynomial-cache-limits/notices/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/NOTICE.md b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/NOTICE.md new file mode 100644 index 0000000000..30d0c8cd3c --- /dev/null +++ b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/NOTICE.md @@ -0,0 +1,24 @@ +# Gauge44 attribution and scope + +New contributions by icekylinx, with OpenAI GPT-6 Astra assistance. +Local review and packaging used OpenAI Codex. Apache-2.0 applies; +the license is included. The full original PR635 notice is preserved as +UPSTREAM-NOTICE.md and construction/UPSTREAM-NOTICE.md. + +The new contribution is the changed source-branch gauge and retired-row +completion, source-carried coordinate totals, exact 44-cold-end realization, +and explicit all72 whole-family assignment using concave capacity matching +with integer majorization certificates. The center-carrier generalization +retains the exact ordered common frames and complete native local contract. +Independent local, price, interface and owner fixed-point checks are included. + +The construction retains the credited PR635 K-triangle and porting machinery, +earlier joint-prefix/HPE/frame ancestry and icekylinx's prior factory work. +#645 used the same cited PR543 bit supplier as PR635. This package (research/gauge44-leaver8) cites the merged PR589 bit supplier instead, with a derived rank-mass deficit (PROOF-NOTE-BIT.md); #645's retained PR543-based evidence is historical. It builds #645's word without K-triangles (PartialK) and stacks earlier community jp8 layers on it (G44Stack), adds the p6n ends (NoTriReopen), entrance promotions (BlockInvert) a read-set exchange (BRoute), chafreaky's #741 frames, JointXF's joint exchange, NewBArch's triangle-hybrid B rewrite and LeaverSAT's eight k8 leaver cells (with LeaverSAT2's frame re-optimisation); see README. All-size, realization, +hosting, precision/tape, analytic-transfer and bit H1-H5 assumptions remain +conditional. No upstream license, credit, source pin or AI disclosure is +replaced by this notice. + +PR641 and PR642 were checked as concurrent reported frontier comparisons. +Their endpoints and owner maps are not included here. See CONSTRUCTION.md, +hosting/PROOF.md, independent/ and README.md for the exact contribution scope. diff --git a/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md new file mode 100644 index 0000000000..ebc24a0168 --- /dev/null +++ b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and scope + +Four verified provider types are offered to every call: PR571's prefix word with twelve multi-cut cold kernels (PR568's unchanged constructor), the same word with forty width-five entrance promotions (PR569's unchanged frame constructor) before those kernels, PR575's plain joint-prefix provider, and PR568's eight-cold provider. A window MILP with an exact per-pattern model chooses the dispatch and a literal owner map. PR583's six source-bound kernel frame coalescences (its unchanged constructor and negative controls) are applied to every PR571-prefix provider word (ck and atm3), followed by two further coalescences that each first move one addition past two commuting additions (package code/build_gate_moves.py, extending PR583's constructor); a final hyperplane_end step (package code/build_hpe.py) then runs 46 single-gate cleanups h -= p right after part B at the dim-8 join U of their registers, so 46 width-8 entering helpers per call end at U with width 7; each such gate commutes with every earlier cleanup gate on its registers (for 8 of them the partner's one earlier gate x -= p only reads p), and the reordered program is replayed exactly. A window MILP (exact windows, RINS around an LP vertex) gives the dispatch ck 45 / atm3 21 / jp8 6 and the literal owner map. + +Pinned external sources (unchanged; `verify.py` checks their manifests and every file it uses): +- PR568 (`research/complex-multicold`, commit `71c99ac935a33bb7b59a1b4a7af8725a939b0b90`). +- PR571 (`research/structural-gain`, commit `b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3`). +- PR569 (`research/larger-gain`, commit `897213a855b7fb8a1b8b0e552a2f5c42e6c1b326`). +- PR575 (`research/complex-joint-prefix`, commit `eac6f7e378ab622dac50a2fd4b7ef6eab014de44`). +- PR583 (`research/kernel-frame-coalescing`, commit `89be768f0157f5a3d8e4db69cf1748768605eac9`). + +Provider construction is described as typed steps in `data/SPEC.json` (`build`); `verify.py` runs only allowlisted step types with their paired omission audits and checks every input and output content hash. `code/` holds the spec-driven global admission scripts adapted from PR571's `frontier-composition/global-code/` (OpenAI Codex assisted, Apache-2.0): every expected value is read from `data/SPEC.json` and compared only after independent recomputation. `code/generated_identity.py` and `code/generated_identity_controls.py`, and the decompressed-content artifact identities in the bind, audit, invoice, assembly and phase-timing scripts, are taken unchanged from PR586 by chafreaky (`research/promoted-kernel-coalescing`, commit `4846fee5b06af770e9b3a10c36200f673d656725`, OpenAI Codex assisted, Apache-2.0), including its proof-content and reference/metadata mutation controls; the normalization of descriptive width metadata after frame changes follows the same PR. + +In PR601, the owner map was nominated by a HiGHS window MILP (adapted from PR569's `global/nominate_width7.py`) with lazy cross-time Hall cuts; this package's re-solved map is described below. Neither is an admission dependency. + +DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. (The PR601 package this one starts from states: "Prepared by Claude Code (Anthropic) research agents.") Apache-2.0 applies; LICENSE is included. All notices, licenses, source pins and AI disclosures of the pinned sources and their ancestry are retained in those packages and are not replaced by this notice. All inherited conditional assumptions remain conditional. + +**This package (complex-571-cold14, DreamingOfClouds).** It starts from PR601 (jeremykothe2, `research/complex-571-hpem46`, commit `529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550`). Everything above is kept unchanged except the following: +- every provider chain (ck, atm3, jp8) gains the typed step `cold_end` (`code/build_cold_end.py`, `code/cold_end_controls.py`; recipes `data/recipes/*-cold_end.json.gz`); +- the generalised native chain and the global admission scripts accept cold helpers that end below FULL (with `0:U` wrappers), a refactored exact cleanup, and check the wrapper order; +- `data/PLAN.json` / `data/OWNERS.json.gz` (dispatch and literal owner map) come from a relocate/swap/ejection-chain/provider-flip annealing search started from PR601's map, refined by an exact pattern-restricted owner model (CP-SAT) with a literal edge-colouring expansion (not an admission dependency); +- `data/SPEC.json` holds the expected values, recorded by a discovery run and then checked by a strict run. + +The cold-end construction (a row-plus-column cone condition for low-frame ends, a rank-0 dirt-spread premix and multi-gate lower-frame cleanup) builds on PR591 / PR592 / PR593 / PR601 (jeremykothe2) and our PR599 (Lean: multi-gate and cold hyperplane-end tails). DreamingOfClouds with Claude Opus 5.5 (Anthropic), via Claude Code. Build on this at your own risk. + +**This package (complex-571-cold14-b3, jeremykothe2).** It is PR604's `complex-571-cold14` (DreamingOfClouds) with ColdBeyond's second cold end per block (two new `cold_end` A-gate primitives, `PROOF-NOTE.md`), ColdSupply's E1 entering pair and reviewed controls, a free dispatch (jp8 ×60, atm3 ×12) and a literal owner map from an exact per-time-Hall window MIP. All other construction, code, controls and proofs are PR604's and earlier contributors', unchanged. + +**This package (complex-571-cold14-k492).** It is complex-571-cold14-b3 with these changes: +- **K-triangle base words.** The leaver-read K-triangle skeleton atom and its read schedule (`data/TRI-SCHEDULE.json`) are by AtomScout, a Claude Code research agent. `code/construct_k_triangle.py` is PR531's `code/construct_504.py` (icekylinx, OpenAI Codex / GPT assisted, Apache-2.0; pinned source `direct_delivery`) extended with that atom. +- **Ported chains.** The PR604/B3 chains are ported stage by stage onto the K-triangle words by `code/build_port_stage.py` (Port480, a Claude Code research agent). `code/build_frame_regroup.py` extends PR583's `build_frames.py` (chafreaky). +- **Helper count R.** The generalisation of the global scripts to the provider helper count R is by GlobalR (a Claude Code research agent), with AtomReviewer's fixes (PROOF-NOTE-R.md). +- **Owner map.** The owner map, the cold_end recipes on the K-triangle words and the package assembly are by Stack492, Port480 and ColdBeyond (Claude Code research agents). + +Build on this at your own risk. diff --git a/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/construction/NOTICE.md b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/construction/NOTICE.md new file mode 100644 index 0000000000..16b0507070 --- /dev/null +++ b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/construction/NOTICE.md @@ -0,0 +1,9 @@ +# Construction delta notice + +Prepared for icekylinx with OpenAI GPT-6 Astra assistance. Apache-2.0. + +`construct_gauge_xcentre.py` modifies PR635's credited `construct_k_triangle.py`, which in turn extends icekylinx's PR531/PR514/PR425 factory lineage. Its original source comments are retained. The K-triangle schedule and the upstream porting, JP8 frame, kernel and HPE procedures are reused from the pinned source checkouts and are not new contributions of this delta. + +The new source-copy exchanges, complementary factory basis, carrier assignment, exact cold44 constructor and compact reproduction driver are described in `../CONSTRUCTION.md`. + +`UPSTREAM-NOTICE.md` is the complete unmodified notice from the pinned PR635 package. `LICENSE` is that package's Apache-2.0 license. All further notices and source credits of the referenced upstream packages remain applicable and are retained in the source checkouts rather than vendored again here. diff --git a/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/t16/NOTICE.md b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/t16/NOTICE.md new file mode 100644 index 0000000000..403f4afffb --- /dev/null +++ b/research/centre-polynomial-cache-limits/notices/research/gauge44-slots-t16/t16/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +Apache-2.0. New construction and integration: Hao Yan (@FanPUYen), 2026. +Prepared with substantial OpenAI Codex assistance, including separately tasked +AI agents for owner construction, independent mathematical/code checking and +native verification. These are not claims of independent human peer review. + +The exact local supplier is Jeremy Kothe's accepted PR799 X4 word, layered on +Chafik Boukhalfa's PR741 frame changes and PR685 owner construction. Chafik's +PR795 fixed-inventory optimality result motivated changing the replica count. +The original owner bytes, scalar program, local frame and width inventory, +native phase and wrapper implementations retain their existing authorship. + +Credit icekylinx for the source gauge and supplier/admission pipeline; +DreamingOfClouds for the PR589 bit transport and inherited cold-end work; +eumemic for the PR555 bit supplier and earlier supplier work; Rohan Arun for +the native exact-complex recurrence correction; Jeremy Diviney, jaymosley07, +and the other retained owner/allocation contributors; and the complete +PR514/PR484/PR507/PR558 controller, physical hosting and verification lineage. +This list is cumulative credit, not approval of every claim in those PRs. + +All original notices and licenses remain in the referenced source packages: + +- `research/gauge44-frames-x/{NOTICE,UPSTREAM-NOTICE}.md` +- `research/complex-sw4-frame8/PROVENANCE.md` +- `research/e8-bit-p111-tuned/tune/README.md` +- the repository `CONTRIBUTORS.md` and source-package licenses. + +The verifier copies pinned global source files into an external replay +directory and applies an explicit checked edit list. Original attribution +comments are preserved in those generated derivatives. No original source +file or historical certificate is rewritten. + +The optional ancestry-reuse coverage guard addresses the omission issue +identified by Lucas (@ljste) in PR838 and the related PR847 integration by +Chinmay (@chinmayarvind23). Its fixed inventories were read from the accepted +PR741 source; no pending implementation is imported. Charles Bethin's +concurrent PR850 strengthens the fixed-inventory owner-profile theorem and +was checked for overlap before publication; that inventory is changed here. diff --git a/research/centre-polynomial-cache-limits/replay.py b/research/centre-polynomial-cache-limits/replay.py new file mode 100644 index 0000000000..f07d090d31 --- /dev/null +++ b/research/centre-polynomial-cache-limits/replay.py @@ -0,0 +1,70 @@ +"""Replay the two retained results from the local source closure.""" + +import argparse +from hashlib import sha256 +import json +from pathlib import Path +import platform +import shutil +import subprocess +import sys + + +def require(condition, reason): + if not condition: + raise ValueError(reason) + + +def main(args): + root = Path(__file__).resolve().parent + sources = json.loads((root / "SOURCES.json").read_text()) + for item in sources["files"]: + raw = (root / item["path"]).read_bytes() + require(len(raw) == item["bytes"] and sha256(raw).hexdigest() == item["sha256"], + "Source digest mismatch: " + item["path"]) + args.out.mkdir(parents=True, exist_ok=False) + shutil.copytree(root / "frozen", args.out / "frozen") + lanes = args.out / "frozen/work/centre-encoding-campaign-20261014/lanes" + interface = lanes / "circuit-interface/INTERFACE.json" + + def run(name, script, *arguments): + result = subprocess.run([sys.executable, "-I", "-B", str(script), *map(str, arguments)], + capture_output=True, text=True) + (args.out / (name + "-stdout.txt")).write_text(result.stdout) + (args.out / (name + "-stderr.txt")).write_text(result.stderr) + require(result.returncode == 0, name + " failed; read its log") + + run("bell-producer", lanes / "history-encoding/certify_bell_gram_degree.py", + "--interface", interface, "--out", args.out / "BELL-GRAM-DEGREE.json") + require((args.out / "BELL-GRAM-DEGREE.json").read_bytes() == + (lanes / "history-encoding/BELL-GRAM-DEGREE.json").read_bytes(), + "The Bell producer receipt must equal the retained receipt") + run("bell-review", lanes / "interface-proof/review_bell_gram_degree.py") + review_path = Path("work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json") + require((args.out / "frozen" / review_path).read_bytes() == + (root / "frozen" / review_path).read_bytes(), + "The separate Bell review receipt must equal the retained receipt") + run("phase-cache", root / "check_phase_cache.py", + "--interface", interface, "--out", args.out / "PHASE-CACHE-CHECK.json") + import numpy + report = { + "status": "PASS_CENTRE_POLYNOMIAL_CACHE_LIMITS", + "python_version": platform.python_version(), + "numpy_version": numpy.__version__, + "historical_source_commit": sources["historical_source_commit"], + "source_files_checked": len(sources["files"]), + "bell_producer_receipt_equal": True, + "bell_independent_review_receipt_equal": True, + "phase_cache_check": json.loads((args.out / "PHASE-CACHE-CHECK.json").read_text()), + "not_run": ["Full supplier replay", "Native decoder", "Selected frontier replay", "Outer kappa calculation", "Formal-kernel proof"], + } + (args.out / "REPLAY.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(report["status"]) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--out", type=Path, required=True) + arguments = parser.parse_args() + arguments.out = arguments.out.resolve() + main(arguments) diff --git a/research/centre-polynomial-cache-limits/requirements.txt b/research/centre-polynomial-cache-limits/requirements.txt new file mode 100644 index 0000000000..9f161acad9 --- /dev/null +++ b/research/centre-polynomial-cache-limits/requirements.txt @@ -0,0 +1 @@ +numpy>=1.24 diff --git a/research/centre-polynomial-cache-limits/review/ARITHMETIC-BOUNDS.json b/research/centre-polynomial-cache-limits/review/ARITHMETIC-BOUNDS.json new file mode 100644 index 0000000000..c07c7fd0ac --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/ARITHMETIC-BOUNDS.json @@ -0,0 +1,12 @@ +{ + "status": "PASS", + "bounds": { + "producer_R_transpose_sum": 262144, + "producer_R_sum": 3670016, + "review_sparse_row_sum": 14680064, + "moment_sum": 17591917608960, + "field_product": 4294967296, + "Bareiss_absolute_difference": 4294967296 + }, + "reason": "Every vector residue is between 0 and 65536. SHAKE observers are between 0 and 65535. Products in elimination have two nonnegative factors at most 65536; their difference has absolute value at most 65536 squared." +} diff --git a/research/centre-polynomial-cache-limits/review/CHECKED-FILES.json b/research/centre-polynomial-cache-limits/review/CHECKED-FILES.json new file mode 100644 index 0000000000..bbec0bd630 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/CHECKED-FILES.json @@ -0,0 +1,170 @@ +{ + "package": "work/project-final-cleanup-20261022/campaign-audit/centre-polynomial-cache-limits", + "files": [ + { + "path": "NOTICE.md", + "bytes": 2804, + "sha256": "4dde831dc40b31d0edc23adbcd0aaeec3aa573eef6f4f27fcdb53d24eab173e8" + }, + { + "path": "PACKAGE-MANIFEST.json", + "bytes": 5961, + "sha256": "b0068a23f4a71c700a2b89383225e77070ff2905a60087e04c686355fa5db9aa" + }, + { + "path": "PROOF.md", + "bytes": 5655, + "sha256": "ebcd0912e990c71f3b29b87674c1b5e3efa8f5ea37ed20f4fd06d80ce27f6382" + }, + { + "path": "README.md", + "bytes": 3420, + "sha256": "7569c606042bacf8c36b75fbbd1dfef9a8861d194659c4a93dfa68fddc7c044f" + }, + { + "path": "SOURCES.json", + "bytes": 5809, + "sha256": "b3ad9ed33fda0ffb64d50ed6d026168651b9351a16a21ca0b9821c179b474d3d" + }, + { + "path": "check_phase_cache.py", + "bytes": 5314, + "sha256": "16ed9b27047d065c7a7648ebc8dc46438ec93c7cfbc530f9cc996e878d1ffe5d" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/bounds-review/review_centre_free.py", + "bytes": 8966, + "sha256": "33b6b73303275e481f12cc2f946d1273ca9ac03d9294600016f03e84e6921088" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json", + "bytes": 23232, + "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE-PROOF.md", + "bytes": 4001, + "sha256": "bc3a72690735230e8d9995df1a343f69fe8afed7dce056a82505efc83a884698" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-DEGREE.json", + "bytes": 10174, + "sha256": "4b198523d498b85b96445681fdcd8020402b1abb31c6a27e7d2a45d5df2217e2" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/BELL-GRAM-INVERSE-COROLLARY.md", + "bytes": 1058, + "sha256": "d1d3011e26d5768edc10ac234aeb9cb80c721addc28f9aabc784f56383ca4fe3" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/history-encoding/certify_bell_gram_degree.py", + "bytes": 5140, + "sha256": "8604d1665862593efc146644fbf47a85c4a2aca88106284096d723853a064e45" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.json", + "bytes": 1996, + "sha256": "4f48be6cfd0f7ab316d1dc957ba18668b56a4feed55ef8cae5c205560e13b16a" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/BELL-GRAM-DEGREE-REVIEW.md", + "bytes": 3113, + "sha256": "3a670ff14be1db7109d12d1fc6c28704543d3a19ad2e9d4ac6431a0a86a57d9f" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/interface-proof/review_bell_gram_degree.py", + "bytes": 9719, + "sha256": "0d9983c288292f568c1f1595b944ca81131f79119855b7ad5c64e28c3cbfd899" + }, + { + "path": "frozen/work/centre-encoding-campaign-20261014/lanes/native-encoding/PHASE-CACHE.md", + "bytes": 7975, + "sha256": "bd53f0c38ac06e20b8361543086bb5f6310bdeb552fb692dc29978434cd4dc84" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/CANONICAL-WORD.json.gz", + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing/LOCAL-PROGRAMS.json.gz", + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + }, + { + "path": "notices/LICENSE", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "notices/research/gauge44-slots-t16/NOTICE.md", + "bytes": 1964, + "sha256": "7a8d17b04da1e6c9d0ec217fb5bda72faa09d9a21695128722dd1e2827870fcf" + }, + { + "path": "notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "bytes": 6406, + "sha256": "a75967ebc34e3bf2ff2c25c08e6c7f1a61b0c0d171cfd1b62196ae2caaf2c610" + }, + { + "path": "notices/research/gauge44-slots-t16/construction/NOTICE.md", + "bytes": 950, + "sha256": "defe7e44af610e25a6c50c1c3b2efd0972d0690574995c0c872fc50eebf4c816" + }, + { + "path": "notices/research/gauge44-slots-t16/t16/NOTICE.md", + "bytes": 2245, + "sha256": "902370e6bfcd39dbea2ece474f15fccbcce3b8e966b2b94066bd03e5174591b5" + }, + { + "path": "replay.py", + "bytes": 3216, + "sha256": "20f3436ba77856ba233650bd04a42daad6c597bb19b439e5291cc3226057e98c" + }, + { + "path": "requirements.txt", + "bytes": 12, + "sha256": "a83a2a4ed7ab2e022b9b8a83cfa2b8cf52cc243006c597e8b96f90a8365590ac" + }, + { + "path": "validation/PHASE-CACHE-CHECK.json", + "bytes": 1376, + "sha256": "34386095a77c0aa3008e652fb2dc982a654b17b525dd0f85bf3b72c8867d3556" + }, + { + "path": "validation/REPLAY.json", + "bytes": 2075, + "sha256": "7898245ca60369fcae643ce6f5bec5065e2e2aa0d46c1658b8e5f5ca56253779" + }, + { + "path": "validation/bell-producer-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/bell-producer-stdout.txt", + "bytes": 200, + "sha256": "b8a03214ced2b88ff097a6a7f5ba55f40dd931299b1fe75cb6d62d2108877b29" + }, + { + "path": "validation/bell-review-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/bell-review-stdout.txt", + "bytes": 135, + "sha256": "04001332aac6a4120ebb33bc8a6f1946fe96094f7ef6bd2d8ea73ed52f60c1e8" + }, + { + "path": "validation/phase-cache-stderr.txt", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "validation/phase-cache-stdout.txt", + "bytes": 39, + "sha256": "3fad44ed5923785fcc2c7534cd9887c315168ffbcd5d9f1c5935a461585d7622" + } + ] +} diff --git a/research/centre-polynomial-cache-limits/review/EXTRA-REJECTION-CONTROLS.json b/research/centre-polynomial-cache-limits/review/EXTRA-REJECTION-CONTROLS.json new file mode 100644 index 0000000000..54bc72cb54 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/EXTRA-REJECTION-CONTROLS.json @@ -0,0 +1,5 @@ +{ + "status": "PASS", + "changed_moment_rejected": true, + "changed_interface_bytes_rejected": true +} diff --git a/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-CHECK.json b/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-CHECK.json new file mode 100644 index 0000000000..647f6dc1cc --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-CHECK.json @@ -0,0 +1,19 @@ +{ + "status": "PASS_SEPARATE_FORWARD_RATIONAL_QUERY_RECONSTRUCTION", + "method": "Propagate sparse source rows forward through every scalar gate before the centers phase. Set other input coordinates to zero. No producer or retained transpose function imported.", + "scalar_gates": 10851, + "centers": [ + 92, + 57, + 81, + 224, + 11, + 240, + 9, + 256 + ], + "rows": 8, + "columns": 112, + "matches_interface": true, + "all_entries_integers": true +} diff --git a/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-REPRODUCED.json b/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-REPRODUCED.json new file mode 100644 index 0000000000..e787936acd --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/FORWARD-QUERY-REPRODUCED.json @@ -0,0 +1,8 @@ +{ + "status": "PASS", + "scalar_gates": 10851, + "rows": 8, + "columns": 112, + "row_absolute_sum": 56, + "column_absolute_sum": 4 +} diff --git a/research/centre-polynomial-cache-limits/review/MAIN-OVERLAP.json b/research/centre-polynomial-cache-limits/review/MAIN-OVERLAP.json new file mode 100644 index 0000000000..0862bec664 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/MAIN-OVERLAP.json @@ -0,0 +1,8 @@ +{ + "main": "cef4b52f2a59009865bf8eabde1be3f159063703", + "scope": "Markdown files under research at this exact commit; exact Bell/degree terms and broader fiber-rank/invariant terms", + "pattern": "bell.{0,20}gram|polynomial.{0,20}409|degree.{0,12}409|hankel.{0,20}409|minimal invariant|fiber.{0,20}rank", + "matching_lines": 31, + "raw_sha256": "6be9f62deffffdc1cf3bf962f721ec08210112e31a16141c55a278ea351ec05d", + "note": "Matches concern binary E8 frame-fiber capacity, monomial partition transport, or unrelated matrix-exponent synthesis. No matching degree409 Bell Gram or minimal diagonal invariant scalar-cache theorem was found by this bounded lexical search." +} diff --git a/research/centre-polynomial-cache-limits/review/OPEN-PR-OVERLAP.json b/research/centre-polynomial-cache-limits/review/OPEN-PR-OVERLAP.json new file mode 100644 index 0000000000..23805c68f6 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/OPEN-PR-OVERLAP.json @@ -0,0 +1,5 @@ +{ + "scope": "315 open PR titles and bodies from parent-fetched OPEN-PRS.json; not all diffs or discussions", + "count": 315, + "matches": [] +} diff --git a/research/centre-polynomial-cache-limits/review/REVIEW.json b/research/centre-polynomial-cache-limits/review/REVIEW.json new file mode 100644 index 0000000000..8b88158758 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/REVIEW.json @@ -0,0 +1,46 @@ +{ + "status": "PASS_INDEPENDENT_AGENT_REVIEW", + "package_manifest_sha256": "b0068a23f4a71c700a2b89383225e77070ff2905a60087e04c686355fa5db9aa", + "checked_files_json_sha256": "86d068a1af55ff9e0d566cc0a5ecd9eb5abfde61988f8d443a7b41ab1d048896", + "review_md_sha256": "c80393d685f8b48092f341ce6adcadd396a97e9cd2de469ac316e2ca46fc867f", + "package_files": 33, + "manifest_exact_coverage": true, + "approves": [ + "Scalar minimal-polynomial degree at least409 for the defined actual112-port doubled Gram at every positive tensor size", + "Scalar-polynomial inverse degree at least408 when aI+bA is invertible and b is nonzero", + "Least invariant scalar cache dimension equals the sum of joint diagonal fiber ranks", + "Pinned56/112 cache dimensions and512-character rank histogram" + ], + "material_findings": [], + "scope_excludes": [ + "General native/circuit cost lower bounds", + "Complete supplier construction", + "Verified complete kappa improvement", + "Independent human review", + "Formal-kernel verification", + "Universal novelty" + ], + "additional_pinned_sources_read": [ + { + "commit": "3ae9a6f3ac74ded022ab3b4872a7357a621af6fb", + "path": "research/involutive-walsh-lift/NATIVE-PROOF.md", + "sha256": "bbf8b04e06a165d608b4e9201c525eb46462de60a1c9e33930ca5b86cdec42ce" + }, + { + "commit": "3c6a768e5391e6bc8355fe2bc849d2978afef8f6", + "path": "research/phase-coded-callers/annexes/fixed-code-interface/PROOF.md", + "sha256": "c14762025b084a3a54680c8bfd05fdf56b16600eaaebd081f975354564ca9098" + }, + { + "commit": "cb102a57254748651ce16aa4454bb611f6380e53", + "path": "research/actual-query-information-bounds/annexes/source-geometry/frozen/lanes/schur-selection/plane-repair/QUERY-SPAN.md", + "sha256": "785e27fdc6f2bcd83318afee14103f3e021065d32be2265b8afdec3fea3e1081" + } + ], + "fresh_replay": "replay/REPLAY.json", + "extra_checks": "check_review.py", + "extra_checks_script_sha256": "ed5abf91b65ddfb3152210d9ad6692103fbae44a073ca82c42804bf847b86aa9", + "extra_checks_output": "portable-replay", + "extra_checks_portable_paths": true, + "checked_package_unchanged_after_portability_update": true +} diff --git a/research/centre-polynomial-cache-limits/review/REVIEW.md b/research/centre-polynomial-cache-limits/review/REVIEW.md new file mode 100644 index 0000000000..697fc16c98 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/REVIEW.md @@ -0,0 +1,147 @@ +# Independent agent review: centre polynomial and scalar-cache limits + +Result: PASS for the two claims in the package `PROOF.md`. No material +mathematical or implementation defect was found. This is an independent +OpenAI Codex agent review, not human peer review or a formal-kernel proof. +The package does not give a native encoder, a complete supplier, or an +improved complete kappa value. + +The checked package is +`work/project-final-cleanup-20261022/campaign-audit/centre-polynomial-cache-limits`. +`CHECKED-FILES.json` records the exact file bytes at review completion. +The PR description standard at +`/Users/aliromman/Projects/IntegerMultiplicationBounds/PR-DESCRIPTION-STANDARD.md` +was read. The coordinating agent must still check the final PR description, +GitHub source targets, and rendered Markdown. + +## Bell Gram proof + +The operator has the explicit definition +`A_lambda=(1/4) sum_q r_q r_q^T tensor Gamma_q^tensor(lambda)`. +The root coefficient occurs once. The 112 columns and their order are the +historical query columns, not the completed 120-root table. The scalar +word inputs match the two original archive members byte for byte at +`bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. The complete archive has SHA-256 +`22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754`. +The interface bytes also match the published PR #4720 object at +`cb102a57254748651ce16aa4454bb611f6380e53`. + +The retained sparse reviewer reconstructs R by a transpose calculation. +This review also reconstructs R in the opposite direction: it propagates +sparse rational source rows through all 10,851 scalar gates before the +centres phase. It sets all other inputs to zero. The result equals every +entry of the eight-by-112 interface matrix. This extra check does not +import either retained reconstruction function. It establishes the clean +query matrix only; it is not a new arbitrary-helper supplier check. + +For odd q, the normalized real matrix `(X_q+Z_q)/sqrt(2)` is a symmetric +involution. Conjugation on the Pauli matrix `X^b Z^a` gives the two stated +Bell cases and preserves `c=a+b`. The retained reviewer checks all 57,344 +columns in the selected `c=11` block by four-term Pauli multiplication. +It separately checks that the identity Pauli matrix is fixed by all +112 operators. The normalized doubled port agrees with the exact formula +in PR #1719's pinned `NATIVE-PROOF.md`; no phase is dropped. + +The producer and separate sparse reviewer both give the 817 retained +moments and determinant 2,984 modulo the prime 65,537. The prime check +covers every possible divisor through its square root. The Hankel +determinant lies in `Z[1/2]`. Its nonzero reduction proves a nonzero +characteristic-zero determinant. This proves independence of the first +409 Krylov vectors and hence the degree bound. It does not require a +guessed recurrence or a claim about the exact minimal polynomial. + +Tensoring the selected Bell block with the common fixed identity vector +in the remaining slots gives the same operator on an invariant subspace +at every positive tensor size. This proves the bound at each size, +including size-dependent candidate polynomials. A nonzero rational +minor remains nonzero after a characteristic-zero field extension. +For an invertible `aI+bA_lambda`, with `b != 0`, a polynomial inverse q +would make `(a+bt)q(t)-1` a nonzero annihilator. Thus `degree(q) >= 408`. +This is a representation bound, not a circuit-gate or native-cost bound. + +All NumPy arithmetic used for the certificate is exact signed int64 +arithmetic. The producer's largest absolute inner sum bounds are +262,144 for `R^T value` and 3,670,016 for `R acted`. The independent +sparse row bound is 14,680,064. The moment bound is 17,591,917,608,960, +which is less than `2^44`. Field products and the absolute difference +of the two nonnegative Bareiss products are at most `2^32`. Every bound +is below the signed int64 limit. The residue reduction occurs before +the next field product. + +## Minimal invariant scalar cache + +The theorem assumes a finite complex source space, fixed diagonal update +matrices, and a linear scalar cache that contains the query row space. +It does not give free source-dependent payload maps or source rereads. +Within this class, the proof is correct. A linear combination of the +updates separates the finitely many joint diagonal fibers. Polynomial +interpolation supplies each fiber projector. Every invariant cache that +contains the query must contain its row projections onto all fibers. +Their supports are disjoint, so their dimensions add. Conversely, the +direct sum of these fiber row spaces is invariant and contains the query. +The empty update family also satisfies the statement. + +The rational checker reproduces the normal-direction dimensions +`8,15,28,44,44,56,56,56,56` and coordinate-direction dimensions +`8,16,31,53,85,101,112,112,112,112`. It verifies fourteen final normal +fibers, each with eight columns and rank four. It constructs the 56-row +basis, checks that it contains R, and checks every stated diagonal +update on every basis row. Removal of one necessary row fails a required +projected-row test. The 512 two-demand ranks are two of rank eight, +sixteen of rank fifteen, and 494 of rank sixteen. Exact rational rank +has the same value over C for these rational matrices. + +The 56-row result applies only to the specified normal-character family. +Six specified coordinate characters force the full 112-dimensional +source space in this model. This is a useful exact cache-size criterion; +it does not price cache birth, native access, storage, or restoration. + +## Reproduction and controls + +From the workspace root, this review ran: + +```sh +env OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 work/autonomous-kappa-run/venv/bin/python -I -B work/project-final-cleanup-20261022/campaign-audit/centre-polynomial-cache-limits/replay.py --out work/project-final-cleanup-20261022/reviews/bell-cache/replay +env OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 work/autonomous-kappa-run/venv/bin/python -I -B work/project-final-cleanup-20261022/reviews/bell-cache/check_review.py --package work/project-final-cleanup-20261022/campaign-audit/centre-polynomial-cache-limits --out work/project-final-cleanup-20261022/reviews/bell-cache/portable-replay --repo . +``` + +Both passed, under Python 3.14.7 and NumPy 2.5.4, with one numerical +thread. The first output directory was new. Its Bell producer and +review receipts equal the retained receipts byte for byte. The duplicate +row, duplicate column, and removed-cache-row controls passed. The extra +review script changed one moment and separately changed the interface +bytes in a scratch copy. The independent moment comparison rejected the +first mutation; the interface digest check rejected the second. Original +package sources were unchanged. The extra script accepts explicit `--package`, `--out`, and `--repo` +paths. It creates a new output directory on every run. Its source-history +check needs a Git repository that contains the cited historical objects. +It does not need the old workspace folder layout. + +No full supplier, native decoder, selected-frontier replay, outer kappa +calculation, or formal-kernel proof was run. The all-size and general +cache conclusions follow from the displayed proofs, not finite samples. + +## Credit and bounded overlap check + +All five copied license/notice objects match the pinned Git source. +The new notice identifies the roles of the prior Codex research lanes, +credits the historical supplier notices, and distinguishes AI review from +human review. This review read PR #1719's pinned native lift proof, +PR #4750's fixed-code projector criterion, and PR #4720's QUERY-SPAN +theorem. The first supplies the port representation. The second tests a +given code, rather than its least invariant enlargement. The third gives +a different payload-query source-span bound. These are not claimed again. + +A bounded search of research Markdown at current main +`cef4b52f2a59009865bf8eabde1be3f159063703` found no equivalent Bell +degree-409 or minimal diagonal-invariant cache statement. Broader +fiber/rank matches concern different E8 frame-capacity or partition +results. The parent-fetched list of 315 open PR titles and bodies had no +matching Bell/Hankel/phase-cache/scalar-cache/minimal-polynomial terms. +The search is recorded in the two overlap receipts. It does not cover +every open diff, Discussion, closed PR, or external literature result, +and it does not establish universal novelty. + +The final two documentation edits add scoped open questions and remove +a redundant determinant sentence. They do not change a proof or checker. +No material review finding remains open. diff --git a/research/centre-polynomial-cache-limits/review/SOURCE-BINDING-REPRODUCED.json b/research/centre-polynomial-cache-limits/review/SOURCE-BINDING-REPRODUCED.json new file mode 100644 index 0000000000..b35a3c065c --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/SOURCE-BINDING-REPRODUCED.json @@ -0,0 +1,14 @@ +{ + "status": "PASS", + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "members": { + "slots/local/CANONICAL-WORD.json.gz": { + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + "slots/local/LOCAL-PROGRAMS.json.gz": { + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + } + } +} diff --git a/research/centre-polynomial-cache-limits/review/SOURCE-BINDING.json b/research/centre-polynomial-cache-limits/review/SOURCE-BINDING.json new file mode 100644 index 0000000000..b23a41f315 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/SOURCE-BINDING.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_EXACT_ORIGINAL_SOURCE_BINDING", + "historical_source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "archive_members": { + "slots/local/CANONICAL-WORD.json.gz": { + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + "slots/local/LOCAL-PROGRAMS.json.gz": { + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + } + }, + "notice_source_matches": [ + "notices/LICENSE", + "notices/research/gauge44-slots-t16/NOTICE.md", + "notices/research/gauge44-slots-t16/UPSTREAM-NOTICE.md", + "notices/research/gauge44-slots-t16/t16/NOTICE.md", + "notices/research/gauge44-slots-t16/construction/NOTICE.md" + ], + "interface_publication_commit": "cb102a57254748651ce16aa4454bb611f6380e53", + "interface_publication_exact_byte_match": true +} diff --git a/research/centre-polynomial-cache-limits/review/check_review.py b/research/centre-polynomial-cache-limits/review/check_review.py new file mode 100644 index 0000000000..e45fa7c913 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/check_review.py @@ -0,0 +1,139 @@ +"""Check source pins, query rows, arithmetic bounds, and rejection controls.""" + +import argparse +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json +import os +import shutil +import subprocess +import sys +import tarfile + + +parser = argparse.ArgumentParser() +parser.add_argument("--package", type=Path, required=True) +parser.add_argument("--out", type=Path, required=True) +parser.add_argument("--repo", type=Path, required=True) +args = parser.parse_args() +PACKAGE = args.package.resolve() +OUT = args.out.resolve() +REPO = args.repo.resolve() +OUT.mkdir(parents=True, exist_ok=False) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def save(name, value): + (OUT / name).write_text(json.dumps(value, indent=2) + "\n") + + +def source_check(): + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + source = sources["historical_source_commit"] + ":" + sources["historical_selected_archive"]["path"] + proc = subprocess.Popen(["git", "show", source], cwd=REPO, stdout=subprocess.PIPE) + digest = sha256() + while chunk := proc.stdout.read(1048576): + digest.update(chunk) + require(proc.wait() == 0, "Read the source archive") + require(digest.hexdigest() == sources["historical_selected_archive"]["sha256"], "Archive digest") + proc = subprocess.Popen(["git", "show", source], cwd=REPO, stdout=subprocess.PIPE) + members = {} + with tarfile.open(fileobj=proc.stdout, mode="r|gz") as archive: + for member in archive: + if member.name not in ["slots/local/CANONICAL-WORD.json.gz", "slots/local/LOCAL-PROGRAMS.json.gz"]: + continue + raw = archive.extractfile(member).read() + local = PACKAGE / "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing" / Path(member.name).name + require(raw == local.read_bytes(), "Exact source member") + members[member.name] = {"bytes": len(raw), "sha256": sha256(raw).hexdigest()} + require(proc.wait() == 0 and len(members) == 2, "Both source members") + for item in sources["files"]: + if item.get("source_commit"): + raw = subprocess.check_output(["git", "show", item["source_commit"] + ":" + item["source_path"]], cwd=REPO) + require(raw == (PACKAGE / item["path"]).read_bytes(), "Exact notice source") + save("SOURCE-BINDING-REPRODUCED.json", {"status": "PASS", "archive_sha256": digest.hexdigest(), "members": members}) + + +def forward_query(): + folder = PACKAGE / "frozen/work/five-pr-sprint-20261013/lanes/centre-sharing" + word = json.loads(gzip.decompress((folder / "CANONICAL-WORD.json.gz").read_bytes())) + events = json.loads(gzip.decompress((folder / "LOCAL-PROGRAMS.json.gz").read_bytes()))["forward"] + state = [{j: Q(1)} if j < 112 else {} for j in range(712)] + def index(register): + return register[1] + (704 if register[0] == "C" else 0) + count = 0 + for event in events: + if event == ["phase", "centers"]: + break + if event[0] != "scalar": + continue + count += 1 + gate = event[1] + target = index(gate[1]) + if gate[0] == "clear": + state[target] = {} + elif gate[0] == "scale": + scale = Q(gate[2], gate[3]) + state[target] = {j: scale * value for j, value in state[target].items() if scale * value} + elif gate[0] == "copy": + state[target] = state[index(gate[2])].copy() + elif gate[0] == "add": + scale = Q(gate[3], gate[4]) + for j, value in state[index(gate[2])].copy().items(): + total = state[target].get(j, Q(0)) + scale * value + if total: + state[target][j] = total + else: + state[target].pop(j, None) + else: + raise ValueError("Unknown scalar gate") + rows = [[state[c].get(j, Q(0)) for j in range(112)] for c in word["centers"]] + interface = json.loads((PACKAGE / "frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json").read_text()) + expected = [[Q(row.get(str(j), "0")) for j in range(112)] for row in interface["R"]] + require(rows == expected, "Forward rational query reconstruction") + row_weights = [sum(abs(value) for value in row) for row in rows] + column_weights = [sum(abs(row[j]) for row in rows) for j in range(112)] + require(max(row_weights) == 56 and max(column_weights) == 4, "Root coefficient bounds") + save("FORWARD-QUERY-REPRODUCED.json", {"status": "PASS", "scalar_gates": count, "rows": 8, "columns": 112, "row_absolute_sum": 56, "column_absolute_sum": 4}) + bounds = { + "producer_R_transpose_sum": 4 * 65536, + "producer_R_sum": 56 * 65536, + "review_sparse_row_sum": 224 * 65536, + "moment_sum": 4096 * 65535 * 65536, + "field_product": 65536 ** 2, + "Bareiss_absolute_difference": 65536 ** 2, + } + require(max(bounds.values()) < 2 ** 44 < 2 ** 63, "Signed int64 operations fit") + save("ARITHMETIC-BOUNDS.json", {"status": "PASS", "bounds": bounds, "reason": "Every vector residue is between 0 and 65536. SHAKE observers are between 0 and 65535. Products in elimination have two nonnegative factors at most 65536; their difference has absolute value at most 65536 squared."}) + + +def rejection_controls(): + copied = OUT / "controls-frozen" + shutil.copytree(PACKAGE / "frozen", copied) + lanes = copied / "work/centre-encoding-campaign-20261014/lanes" + env = dict(os.environ, OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1") + certificate = lanes / "history-encoding/BELL-GRAM-DEGREE.json" + value = json.loads(certificate.read_text()) + value["moments"][0] = (value["moments"][0] + 1) % 65537 + certificate.write_text(json.dumps(value)) + result = subprocess.run([sys.executable, "-I", "-B", str(lanes / "interface-proof/review_bell_gram_degree.py")], capture_output=True, text=True, env=env) + (OUT / "corrupt-moment-stderr.txt").write_text(result.stderr) + require(result.returncode != 0 and "All817 independent sparse moments agree" in result.stderr, "Corrupt moment must fail") + interface = lanes / "circuit-interface/INTERFACE.json" + interface.write_bytes(interface.read_bytes() + b"\n") + result = subprocess.run([sys.executable, "-I", "-B", str(lanes / "history-encoding/certify_bell_gram_degree.py"), "--interface", str(interface), "--out", str(OUT / "invalid.json")], capture_output=True, text=True, env=env) + (OUT / "corrupt-interface-stderr.txt").write_text(result.stderr) + require(result.returncode != 0 and "Actual supplier interface pin" in result.stderr, "Corrupt interface must fail") + save("EXTRA-REJECTION-CONTROLS.json", {"status": "PASS", "changed_moment_rejected": True, "changed_interface_bytes_rejected": True}) + + +source_check() +forward_query() +rejection_controls() +print("PASS_BELL_CACHE_INDEPENDENT_REVIEW_CHECKS") diff --git a/research/centre-polynomial-cache-limits/review/replay/ARITHMETIC-BOUNDS.json b/research/centre-polynomial-cache-limits/review/replay/ARITHMETIC-BOUNDS.json new file mode 100644 index 0000000000..c07c7fd0ac --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/replay/ARITHMETIC-BOUNDS.json @@ -0,0 +1,12 @@ +{ + "status": "PASS", + "bounds": { + "producer_R_transpose_sum": 262144, + "producer_R_sum": 3670016, + "review_sparse_row_sum": 14680064, + "moment_sum": 17591917608960, + "field_product": 4294967296, + "Bareiss_absolute_difference": 4294967296 + }, + "reason": "Every vector residue is between 0 and 65536. SHAKE observers are between 0 and 65535. Products in elimination have two nonnegative factors at most 65536; their difference has absolute value at most 65536 squared." +} diff --git a/research/centre-polynomial-cache-limits/review/replay/EXTRA-REJECTION-CONTROLS.json b/research/centre-polynomial-cache-limits/review/replay/EXTRA-REJECTION-CONTROLS.json new file mode 100644 index 0000000000..54bc72cb54 --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/replay/EXTRA-REJECTION-CONTROLS.json @@ -0,0 +1,5 @@ +{ + "status": "PASS", + "changed_moment_rejected": true, + "changed_interface_bytes_rejected": true +} diff --git a/research/centre-polynomial-cache-limits/review/replay/FORWARD-QUERY-REPRODUCED.json b/research/centre-polynomial-cache-limits/review/replay/FORWARD-QUERY-REPRODUCED.json new file mode 100644 index 0000000000..e787936acd --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/replay/FORWARD-QUERY-REPRODUCED.json @@ -0,0 +1,8 @@ +{ + "status": "PASS", + "scalar_gates": 10851, + "rows": 8, + "columns": 112, + "row_absolute_sum": 56, + "column_absolute_sum": 4 +} diff --git a/research/centre-polynomial-cache-limits/review/replay/SOURCE-BINDING-REPRODUCED.json b/research/centre-polynomial-cache-limits/review/replay/SOURCE-BINDING-REPRODUCED.json new file mode 100644 index 0000000000..b35a3c065c --- /dev/null +++ b/research/centre-polynomial-cache-limits/review/replay/SOURCE-BINDING-REPRODUCED.json @@ -0,0 +1,14 @@ +{ + "status": "PASS", + "archive_sha256": "22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754", + "members": { + "slots/local/CANONICAL-WORD.json.gz": { + "bytes": 84805, + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + "slots/local/LOCAL-PROGRAMS.json.gz": { + "bytes": 209318, + "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a" + } + } +} diff --git a/research/centre-polynomial-cache-limits/validation/PHASE-CACHE-CHECK.json b/research/centre-polynomial-cache-limits/validation/PHASE-CACHE-CHECK.json new file mode 100644 index 0000000000..3abadcc749 --- /dev/null +++ b/research/centre-polynomial-cache-limits/validation/PHASE-CACHE-CHECK.json @@ -0,0 +1,107 @@ +{ + "arithmetic": "fractions.Fraction over Q", + "cache_invariant_under_all_normal_directions": true, + "coordinate_dimensions": [ + 8, + 16, + 31, + 53, + 85, + 101, + 112, + 112, + 112, + 112 + ], + "explicit_cache_rank": 56, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "missing_projection_index": 0, + "normal_dimensions": [ + 8, + 15, + 28, + 44, + 44, + 56, + 56, + 56, + 56 + ], + "normal_directions": [ + 42, + 7, + 25, + 52, + 82, + 127, + 97, + 76 + ], + "normal_fiber_sizes_and_ranks": [ + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ] + ], + "query_rows_in_cache": true, + "removed_row_control_rejected": true, + "scope": "Finite counts and a basis construction for the pinned query. The written proof gives the general theorem. No native cost or kappa claim.", + "stacked_rank_histogram": { + "8": 2, + "15": 16, + "16": 494 + }, + "status": "PASS_EXACT_MINIMAL_SCALAR_CACHE_COUNTS" +} diff --git a/research/centre-polynomial-cache-limits/validation/REPLAY.json b/research/centre-polynomial-cache-limits/validation/REPLAY.json new file mode 100644 index 0000000000..81e014e9a1 --- /dev/null +++ b/research/centre-polynomial-cache-limits/validation/REPLAY.json @@ -0,0 +1,123 @@ +{ + "bell_independent_review_receipt_equal": true, + "bell_producer_receipt_equal": true, + "historical_source_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f", + "not_run": [ + "Full supplier replay", + "Native decoder", + "Selected frontier replay", + "Outer kappa calculation", + "Formal-kernel proof" + ], + "numpy_version": "2.5.4", + "phase_cache_check": { + "arithmetic": "fractions.Fraction over Q", + "cache_invariant_under_all_normal_directions": true, + "coordinate_dimensions": [ + 8, + 16, + 31, + 53, + 85, + 101, + 112, + 112, + 112, + 112 + ], + "explicit_cache_rank": 56, + "interface_sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3", + "missing_projection_index": 0, + "normal_dimensions": [ + 8, + 15, + 28, + 44, + 44, + 56, + 56, + 56, + 56 + ], + "normal_directions": [ + 42, + 7, + 25, + 52, + 82, + 127, + 97, + 76 + ], + "normal_fiber_sizes_and_ranks": [ + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ], + [ + 8, + 4 + ] + ], + "query_rows_in_cache": true, + "removed_row_control_rejected": true, + "scope": "Finite counts and a basis construction for the pinned query. The written proof gives the general theorem. No native cost or kappa claim.", + "stacked_rank_histogram": { + "15": 16, + "16": 494, + "8": 2 + }, + "status": "PASS_EXACT_MINIMAL_SCALAR_CACHE_COUNTS" + }, + "python_version": "3.14.7", + "source_files_checked": 17, + "status": "PASS_CENTRE_POLYNOMIAL_CACHE_LIMITS" +} diff --git a/research/centre-polynomial-cache-limits/validation/bell-producer-stderr.txt b/research/centre-polynomial-cache-limits/validation/bell-producer-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/centre-polynomial-cache-limits/validation/bell-producer-stdout.txt b/research/centre-polynomial-cache-limits/validation/bell-producer-stdout.txt new file mode 100644 index 0000000000..7bfeefede7 --- /dev/null +++ b/research/centre-polynomial-cache-limits/validation/bell-producer-stdout.txt @@ -0,0 +1,2 @@ +PASS_EXACT_CHARACTERISTIC_ZERO_GRAM_DEGREE_LOWER_BOUND +{"hankel_determinant_mod_prime": 2984, "hankel_size": 409, "moments_sha256": "a438880f142ea5c0a53120246fa5aed60c36db1d8052c911b485345fcb332150"} diff --git a/research/centre-polynomial-cache-limits/validation/bell-review-stderr.txt b/research/centre-polynomial-cache-limits/validation/bell-review-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/centre-polynomial-cache-limits/validation/bell-review-stdout.txt b/research/centre-polynomial-cache-limits/validation/bell-review-stdout.txt new file mode 100644 index 0000000000..17efc32524 --- /dev/null +++ b/research/centre-polynomial-cache-limits/validation/bell-review-stdout.txt @@ -0,0 +1,2 @@ +PASS_INDEPENDENT_EXACT_BELL_GRAM_DEGREE_CERTIFICATE +{"hankel_determinant_mod_prime": 2984, "integer_operator_nonzero_entries": 499072} diff --git a/research/centre-polynomial-cache-limits/validation/phase-cache-stderr.txt b/research/centre-polynomial-cache-limits/validation/phase-cache-stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/centre-polynomial-cache-limits/validation/phase-cache-stdout.txt b/research/centre-polynomial-cache-limits/validation/phase-cache-stdout.txt new file mode 100644 index 0000000000..5e6d1b4426 --- /dev/null +++ b/research/centre-polynomial-cache-limits/validation/phase-cache-stdout.txt @@ -0,0 +1 @@ +PASS_EXACT_MINIMAL_SCALAR_CACHE_COUNTS