From 080432fb715e1a9cda5a3affa9128bb579ae7652 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 18 Nov 2026 21:16:19 +0000 Subject: [PATCH 1/2] feat(research): compute the four-qubit Clifford width-nine rank --- .../PROJECTION.json | 87 +++++++++ .../clifford-four-qubit-width-nine/README.md | 182 ++++++++++++++++++ .../SOURCES.json | 30 +++ .../clifford-four-qubit-width-nine/TASK.json | 102 ++++++++++ .../VERIFY.json | 23 +++ .../clifford-four-qubit-width-nine/verify.py | 179 +++++++++++++++++ 6 files changed, 603 insertions(+) create mode 100644 research/clifford-four-qubit-width-nine/PROJECTION.json create mode 100644 research/clifford-four-qubit-width-nine/README.md create mode 100644 research/clifford-four-qubit-width-nine/SOURCES.json create mode 100644 research/clifford-four-qubit-width-nine/TASK.json create mode 100644 research/clifford-four-qubit-width-nine/VERIFY.json create mode 100644 research/clifford-four-qubit-width-nine/verify.py diff --git a/research/clifford-four-qubit-width-nine/PROJECTION.json b/research/clifford-four-qubit-width-nine/PROJECTION.json new file mode 100644 index 0000000000..406f84b469 --- /dev/null +++ b/research/clifford-four-qubit-width-nine/PROJECTION.json @@ -0,0 +1,87 @@ +{ + "class_counts": [14, 16, 20, 12, 10, 4, 3, 1, 1], + "element_counts": [19871236096, 19871232000, 6623744000, 946249920, 63083328, 2034900, 32300, 255, 1], + "rows": [ + [1, 19871232000, 6623744000, 946249920, 63083328, 2034900, 32300, 255], + [35, -6624092160, 4415756800, -1261552320, 168218400, -10859940, 345100, -5355], + [51, -6624092160, 4415669760, -1261552320, 168241248, -10859940, 343740, -5355], + [85, -13247139840, 8831774720, -2523447360, 336436800, -21698460, 689180, -10965], + [119, 0, 6623787520, 2838749760, 441571872, 30523500, 1001980, 16065], + [135, 0, 6623700480, 2838749760, 441594720, 30523500, 1000620, 16065], + [238, 1023590400, -219950080, -198092160, 94202304, -14351400, 918680, -24990], + [510, -576552960, -753331200, 59633280, 111384000, 20948760, 1479000, 44370], + [595, -541040640, -730831360, 49008960, 108013920, 21355740, 1611260, 51765], + [595, -36556800, -15232000, 11995200, 1599360, -749700, -59500, 8925], + [918, 1015234560, -204456960, -195350400, 89861184, -14522760, 1119960, -22950], + [1190, -584908800, -737838080, 62375040, 107042880, 20777400, 1680280, 46410], + [1275, -532684800, -731788800, 46267200, 108813600, 21527100, 1555500, 49725], + [1512, 3948134400, -888330240, -748500480, 369726336, -59119200, 4112640, -128520], + [1785, -570286080, -37470720, 171702720, -26560800, -6875820, 1663620, -101745], + [1785, -1118638080, -1476894720, 110013120, 217627200, 41961780, 3163020, 112455], + [2295, 4963368960, -1103362560, -944879040, 462157920, -73320660, 5113260, -167535], + [2856, -2193408000, -2935511040, 205632000, 433335168, 84823200, 6397440, 214200], + [2856, 3948134400, -895641600, -748500480, 371645568, -59119200, 3998400, -128520], + [2975, -255897600, 6092800, 73684800, -17707200, -2034900, 987700, -98175], + [2975, 4971724800, -1104320000, -947620800, 462957600, -73149300, 5057500, -169575], + [3213, 658022400, 435939840, -194322240, -66933216, 6747300, 2634660, 176715], + [3213, 5988003840, -1316044800, -1144342080, 554589504, -87329340, 6104700, -208845], + [3400, -2193408000, -2938470400, 205632000, 434112000, 84823200, 6351200, 214200], + [3570, -219340800, -91392000, 71971200, 9596160, -4498200, -357000, 53550], + [3570, -2237276160, -2953789440, 220026240, 435254400, 83923560, 6326040, 224910], + [3570, -1140572160, -74941440, 343405440, -53121600, -13751640, 3327240, -203490], + [3808, -877363200, -53616640, 263208960, -41857536, -10281600, 2589440, -171360], + [4200, -2193408000, -2942822400, 205632000, 435254400, 84823200, 6283200, 214200], + [4760, 848117760, 569067520, -249500160, -87964800, 8396640, 3465280, 242760], + [5712, 175472640, 248586240, -49351680, -50448384, 1028160, 2170560, 85680], + [5950, -511795200, 12185600, 147369600, -35414400, -4069800, 1975400, -196350], + [5950, 219340800, 39603200, -71971200, 3998400, 4498200, -452200, -53550], + [7140, -263208960, 113326080, 78140160, -44553600, -2827440, 2199120, -64260], + [8160, -877363200, -77291520, 263208960, -35642880, -10281600, 2219520, -171360], + [8925, 877363200, 635174400, -251899200, -101959200, 6747300, 4034100, 348075], + [8925, -658022400, -105100800, 200491200, -14565600, -8675100, 1035300, -80325], + [8960, -2339635200, -136478720, 701890560, -113326080, -27417600, 7006720, -456960], + [9639, -592220160, -246758400, 194322240, 25909632, -12145140, -963900, 144585], + [10200, -2068070400, -96614400, 616896000, -106243200, -23133600, 6446400, -459000], + [11900, -731136000, -304640000, 239904000, 31987200, -14994000, -1190000, 178500], + [11900, 438681600, 79206400, -143942400, 7996800, 8996400, -904400, -107100], + [13056, 1804861440, 1245020160, -526417920, -195213312, 16450560, 7703040, 587520], + [13600, -167116800, 309862400, 54835200, -86822400, -3427200, 4025600, 40800], + [14280, -877363200, -365568000, 287884800, 38384640, -17992800, -1428000, 214200], + [14280, -2017935360, -102359040, 600445440, -101445120, -22105440, 6111840, -471240], + [14688, 1579253760, 1071636480, -460615680, -166150656, 14394240, 6462720, 514080], + [16065, 723824640, 625121280, -194322240, -107956800, 1349460, 4305420, 498015], + [16065, 789626880, 567544320, -223110720, -89964000, 4948020, 3405780, 369495], + [16065, 921231360, 452390400, -280687680, -53978400, 12145140, 1606500, 112455], + [16065, -2632089600, -90478080, 780373440, -143428320, -27953100, 8546580, -658665], + [16065, 1118638080, 279659520, -367053120, 0, 22940820, -1092420, -273105], + [17850, 1754726400, 1270348800, -503798400, -203918400, 13494600, 8068200, 696150], + [17850, -1316044800, -210201600, 400982400, -29131200, -17350200, 2070600, -160650], + [18360, 1015234560, 549918720, -304335360, -71971200, 11823840, 2350080, 201960], + [19040, 1579253760, 1047961600, -460615680, -159936000, 14394240, 6092800, 514080], + [23800, -1900953600, -115763200, 562060800, -90249600, -19706400, 5331200, -499800], + [23800, -2047180800, 48742400, 589478400, -141657600, -16279200, 7901600, -785400], + [26775, -2303078400, 54835200, 663163200, -159364800, -18314100, 8889300, -883575], + [26775, -1645056000, -685440000, 539784000, 71971200, -33736500, -2677500, 401625], + [28560, -350945280, -270520320, 115153920, 47980800, -7197120, -2513280, 85680], + [28917, -2368880640, -74027520, 694008000, -130473504, -22555260, 7518420, -722925], + [30464, -2339635200, -253460480, 701890560, -82618368, -27417600, 5178880, -456960], + [32130, 1579253760, 1135088640, -446221440, -179928000, 9896040, 6811560, 738990], + [32130, -921231360, -477066240, 302279040, 64774080, -18892440, -2955960, 224910], + [32130, 2237276160, 559319040, -734106240, 0, 45881640, -2184840, -546210], + [34425, 1551052800, 1339545600, -416404800, -231336000, 2891700, 9225900, 1067175], + [34425, 2397081600, 599270400, -786542400, 0, 49158900, -2340900, -585225], + [34560, 1804861440, 1128038400, -526417920, -164505600, 16450560, 5875200, 587520], + [38080, -2339635200, -974848000, 767692800, 102359040, -47980800, -3808000, 571200], + [38556, -2368880640, -987033600, 777288960, 103638528, -48580560, -3855600, 578340], + [42525, 2961100800, 740275200, -971611200, 0, 60725700, -2891700, -722925], + [42525, 2961100800, 740275200, -971611200, 0, 60725700, -2891700, -722925], + [43520, 534773760, -61276160, -175472640, 51179520, 10967040, -3568640, -130560], + [47600, 1754726400, 316825600, -575769600, 31987200, 35985600, -3617600, -428400], + [48195, -2961100800, -1233792000, 971611200, 129548160, -60725700, -4819500, 722925], + [51408, 1052835840, 65802240, -345461760, 51819264, 21591360, -4112640, -257040], + [53550, 1974067200, 356428800, -647740800, 35985600, 40483800, -4069800, -481950], + [57120, -701890560, -541040640, 230307840, 95961600, -14394240, -5026560, 171360], + [65536, 0, -356515840, 0, 93585408, 0, -5570560, 0], + [68850, -1974067200, -1022284800, 647740800, 138801600, -40483800, -6334200, 481950] + ] +} diff --git a/research/clifford-four-qubit-width-nine/README.md b/research/clifford-four-qubit-width-nine/README.md new file mode 100644 index 0000000000..d31d4d24c9 --- /dev/null +++ b/research/clifford-four-qubit-width-nine/README.md @@ -0,0 +1,182 @@ +# Exact width-nine rank for the four-qubit Clifford alphabet + +This scoped proof was produced by Nick Petalas. For the full projective +four-qubit Gaussian-dyadic Clifford alphabet, the tensor Gram matrix at +width nine has **rank 10,107,260,791,808** out of **12,128,668,876,800**. +Its nullity is **2,021,408,084,992**. In particular, the pointwise +tensor-independence threshold satisfies **T(4) ≥ 10**. + +This answers the width-nine step of alephnan's four-qubit question. The +calculation reduces the Gram rank to 81 exact character inner products in +\(\operatorname{Sp}(8,2)\). Twenty quotient irreducibles are absent. +[PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714) + +## Proof + +### From tensor rank to quotient characters + +Let \(G\) be the group of all four-qubit unitary Clifford matrices over +\(\mathbb Z[i,1/2]\), \(V\) its 16-dimensional natural representation, and +\(P\) its Pauli subgroup including \(z=iI\). The scalar kernel has order +four. The Gaussian-dyadic phase gate, the Gaussian-dyadic version +\((1+i)H/\sqrt{2}\) of the normalized Hadamard \(H\), and CNOT realize the +usual symplectic generators. Consequently \(S=G/P=\operatorname{Sp}(8,2)\) +and \(|G/\langle z\rangle|=256|S|\). + +In the central sector \(z\mapsto i\) every irreducible of \(G\) has the +form \(V\otimes\sigma\) for a unique \(\sigma\in\operatorname{Irr}(S)\). +The restriction of \(V\) to \(P\) is the unique irreducible with that +central character. For any representation \(R\) in this sector, +\(\operatorname{Hom}_P(V,R)\) is a quotient representation under the +action \(\phi\mapsto R(g)\phi V(g)^{-1}\), and evaluation recovers +\(R\). Write \(V^{\otimes 9}=V\otimes W\) in this way. +These are the odd-sector reductions used for three qubits in the pinned +predecessor. [PR #6714, proof §§1–3](../clifford-three-qubit-threshold/PROOF.md) + +For \(s\in S\), write \(d(s)=\dim\ker(s-I)\) on the symplectic label +space. A lift of \(s\) acts by signed permutation of the Hermitian Pauli +basis. Its adjoint trace is the sum of its signs on fixed labels. +Those signs form a character on the fixed space by multiplicativity of +Pauli conjugation. Multiplication of the lift by a Pauli adds an arbitrary +binary character on the fixed space, by nondegeneracy of the symplectic +pairing on the full label space. Hence a lift \(g\) exists with +\(|\operatorname{tr}V(g)|^2=2^{d(s)}\). For a Gaussian-dyadic trace of +this squared modulus, clearing a power-of-two denominator and repeatedly +dividing out common factors of two shows that the trace is on an axis or +a diagonal of the Gaussian plane. Its eighth power is \(2^{4d(s)}\). +The trace is nonzero, so the tensor factorization gives + +\[ +\chi_W(s)=\operatorname{tr}(V(g))^8 = 2^{4d(s)}. +\] + +This is the permutation character on ordered four-tuples of vectors in +\(\mathbb F_2^8\). It includes the zero vector in each coordinate. + +### Identifying the fixed dimensions + +The permutation character on all vectors is +\(2+\chi_{119}+\chi_{135}\). To see this, the action on quadratic +refinements of the symplectic form has the same fixed-point count as +the action on vectors. For any \(s\), start with a refinement \(Q\). +The functional \(Q\circ s-Q\) is linear and vanishes on \(\ker(s-I)\). +It is therefore \(\ell\circ(s-I)\) for a linear \(\ell\), so \(Q+\ell\) +is fixed. All other fixed refinements differ by an \(s\)-invariant +functional, giving exactly \(2^{d(s)}\) of them. + +The refinement orbits of the two Arf signs have sizes 120 and 136. +For example, writing \(Q(a,b)=a\cdot b+\alpha\cdot a+\beta\cdot b\), +the sign is determined by \(\alpha\cdot\beta\) and counting the pairs +gives the sizes. For fixed \(Q\), refinements of its sign other than +itself correspond to nonzero singular vectors via +\(v\mapsto Q+\omega(v,\cdot)\). Witt's lemma makes the stabilizer of +\(Q\) transitive on those vectors. Each orbit action is thus doubly +transitive and its augmentation character is irreducible. Their degrees +are 119 and 135, unique in the ordinary table. [Independent identification of the orbit characters](https://link.springer.com/article/10.1007/s13370-024-01197-2) + +### Exact inner products and nullity + +Use the ordinary `S8(2)` table in Thomas Breuer's GAP Character Table +Library, release 1.3.11, which attributes this table to the ATLAS. +For row \(i\) of degree \(b_i\), define the integer +\(A_{i,d}=\sum_{C:d(C)=d}|C|\chi_i(C)\) for \(1\le d\le 7\), +summing over conjugacy classes \(C\). The unique dimension-eight column +is the identity. Subtract the trivial character from \(\chi_W\) to +eliminate every dimension-zero column. In the positive-dimension columns +all table values are integers. Row 73 is Galois conjugate to row 72 and +has the same retained values. Therefore the multiplicities are + +\[ +m_i = \mathbf 1_{i=1} + +\frac{b_i(2^{32}-1)+\sum_{d=1}^7 A_{i,d}(2^{4d}-1)}{47{,}377{,}612{,}800}. +\] + +[PROJECTION.json](PROJECTION.json) records the degree and seven sums +for each row in library order. The zero multiplicities occur at rows +\(2,4,7,14,15,17,20,23,27,32,38,40,51,52,58,59,66,68,72,73\). +The sum of their squared quotient degrees is \(7{,}896{,}125{,}332\). +[CTblLib 1.3.11 and source information](https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/) + +The group algebra ideal with central character \(i\) has a basis indexed +by projective classes. By semisimplicity its block for \(V\otimes\sigma\) +has dimension \((16\dim\sigma)^2\), and tensor evaluation is injective +on that block precisely when it occurs. The missing blocks thus have +total dimension \(256\cdot7{,}896{,}125{,}332=2{,}021{,}408{,}084{,}992\). +Subtracting from \(256|S|\) gives the stated Gram rank. The normalized +Gram matrix at width \(f+1\) is the Schur product of those at widths +\(f\) and one. Since the latter has unit diagonal, positive definiteness +at any earlier width would propagate to width nine. + +### Checks independent of the table arithmetic + +The verifier counts symplectic orbits on ordered \(k\)-tuples for +\(0\le k\le 8\) by Witt's lemma. Regard a tuple as a linear map from +\(\mathbb F_2^k\) into the label space. An orbit is specified by the +kernel and the alternating form induced on the quotient. For quotient +dimension \(r\) and radical dimension \(u\), the form embeds exactly +when \(r+u\le8\). There are \({k\brack r}_2\) kernels, +\({r\brack u}_2\) radicals, and +\(|\mathrm{GL}(r-u,2)|/|\mathrm{Sp}(r-u,2)|\) nondegenerate forms +on the remaining quotient. This follows by choosing the radical and +using transitivity of \(\mathrm{GL}\) on symplectic bases up to the form's +stabilizer. + +Burnside's lemma then checks each of the nine moments of the +fixed-dimension histogram. The verifier also checks +\(\sum_i b_i^2=|S|\), \(\sum_i b_i m_i=2^{32}\), and +\(\sum_i m_i^2\) against the eight-tuple orbit count. Two failure +controls change one character sum and move one element between +fixed-dimension bins, respectively. + +## Reproduce + +Run these from the repository root with CPython 3.12.15 and the standard +library. + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-four-qubit-width-nine +python3.12 -B scripts/check_research_commit.py --package research/clifford-four-qubit-width-nine --check-source-history +python3.12 -B -W error research/clifford-four-qubit-width-nine/verify.py +``` + +The registered replay uses the derived integer projection as input. To +rederive every projection entry from the external table, run the following +optional check. It authenticates the release archive and exact table member +before reading the 81 rows and compares the complete projection. + +```sh +scratch_dir=$(mktemp -d) +curl -fsSL 'https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz' \ + -o "$scratch_dir/ctbllib-1.3.11.tar.gz" +python3.12 -B -W error research/clifford-four-qubit-width-nine/verify.py \ + --ctbllib-archive "$scratch_dir/ctbllib-1.3.11.tar.gz" +``` + +The archive SHA-256 is +`f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434`. +The SHA-256 of `ctbllib-1.3.11/data/ctosymp1.tbl` is +`461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f`. +The proof takes the published ordinary character table as input. +Formal proof-kernel review remains open. The computation concerns exact +Clifford operators at one width. It leaves physical implementation, +recursive costs and the five selected framework assumptions outside +its scope. + +## Open next questions + +- Is width ten already independent? Use the twenty missing odd-sector + rows as the only possible constituents of the reciprocity obstruction + for a missing even-sector irreducible. The remaining step is to rule + out, or realize, such a combination using the two quadratic-form + stabilizers. The width-nine rank alone does not decide this. + +## Credit + +Credit alephnan's [PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714) +for the four-qubit question and the odd-sector reduction, Ali Romman's +[PR #5526](https://github.com/CrocSwap/integer-mult-bounds/pull/5526) for the +pointwise framework, and Nick Petalas's +[PR #5967](https://github.com/CrocSwap/integer-mult-bounds/pull/5967) for the +general lower bound \(2n+1\). The published character table data are +credited to the ATLAS and Thomas Breuer's CTblLib. The new calculation, +proof and checker are Apache-2.0. diff --git a/research/clifford-four-qubit-width-nine/SOURCES.json b/research/clifford-four-qubit-width-nine/SOURCES.json new file mode 100644 index 0000000000..1ad5bd2e2e --- /dev/null +++ b/research/clifford-four-qubit-width-nine/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/clifford-three-qubit-threshold/PROOF.md", + "usage": "input", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0" + }, + { + "path": "research/clifford-three-qubit-threshold/README.md", + "usage": "input", + "git_blob": "de2ba2b2222ea47f0f0e17e5616d27e47c3df839", + "sha256": "f423d61edea2e1975ec3e466edd95ea308dcd1a6e8d2d1ba820209da07f10c87" + } + ] +} diff --git a/research/clifford-four-qubit-width-nine/TASK.json b/research/clifford-four-qubit-width-nine/TASK.json new file mode 100644 index 0000000000..819c9ff42e --- /dev/null +++ b/research/clifford-four-qubit-width-nine/TASK.json @@ -0,0 +1,102 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Determine the exact rank of the width-nine full projective four-qubit Gaussian-dyadic Clifford tensor Gram.", + "scope_change_reason": "The first open question in alephnan's PR #6714 calls for a bounded four-qubit character calculation. This written algebraic side result addresses that step outside the original formal caller gate.", + "bottleneck_link": "Pointwise tensor independence is one exact native-algebra tool. The result supplies an obstruction at width nine without supplying a paid native caller.", + "budget_minutes": 60, + "stop_rule": "Stop after the width-nine multiplicities and rank replay from the pinned ordinary character table.", + "outcome": "completed", + "claim_type": "scoped proof", + "evidence": "81 exact quotient multiplicities, 20 missing rows, Gram rank 10107260791808, nullity 2021408084992, an independent nine-moment histogram check, and two rejection controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Is the full four-qubit Clifford tensor Gram independent at width ten?", + "why_it_matters": "Width-ten independence would make the new lower bound sharp.", + "first_step": "Apply tensor reciprocity to the twenty missing width-nine rows and test the two quadratic-form stabilizer restrictions.", + "blocked_by": "The admissible even-sector multiplicity spaces have not been determined." + } + ], + "verified_python": "CPython 3.12.15", + "predecessor": { + "pull_request": 6714, + "author": "alephnan", + "head": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0" + } +} diff --git a/research/clifford-four-qubit-width-nine/VERIFY.json b/research/clifford-four-qubit-width-nine/VERIFY.json new file mode 100644 index 0000000000..659494422c --- /dev/null +++ b/research/clifford-four-qubit-width-nine/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/clifford-three-qubit-threshold/PROOF.md", + "research/clifford-three-qubit-threshold/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Check all 81 multiplicities and the Gram rank. Check the nine fixed-dimension histogram moments by a separate tuple orbit count and reject two altered inputs." + } + ] +} diff --git a/research/clifford-four-qubit-width-nine/verify.py b/research/clifford-four-qubit-width-nine/verify.py new file mode 100644 index 0000000000..4914eea276 --- /dev/null +++ b/research/clifford-four-qubit-width-nine/verify.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +"""Verify the width-nine quotient calculation, optionally from its source archive.""" + +import argparse +from hashlib import sha256 +from io import BytesIO +import json +from math import prod +from pathlib import Path +import re +import tarfile + +ORDER = 47_377_612_800 +N_CLASSES = 81 +ARCHIVE_SHA256 = "f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434" +TABLE_SHA256 = "461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f" +TABLE_MEMBER = "ctbllib-1.3.11/data/ctosymp1.tbl" +MISSING_ROWS = [2, 4, 7, 14, 15, 17, 20, 23, 27, 32, 38, 40, 51, 52, 58, 59, 66, 68, 72, 73] + + +def require(test, message): + if not test: + raise ValueError(message) + + +def read_bounded(path, limit): + with path.open("rb") as stream: + data = stream.read(limit + 1) + require(len(data) <= limit, f"{path.name} exceeds its byte bound") + return data + + +def read_table(archive): + raw = read_bounded(archive, 20 * 1024 * 1024) + require(sha256(raw).hexdigest() == ARCHIVE_SHA256, "CTblLib archive hash") + with tarfile.open(fileobj=BytesIO(raw), mode="r:gz") as tar: + member = tar.getmember(TABLE_MEMBER) + require(member.isfile() and 0 < member.size < 256 * 1024, "table member size") + stream = tar.extractfile(member) + require(stream is not None, "missing table payload") + with stream: + data = stream.read(member.size + 1) + require(sha256(data).hexdigest() == TABLE_SHA256, "CTblLib table hash") + return data.decode("ascii") + + +def table_projection(table): + block = table.split('MOT("S8(2)",\n', 1)[1].split('\nARC("S8(2)"', 1)[0] + numbers = block.split("],\n", 1)[1] + centralizers = json.loads(numbers.split("],\n", 1)[0] + "]") + # This sequence follows the power-map argument in the MOT record. + entries = block.split("\n[[1,1,1,", 1)[1].split("]],\n", 1)[0] + entries = re.sub(r"\s+", "", "1,1,1," + entries) + require(entries.count("[GALOIS,[72,3]]") == 1, "Galois row") + entries = entries.replace("[GALOIS,[72,3]]", "GALOIS") + rows = [row.split(",") for row in re.split(r"\],\[|\],(?=GALOIS)|(?<=GALOIS),\[", entries)] + require(len(centralizers) == len(rows) == N_CLASSES, "table dimensions") + require(rows[72] == ["GALOIS"], "Galois row index") + # Galois rows agree on rational values. The only irrational entries + # occur on dimension-zero columns, which carry zero weight. + rows[72] = rows[71] + require(all(len(row) == N_CLASSES for row in rows), "table row lengths") + fixed = [2 + int(a) + int(b) for a, b in zip(rows[4], rows[5], strict=True)] + require([int(rows[i][0]) for i in (4, 5)] == [119, 135], "point character rows") + require(all(1 <= n <= 256 and n.bit_count() == 1 for n in fixed), "fixed-point powers") + dims = [n.bit_length() - 1 for n in fixed] + require(all(c > 0 and ORDER % c == 0 for c in centralizers), "centralizers") + sizes = [ORDER // c for c in centralizers] + columns = [tuple(j for j, dim in enumerate(dims) if dim == d) for d in range(9)] + require(columns[8] == (0,) and sizes[0] == 1, "identity class") + return { + "class_counts": [len(column) for column in columns], + "element_counts": [sum(sizes[j] for j in column) for column in columns], + "rows": [ + [int(row[0]), *(sum(sizes[j] * int(row[j]) for j in column) + for column in columns[1:8])] + for row in rows + ], + } + + +def gaussian_binomial(n, r): + """Number of r-subspaces of a binary n-space for 0 <= r <= n <= 8.""" + top = prod(2**n - 2**i for i in range(r)) + bottom = prod(2**r - 2**i for i in range(r)) + return top // bottom + + +def tuple_orbits(length): + """Count ordered-tuple orbits by the kernel and induced alternating form.""" + result = 0 + for rank in range(length + 1): + for radical in range(rank % 2, rank + 1, 2): + if rank + radical > 8: + continue + even = rank - radical + gl_order = prod(2**even - 2**i for i in range(even)) + half = even // 2 + sp_order = 2**(half**2) * prod(2**(2*i) - 1 for i in range(1, half + 1)) + result += (gaussian_binomial(length, rank) + * gaussian_binomial(rank, radical) * (gl_order // sp_order)) + return result + + +def check_projection(data): + class_counts = data["class_counts"] + elements = data["element_counts"] + rows = data["rows"] + require(len(class_counts) == len(elements) == 9 and len(rows) == N_CLASSES, "projection shape") + require(all(type(c) is int and 1 <= c <= N_CLASSES for c in class_counts), "class counts") + require(all(type(e) is int and 1 <= e <= ORDER for e in elements), "element counts") + require(sum(class_counts) == N_CLASSES and sum(elements) == ORDER, "class coverage") + require(class_counts[8] == elements[8] == 1, "single identity") + require(all(len(row) == 8 for row in rows), "projected row lengths") + for degree, *sums in rows: + require(type(degree) is int and 1 <= degree <= 68_850, "character degree") + require(all(type(s) is int and abs(s) <= degree * e + for s, e in zip(sums, elements[1:8], strict=True)), "character sum bounds") + + for length in range(9): + mass = sum(count * 2**(d * length) for d, count in enumerate(elements)) + require(mass == ORDER * tuple_orbits(length), "independent tuple orbit count") + + degrees = [row[0] for row in rows] + require(degrees[0] == 1 and sum(d * d for d in degrees) == ORDER, "degree square sum") + multiplicities = [] + for i, (degree, *sums) in enumerate(rows): + moment = degree * (2**32 - 1) + moment += sum(value * (2**(4*d) - 1) for d, value in enumerate(sums, 1)) + quotient, remainder = divmod(moment, ORDER) + require(remainder == 0 and quotient >= 0, "nonintegral or negative multiplicity") + multiplicities.append(quotient + (i == 0)) + require(sum(m * d for m, d in zip(multiplicities, degrees, strict=True)) == 2**32, + "multiplicity dimension sum") + require(sum(m * m for m in multiplicities) == tuple_orbits(8), "character norm") + return degrees, multiplicities + + +def require_rejected(data, reason): + try: + check_projection(data) + except ValueError as error: + require(str(error) == reason, f"unexpected control failure: {error}") + return + raise ValueError(f"control accepted: {reason}") + + +def check_controls(data): + rows = [row.copy() for row in data["rows"]] + rows[1][1] += 1 + require_rejected({**data, "rows": rows}, "nonintegral or negative multiplicity") + elements = data["element_counts"].copy() + elements[0] -= 1 + elements[1] += 1 + require_rejected({**data, "element_counts": elements}, "independent tuple orbit count") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--ctbllib-archive", type=Path, help="optional CTblLib 1.3.11 release archive") + args = parser.parse_args() + data = json.loads(read_bounded(Path(__file__).with_name("PROJECTION.json"), 64 * 1024)) + if args.ctbllib_archive is not None: + require(table_projection(read_table(args.ctbllib_archive)) == data, "source projection differs") + print("PASS_CTBL_SOURCE_PROJECTION classes=81 rows=81") + degrees, multiplicities = check_projection(data) + check_controls(data) + missing = [i for i, m in enumerate(multiplicities, 1) if m == 0] + require(missing == MISSING_ROWS, "missing character row indices") + nullity = 256 * sum(degrees[i - 1]**2 for i in missing) + rank = 256 * ORDER - nullity + require((rank, nullity) == (10_107_260_791_808, 2_021_408_084_992), "Gram dimension result") + print(f"PASS_CLIFFORD_FOUR_QUBIT_WIDTH_NINE classes={N_CLASSES} " + f"present={N_CLASSES - len(missing)} missing={len(missing)} rank={rank} nullity={nullity} " + "tuple_moments=9 controls=2") + + +if __name__ == "__main__": + main() From ff12ca358d601a21cd4b1f016b8a3a969ac44016 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Wed, 18 Nov 2026 21:19:47 +0000 Subject: [PATCH 2/2] fix(ci): sync CI verification doc and historical replay-gap verifier --- docs/ci-verification.md | 19 +++++- .../historical-selected-replay-gap/README.md | 6 +- .../SOURCES.json | 60 +++++++++--------- .../VERIFY.json | 31 +-------- .../historical-selected-replay-gap/verify.py | 63 ++++++++++++++----- 5 files changed, 100 insertions(+), 79 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9")