diff --git a/research/schur-whole-central-class/NOTICE.md b/research/schur-whole-central-class/NOTICE.md new file mode 100644 index 0000000000..9a99ccf7a1 --- /dev/null +++ b/research/schur-whole-central-class/NOTICE.md @@ -0,0 +1,27 @@ +# Attribution and source availability + +New central-class proof, classifier and independent invariant checks: Ali +Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +The frozen files in vendor are byte-exact copies of ssafwann's +[PR #5256](https://github.com/CrocSwap/integer-mult-bounds/pull/5256), head +c72d6ff431cf5c979f5010018d8eba0c15577bce, and +[PR #5267](https://github.com/CrocSwap/integer-mult-bounds/pull/5267), head +8ab280c8a3ef0544f13ff23a1c69df4757cd4900. They are prepared for ssafwann +with substantial OpenAI Codex assistance, under Apache-2.0. The first source +supplies the exact fixture constructor, matrix helpers and ordered block action; +the second supplies the nilpotent representative, existing odd-field result +and open characteristic-two question. Both original proof/credit documents +are retained because the new proof uses their contracts. + +SOURCES.json records original commits, paths, blobs and SHA256, and binds the +same bytes to an ancestor in this publication history. A clean registered +replay does not require an unmerged upstream object. No predecessor is edited. + +Retain Nick Petalas's #4597/#4746/#4801/#4915, MatShep's #4762, codyw912's +#4735, ssafwann's #4657/#4671/#4678, Ryanson Jonathan's #4609/#4617, lee-phys, +Mihir Srivastava, JoyboyBrian, Krzysztof Wojt, Cinna Davis and the source527 / +commdata2338 / Jose Manuel lineage exactly as documented in the retained +sources. These results and the generic factor-extension/counting methods are +not our new work. Classical primary decomposition, nilpotent Jordan chains +and Faddeev-LeVerrier retain their standard attribution. diff --git a/research/schur-whole-central-class/PROOF.md b/research/schur-whole-central-class/PROOF.md new file mode 100644 index 0000000000..223069d517 --- /dev/null +++ b/research/schur-whole-central-class/PROOF.md @@ -0,0 +1,156 @@ +# Reconstruct the whole central operator from the sharp image + +## Contract and statement + +Work over any field F. Let P,Q be commuting idempotents with a common leading +identity block I_d. Let S,T be their Schur complements on a residual space V +of dimension m. Put H=(PQ)_11, K=ST-TS, Z=(S-T)^2, and require rank K=2d. +This is the sharp-image hypothesis. It is not optional. + +The complete similarity class of Z is determined by H, m and the one integer + + a_1 = dim(ker S intersect ker(T-I)) + + dim(ker(S-I) intersect ker T). + +The result concerns the central operator Z. It does not classify the ordered +pair (S,T), count headers or give a probability law. It covers nonnilpotent H, +non-split primary components, repeated roots and characteristic two. + +The credited block action in ssafwann's [PR #5256](https://github.com/CrocSwap/integer-mult-bounds/pull/5256) +identifies M=im K with F^(2d). Set J=H(I-H) and Theta=2H-H^2. In this basis, + + D = Z|M = diag(Theta,Theta), + B = K|M = [ J 2(I-H); -J -J ]. (1) + +The second equation follows by taking the commutator of the source's ordered +matrices U_H and V_H. Thus B and D commute and B^2=D(D-I). The unchanged +source proof and fixture construction are retained in vendor, with exact +original and retained-history pins. Their proof and attribution remain intact. + +For lambda=0,1, let M_lambda=ker(D-lambda I)^(2d). Compute the nilpotent Jordan +block sizes j_(lambda,1),...,j_(lambda,c_lambda) of B on M_lambda. Set + + a_0 = m-2d-a_1. + +Then the lambda-primary Jordan blocks of Z are: + +- for each j_(lambda,i), one block of length ceil((j_(lambda,i)+1)/2) + and one of length floor((j_(lambda,i)+1)/2); +- a_lambda-c_lambda additional blocks of length one. + +The remaining primary part is exactly D restricted to +im((D(D-I))^(2d)). This is an invariant complement to M_0+M_1 and gives a +representative over F itself. No splitting field is needed for this part. +For an admitted source pair, both extra multiplicities are nonnegative. + +## Proof + +For any two idempotents S,T, direct expansion gives + + K^2=Z(Z-I), ZS=SZ, ZT=TZ, + KS=(I-S)K, KT=(I-T)K. (2) + +These are credited projector identities from the retained Schur lineage. +In particular ker K is invariant under both S and T. Their restrictions +commute on ker K. The four joint eigensectors therefore split ker K over +every field, including characteristic two. On the equal sectors 00 and11, +Z is zero. On the opposite sectors 01 and10, Z is identity. Rank-nullity gives + + dim ker K = m-2d = a_0+a_1. (3) + +Decompose V into its Z-primary spaces at0, at1, and away from these endpoints. +On the last part, Z(Z-I) is invertible. Equation (2) makes K invertible there, +so that entire part is contained in im K. Its Z action is therefore exactly +the non-endpoint restriction of D in (1). + +On V_lambda, lambda=0 or1, K is nilpotent: its square is the product of a +nilpotent operator and a commuting invertible operator. Moreover +M intersect V_lambda is im(K|V_lambda). On ker K within V_lambda, equation +(2) forces Z=lambda I, so the kernel dimension of K|V_lambda is a_lambda. + +A nilpotent Jordan block of K of length ell>=2 induces on its image a block +of length ell-1. A block of length one has zero image. Thus every block j of +B|M_lambda comes from exactly one block j+1 of K|V_lambda. The remaining +blocks of K have length one, and their number is a_lambda-c_lambda. + +The factor of Z(Z-I) other than Z-lambda I is invertible on V_lambda and +commutes with K. Therefore, for every positive integer r, + + rank((Z-lambda I)^r | V_lambda) + = rank(K^(2r) | V_lambda). (4) + +These ranks determine the nilpotent Jordan partition. Squaring a nilpotent +block of length ell splits its chain into the odd and even positions, with +lengths ceil(ell/2) and floor(ell/2); omit a zero-length chain. Apply this to +the reconstructed K blocks. The formula in the statement follows. + +This is a complete similarity classification of Z under the stated contract. +It does not require a choice of how complementary vectors attach to M. +The integer a_1 is also recoverable from the full class, since + + dim V_1 = dim M_1 + a_1. + +It cannot in general be omitted. Append one scalar00 sector or one scalar01 +sector to the same admitted pair. Both operations preserve H, sharpness and +the new residual dimension. The first appends a zero eigenvalue to Z; the +second appends an eigenvalue one. Their characteristic polynomials differ. +The verifier retains this same-H, same-dimension control. + +## The open characteristic-two nilpotent case + +Suppose char F=2 and H is nilpotent with block sizes k_1,...,k_a, where +sum k_i=d. Then Theta=H^2, and (1) becomes + + B = diag(H(I-H),H(I-H)) [I 0; I I]. + +The second factor is invertible and commutes with H. Since I-H is invertible, +rank B^r = 2 rank H^r for every r. Thus B has two copies of every nilpotent H +block. The complete central partition is consequently + + sum_i [2 J_ceil((k_i+1)/2)(0) + 2 J_floor((k_i+1)/2)(0)] + + (m-2d-a_1-2a) J_1(0) + a_1 J_1(1). (5) + +This answers the explicitly open characteristic-two question in ssafwann's +[PR #5267](https://github.com/CrocSwap/integer-mult-bounds/pull/5267). +For its nilpotent profile + + (r00,r10,r01,r11)=(d+s00,d+s10,d+s01,d+a+s11), + +that predecessor's all-field representative gives a_1=s10+s01 and +m=3d+a+s00+s10+s01+s11. The extra zero-block count in (5) is therefore +`d-a+s00+s11`, and the extra one-block count is `s10+s01`. +The predecessor already proves the whole ordered-pair rigidity, its odd-field +k/(k+1) law and the fixed-H weights. None is claimed again here. + +For the padded H=J3 fixture, (5) gives `(2,2,2,2,1,1)`. Its whole central +minimal polynomial is t^2. In odd characteristic the credited partition is +`(4,3,1,1,1)`, with minimal polynomial t^4. Division by two would give the +wrong characteristic-two answer. + +## Computation, evidence and trust + +[central.py](central.py) computes the two primary subspaces in dimension2d, +the nilpotent B rank sequences, and an explicit non-endpoint restriction. +Its current scalar implementation supports F2,F3,F5,F7. The written theorem +applies to every field. The function requires the stated source contract; +H,m,a_1 alone are not a proof that a proposed original pair is admissible. + +The verifier constructs full source pairs with the frozen credited helper, +then independently forms their Schur complements and checks the original +premises and sharp rank. It computes full characteristic polynomials through +integer-lift Faddeev-LeVerrier, factors them over the small prime field, and +checks all primary power-rank partitions using a separate column-elimination +routine. These full-matrix invariants are compared with the proposed complete +representative. Non-split repeated factors and mixed primary examples prevent +scalar-eigenvalue sampling from serving as the acceptance test. + +The generic nilpotent-image and squared-Jordan arguments are classical linear +algebra, not claims of global novelty. The new result is their complete +application to the sharp block-Schur central contract and the explicit +characteristic-two partition. Written proof, exact scalar arithmetic, Python +and source transcription remain in the trust base. Finite corroboration is +not independent human or proof-kernel acceptance. Nonsharp pairs, full ordered- +pair classification for general H, header weights, native realization and +all physical consumer costs remain outside scope. No kappa or frontier change. + +Prepared by Ali Romman with substantial OpenAI Codex assistance; Apache-2.0. diff --git a/research/schur-whole-central-class/README.md b/research/schur-whole-central-class/README.md new file mode 100644 index 0000000000..d31e16ddeb --- /dev/null +++ b/research/schur-whole-central-class/README.md @@ -0,0 +1,76 @@ +# The whole central class after sharp Schur deletion + +For commuting idempotents P,Q with common identity pivot I_d, let S,T be the +Schur residuals, K=ST-TS, Z=(S-T)^2 and H=(PQ)_11. If rank K=2d, the complete +similarity class of Z is determined by H, residual dimension m, and one count: + + a1 = dim(ker S intersect ker(T-I)) + + dim(ker(S-I) intersect ker T). + +[PROOF.md](PROOF.md) gives the all-field reconstruction. On the central +primary spaces at0 and1, first extend each Jordan block of K restricted to +im K by one, then square that chain. The remaining scalar blocks come from +ker K. Away from0 and1, the entire space is already in im K. This recovers +non-split and repeated primary factors as well as scalar eigenvalues. + +This answers the characteristic-two handoff from +[PR #5267](https://github.com/CrocSwap/integer-mult-bounds/pull/5267) and extends +the restricted central action in +[PR #5256](https://github.com/CrocSwap/integer-mult-bounds/pull/5256). +For nilpotent H in characteristic two, each block k gives two blocks of length +ceil((k+1)/2) and two of length floor((k+1)/2), plus the specified scalar +summands. The padded binary H=J3 case has blocks `(2,2,2,2,1,1)`; its ternary +counterpart retains the predecessor's `(4,3,1,1,1)`. + +The result classifies the central operator, not the whole ordered residual +pair or its header weights. The sharp rank assumption is required. The complete +kappa calculation and selected frontier are unchanged. + +## Reproduce and evidence + +Requires CPython 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/schur-whole-central-class +``` + +Expected: `PASS_SCHUR_WHOLE_CENTRAL` in normal and optimized modes, followed +by `PASS_REGISTERED_RESEARCH_PACKAGE`. [RESULT.json](RESULT.json) records the +exact result digest, examples and file hashes. All1,244 H in seven complete +small prime-field domains are checked. Additional examples cover Jordan +blocks through size5 over F2,F3,F5,F7, scalar padding, mixed primary spaces +and a non-split repeated factor. Nine control groups include two admitted +pairs with the same H and residual dimension but different central classes. + +The full-matrix oracle uses integer-lift characteristic polynomials and +primary power-rank invariants with a separately transcribed column-elimination +routine. It does not accept scalar eigenvalue samples or the image restriction +as a substitute for the complete class. The classifier currently implements +F2,F3,F5,F7; the written theorem is over any field. Finite corroboration does +not establish independent human or proof-kernel acceptance. + +The exact source helpers and proof/attribution documents are retained from +pending predecessor heads in our own publication history. [SOURCES.json](SOURCES.json) +records original and retained pins. Every declared source commit is an +ancestor of this publication; no hidden local Git object is needed. Base: +ff3cc58e370d0f678e529246f8c73e8094e18fcf, priority revision7. The full-history +wrapper, selected cold replay, Lean and Docker were not run. + +## Open next questions + +Can a1 be recovered from cheaper original header data for general H? Compare +it with the four original joint-sector dimensions when H has a nontrivial +eigenvalue-one primary component. This could avoid large residual kernel +calculations. No general original-header formula or physical consumer is +proved here. General nonsharp central reconstruction and full ordered-pair +classification remain outside scope. + +## Credit + +Prepared by Ali Romman with substantial OpenAI Codex assistance; Apache-2.0. +ssafwann supplies the restricted action, nilpotent model and open question; +Nick Petalas, Ryanson Jonathan and the wider Schur lineage retain the results +listed in [NOTICE.md](NOTICE.md) and the unchanged source documents. The +nilpotent ordered-pair rigidity, odd-field partition and fixed-H weights are +predecessor results. Classical Jordan-image, primary-decomposition and +Faddeev-LeVerrier methods are not claimed as new. diff --git a/research/schur-whole-central-class/RESULT.json b/research/schur-whole-central-class/RESULT.json new file mode 100644 index 0000000000..785bc6b3ec --- /dev/null +++ b/research/schur-whole-central-class/RESULT.json @@ -0,0 +1,3833 @@ +{ + "additional_examples": [ + { + "field": 2, + "h": [ + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 2, + 2, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 2, + 2 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 2, + "h": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 1, + 1, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 2, + 2 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 2, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 2, + 2, + 2, + 2, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 3, + 3 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 2, + "h": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 15, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 2, + 2, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 3, + 3 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 2, + "h": [ + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 3, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 20, + "endpoint_blocks": { + "0": [ + 3, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 5, + 5 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 2, + "h": [ + [ + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 3, + 3, + 3, + 3, + 1, + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 21, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 3, + 3, + 3, + 3, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 5, + 5 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 3, + "h": [ + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 4 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 3, + "h": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 1, + 1, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 2, + 2 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 3, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 6 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 3, + "h": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 15, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 2, + 2, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 3, + 3 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 3, + "h": [ + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 20, + "endpoint_blocks": { + "0": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 10 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 3, + "h": [ + [ + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 2, + 2, + 2, + 0, + 0, + 0, + 2, + 2, + 2, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 3, + 3, + 3, + 3, + 1, + 1 + ], + "polynomial": [ + 2, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 21, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 3, + 3, + 3, + 3, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 5, + 5 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 5, + "h": [ + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 3, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 4 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 5, + "h": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 2, + 3, + 4, + 0, + 4, + 3, + 2, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 1, + 1, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 2, + 2 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 5, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 3, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 6 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 5, + "h": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 3, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 15, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 2, + 2, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 3, + 3 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 5, + "h": [ + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 3, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 20, + "endpoint_blocks": { + "0": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 10 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 5, + "h": [ + [ + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 3, + 3, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 3, + 3, + 3, + 3, + 1, + 1 + ], + "polynomial": [ + 4, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 21, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 3, + 3, + 3, + 3, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 5, + 5 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 7, + "h": [ + [ + 0, + 1 + ], + [ + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 5, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 3, + 2, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 4 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 7, + "h": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 6, + 0, + 0, + 0, + 0, + 0, + 6, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 1, + 1, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 2, + 2 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 7, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 5, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 4, + 3, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 6 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 7, + "h": [ + [ + 1, + 1, + 0 + ], + [ + 0, + 1, + 1 + ], + [ + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 1, + 4, + 3, + 6, + 0, + 0, + 0, + 6, + 3, + 4, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 15, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 2, + 2, + 2, + 2, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 3, + 3 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 7, + "h": [ + [ + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 5, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 20, + "endpoint_blocks": { + "0": [ + 6, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 10 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + { + "field": 7, + "h": [ + [ + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 5, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 3, + 3, + 3, + 3, + 1, + 1 + ], + "polynomial": [ + 6, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ], + [ + 1, + 1 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "prediction": { + "dimension": 21, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 3, + 3, + 3, + 3, + 1, + 1 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 5, + 5 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 4 + } + }, + { + "field": 2, + "h": [ + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 1, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 1, + 1, + 1 + ] + } + ] + }, + "padding": [], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [] + }, + "image_commutator_blocks": { + "0": [], + "1": [] + }, + "nonendpoint_representative": [ + [ + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ] + ], + "opposite_count": 0 + } + }, + { + "field": 2, + "h": [ + [ + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 1, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 1, + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1 + ], + "polynomial": [ + 1, + 1 + ] + }, + { + "exponents": [ + 1, + 1 + ], + "polynomial": [ + 1, + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 1 + ] + ], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 2, + 2, + 1, + 1, + 1, + 1, + 1 + ], + "1": [ + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 2, + 2 + ], + "1": [] + }, + "nonendpoint_representative": [ + [ + 1, + 1, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 1, + 0 + ] + ], + "opposite_count": 1 + } + } + ], + "binary_j3": { + "field": 2, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + } + ] + }, + "padding": [], + "prediction": { + "dimension": 10, + "endpoint_blocks": { + "0": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "1": [] + }, + "image_commutator_blocks": { + "0": [ + 3, + 3 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 0 + } + }, + "domains": [ + { + "count": 2, + "dimension_h": 1, + "field": 2 + }, + { + "count": 16, + "dimension_h": 2, + "field": 2 + }, + { + "count": 512, + "dimension_h": 3, + "field": 2 + }, + { + "count": 3, + "dimension_h": 1, + "field": 3 + }, + { + "count": 81, + "dimension_h": 2, + "field": 3 + }, + { + "count": 5, + "dimension_h": 1, + "field": 5 + }, + { + "count": 625, + "dimension_h": 2, + "field": 5 + } + ], + "endpoint_one": { + "field": 2, + "h": [ + [ + 1, + 1, + 0, + 0 + ], + [ + 0, + 1, + 1, + 0 + ], + [ + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 1 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 3, + 3, + 2, + 2 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [], + "prediction": { + "dimension": 14, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [ + 3, + 3, + 2, + 2 + ] + }, + "image_commutator_blocks": { + "0": [], + "1": [ + 4, + 4 + ] + }, + "nonendpoint_representative": [], + "opposite_count": 2 + } + }, + "exhaustive_cases": 1244, + "exhaustive_result_sha256": "13fc904e188253e8155c7b12cc8258e4eccb57e546aad90922432c996b1e9ea6", + "files": { + "NOTICE.md": "7766573e4259a2dca111130c93cd5244ac580f6c6d8d31800fb05fbfde47440f", + "PROOF.md": "24d54ea4de5c1d6e33bb1bf65898f13bf20bae5f6f60cb52f338724e76d5f84c", + "README.md": "ecf2a0ac1b9fb353ea8de8aa207af2fc3f63e97f4f6bae06b3d54bebc9ddc903", + "SOURCES.json": "db1762fcc67fd659cadbb7ae0382d7ae437cd481ffd13f147129d5fb4ae8d47c", + "TASK.json": "092ffafb52306d2f0d05d7cb4562faeaa3ac3cbe33e9e50acb48f321606ac4df", + "VERIFY.json": "18bfb986512450df9526d477a318b54ad183d3e60e318937f2ba97625e8b2dd7", + "central.py": "f32ae572108b284b2de1aa9e78f774bf734773431f53bd5e3719a40ef806a8cd", + "vendor/BLOCK-SOURCE.md": "d2fef84ac2b9fcf5346554ee904539f6526abe3f703694fedb8fd061b491b7a9", + "vendor/NILPOTENT-SOURCE.md": "7e5e74f4e5ddc1793ac6e427a80492d8d978aa78f01f189e33d2831147c9639a", + "vendor/block_source.py": "d474332a32991f4bb92ac75559f878f4ec99205844c6c7ae90d53622ad9cdfe5", + "verify.py": "6b1791691c2255ad12017583eecae428e3d4288ee1e466020f3a28bfdfbdf301" + }, + "groups": 9, + "odd_nonsplit": { + "field": 3, + "h": [ + [ + 0, + 0, + 0, + 2 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 1 + ], + [ + 0, + 0, + 1, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 1, + 2, + 2, + 2, + 1, + 1, + 2, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 1, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 2, + 2 + ], + "polynomial": [ + 2, + 1, + 1 + ] + } + ] + }, + "padding": [], + "prediction": { + "dimension": 12, + "endpoint_blocks": { + "0": [ + 1, + 1, + 1, + 1 + ], + "1": [] + }, + "image_commutator_blocks": { + "0": [], + "1": [] + }, + "nonendpoint_representative": [ + [ + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 1, + 0, + 0, + 0, + 0 + ], + [ + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 2, + 2, + 2, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + [ + 0, + 0, + 0, + 0, + 2, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2 + ] + ], + "opposite_count": 0 + } + }, + "same_h_dimension_different_classes": [ + { + "field": 2, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 0 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 2, + 2, + 2, + 2, + 1, + 1, + 1 + ], + "1": [] + }, + "image_commutator_blocks": { + "0": [ + 3, + 3 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 0 + } + }, + { + "field": 2, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + }, + { + "exponents": [ + 1 + ], + "polynomial": [ + 1, + 1 + ] + } + ] + }, + "padding": [ + [ + 0, + 1 + ] + ], + "prediction": { + "dimension": 11, + "endpoint_blocks": { + "0": [ + 2, + 2, + 2, + 2, + 1, + 1 + ], + "1": [ + 1 + ] + }, + "image_commutator_blocks": { + "0": [ + 3, + 3 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 1 + } + } + ], + "ternary_j3": { + "field": 3, + "h": [ + [ + 0, + 1, + 0 + ], + [ + 0, + 0, + 1 + ], + [ + 0, + 0, + 0 + ] + ], + "invariants": { + "characteristic_polynomial": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ], + "primary_blocks": [ + { + "exponents": [ + 4, + 3, + 1, + 1, + 1 + ], + "polynomial": [ + 0, + 1 + ] + } + ] + }, + "padding": [], + "prediction": { + "dimension": 10, + "endpoint_blocks": { + "0": [ + 4, + 3, + 1, + 1, + 1 + ], + "1": [] + }, + "image_commutator_blocks": { + "0": [ + 6 + ], + "1": [] + }, + "nonendpoint_representative": [], + "opposite_count": 0 + } + } +} diff --git a/research/schur-whole-central-class/SOURCES.json b/research/schur-whole-central-class/SOURCES.json new file mode 100644 index 0000000000..94c0a74170 --- /dev/null +++ b/research/schur-whole-central-class/SOURCES.json @@ -0,0 +1,54 @@ +{ + "schema_version": 1, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "research/schur-whole-central-class/vendor/block_source.py", + "usage": "provenance", + "pin": "head:60bd962e4e4397ed77a6f149064c2a585cce89d3:research/schur-whole-central-class/vendor/block_source.py", + "git_blob": "7bfce0e512f56121d2da9834ec97f37193a4efd0", + "sha256": "d474332a32991f4bb92ac75559f878f4ec99205844c6c7ae90d53622ad9cdfe5", + "upstream": { + "commit": "c72d6ff431cf5c979f5010018d8eba0c15577bce", + "path": "research/schur-block-central-law/verify.py", + "url": "https://github.com/ssafwann/integer-mult-bounds/blob/c72d6ff431cf5c979f5010018d8eba0c15577bce/research/schur-block-central-law/verify.py" + } + }, + { + "path": "research/schur-whole-central-class/vendor/BLOCK-SOURCE.md", + "usage": "provenance", + "pin": "head:60bd962e4e4397ed77a6f149064c2a585cce89d3:research/schur-whole-central-class/vendor/BLOCK-SOURCE.md", + "git_blob": "60940ce955dfcb3786d9af0de5114bec7b95d422", + "sha256": "d2fef84ac2b9fcf5346554ee904539f6526abe3f703694fedb8fd061b491b7a9", + "upstream": { + "commit": "c72d6ff431cf5c979f5010018d8eba0c15577bce", + "path": "research/schur-block-central-law/README.md", + "url": "https://github.com/ssafwann/integer-mult-bounds/blob/c72d6ff431cf5c979f5010018d8eba0c15577bce/research/schur-block-central-law/README.md" + } + }, + { + "path": "research/schur-whole-central-class/vendor/NILPOTENT-SOURCE.md", + "usage": "provenance", + "pin": "head:60bd962e4e4397ed77a6f149064c2a585cce89d3:research/schur-whole-central-class/vendor/NILPOTENT-SOURCE.md", + "git_blob": "1e738614a419c8f91941886179bdf235e4e5ed52", + "sha256": "7e5e74f4e5ddc1793ac6e427a80492d8d978aa78f01f189e33d2831147c9639a", + "upstream": { + "commit": "8ab280c8a3ef0544f13ff23a1c69df4757cd4900", + "path": "research/schur-nilpotent-extension/README.md", + "url": "https://github.com/ssafwann/integer-mult-bounds/blob/8ab280c8a3ef0544f13ff23a1c69df4757cd4900/research/schur-nilpotent-extension/README.md" + } + } + ] +} diff --git a/research/schur-whole-central-class/TASK.json b/research/schur-whole-central-class/TASK.json new file mode 100644 index 0000000000..ad2c35de28 --- /dev/null +++ b/research/schur-whole-central-class/TASK.json @@ -0,0 +1,95 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 7, + "base_commit": "ff3cc58e370d0f678e529246f8c73e8094e18fcf", + "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_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Inventory the gate-operand parity lemma (#3807) and certified endpoint arithmetic (#3857). Neither is a full multiplication proof. For #4100, audit the compact-switch statement and its hypotheses before formalizing it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "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": "Recover the complete central similarity class after sharp identity-block Schur deletion from H, residual dimension and one opposite-sector count, including the open characteristic-two nilpotent partition.", + "scope_change_reason": "This follows the explicit #5267 characteristic-two handoff and extends the #5256 restricted block action. It is a written algebraic side result, not a proof-assistant or physical-supplier claim.", + "bottleneck_link": "Determines exactly which extra central state data are needed beyond the commutator image, without another header census. A paid consumer and general ordered-pair classification remain absent.", + "budget_minutes": 90, + "stop_rule": "Stop at the complete central class and characteristic-two partition after independent full-matrix invariant checks. Do not duplicate nilpotent ordered-pair rigidity or header weights.", + "outcome": "completed", + "evidence": "PROOF.md, central.py, verify.py, RESULT.json", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance for proof, implementation, verification and publication.", + "open_questions": [ + { + "question": "Can the one opposite-sector count be recovered from cheaper original header data for general H?", + "why_it_matters": "The central class is determined, but the count can still require large residual kernel calculations.", + "first_step": "Compare the count with the four original joint-sector dimensions on H with nontrivial eigenvalue-one primary blocks.", + "blocked_by": "No general original-header formula or physical consumer is proved here." + } + ] +} diff --git a/research/schur-whole-central-class/VERIFY.json b/research/schur-whole-central-class/VERIFY.json new file mode 100644 index 0000000000..8ce1c3ac70 --- /dev/null +++ b/research/schur-whole-central-class/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Full source premises, sharp rank, independent characteristic polynomials and all primary rank partitions, including non-split and characteristic-two cases." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Full source premises, sharp rank, independent characteristic polynomials and all primary rank partitions, including non-split and characteristic-two cases." + } + ] +} diff --git a/research/schur-whole-central-class/central.py b/research/schur-whole-central-class/central.py new file mode 100644 index 0000000000..b35e82ab5f --- /dev/null +++ b/research/schur-whole-central-class/central.py @@ -0,0 +1,95 @@ +"""Recover the full central class under the sharp Schur-image contract. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Matrix helpers are retained from ssafwann; see NOTICE.md. +""" +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent/'vendor')) +from block_source import add, mul, eye, zero, block, kernel, rank, rref, inverse, require + + +def power(a, exponent, q): + result = eye(len(a)) + for _ in range(exponent): result = mul(result, a, q) + return result + + +def column_basis(a, q): + pivots = rref(a, q)[1] + return tuple(tuple(row[j] for j in pivots) for row in a) + + +def restrict(a, basis, q): + if not basis or not basis[0]: return () + indices = rref(tuple(zip(*basis)), q)[1] + square = tuple(basis[i] for i in indices) + image = mul(a, basis, q) + result = mul(inverse(square, q), tuple(image[i] for i in indices), q) + require(mul(basis, result, q) == image, 'subspace is not invariant') + return result + + +def nilpotent_blocks(operator, basis, q): + if not basis or not basis[0]: return [] + ranks = [len(basis[0])] + current = basis + for _ in range(len(operator)): + current = mul(operator, current, q) + ranks.append(rank(current, q)) + if not ranks[-1]: break + require(ranks[-1] == 0, 'primary commutator is not nilpotent') + ranks.append(0) + blocks = [] + for size in range(1, len(ranks)-1): + count = ranks[size-1]-2*ranks[size]+ranks[size+1] + require(count >= 0, 'invalid rank sequence') + blocks += [size]*count + return sorted(blocks, reverse=True) + + +def classify(h, residual_dimension, opposite_count, q): + """The source pair must satisfy the sharp contract in PROOF.md.""" + require(q in (2,3,5,7), 'implemented fields are F2, F3, F5 and F7') + d = len(h) + require(d > 0 and all(len(row) == d for row in h), 'square nonempty H required') + require(type(residual_dimension) is int and type(opposite_count) is int and + residual_dimension >= 2*d and 0 <= opposite_count <= residual_dimension-2*d, + 'invalid residual or sector count') + ident = eye(d); w = add(ident,h,q,-1); j = add(h,mul(h,h,q),q,-1) + theta = add(add(h,h,q),mul(h,h,q),q,-1) + central = block(theta,zero(d,d),zero(d,d),theta) + commutator = block(j,add(w,w,q),add(zero(d,d),j,q,-1),add(zero(d,d),j,q,-1)) + require(mul(commutator,commutator,q) == mul(central,add(central,eye(2*d),q,-1),q), + 'small commutator identity') + endpoints = {} + bblocks = {} + for lam, count in ((0,residual_dimension-2*d-opposite_count),(1,opposite_count)): + basis = kernel(power(add(central,eye(2*d),q,-lam),2*d,q),q) + blocks = nilpotent_blocks(commutator,basis,q) + require(count >= len(blocks), 'endpoint count cannot support the image') + bblocks[str(lam)] = blocks + parts = [part for size in blocks for part in ((size+2)//2,(size+1)//2)] + parts += [1]*(count-len(blocks)) + endpoints[str(lam)] = sorted(parts,reverse=True) + g = mul(central,add(central,eye(2*d),q,-1),q) + basis = column_basis(power(g,2*d,q),q) + nonendpoint = restrict(central,basis,q) + require(sum(map(sum,endpoints.values()))+len(nonendpoint) == residual_dimension, 'dimension mismatch') + return {'endpoint_blocks':endpoints,'image_commutator_blocks':bblocks, + 'nonendpoint_representative':[list(row) for row in nonendpoint], + 'opposite_count':opposite_count,'dimension':residual_dimension} + + +def representative(result, q): + chunks = [] + for lam in (0,1): + for size in result['endpoint_blocks'][str(lam)]: + chunks.append(tuple(tuple((lam*int(i==j)+int(j==i+1))%q for j in range(size)) for i in range(size))) + if result['nonendpoint_representative']: + chunks.append(tuple(map(tuple,result['nonendpoint_representative']))) + n = sum(map(len,chunks)); out = [[0]*n for _ in range(n)]; offset = 0 + for chunk in chunks: + for i,row in enumerate(chunk):out[offset+i][offset:offset+len(chunk)] = row + offset += len(chunk) + return tuple(map(tuple,out)) diff --git a/research/schur-whole-central-class/vendor/BLOCK-SOURCE.md b/research/schur-whole-central-class/vendor/BLOCK-SOURCE.md new file mode 100644 index 0000000000..60940ce955 --- /dev/null +++ b/research/schur-whole-central-class/vendor/BLOCK-SOURCE.md @@ -0,0 +1,304 @@ +# Central action after an identity-block Schur deletion + +**Scoped all-field algebraic proof with finite exact corroboration; no new κ.** +Prepared for ssafwann with substantial OpenAI Codex (gpt-6-astra) assistance, +by one agent. Apache-2.0. + +Nick Petalas's [#4801](https://github.com/CrocSwap/integer-mult-bounds/pull/4801) +proves a central-spectrum law for a scalar identity pivot and explicitly asks +for the ordered block replacement. This package answers that question. For a +common identity block of size d and compressed product H, the replacement is +an **intertwiner with two copies of Θ = 2H−H²**, rather than a scalar equation +between matrices of different sizes. When the Schur commutator has rank 2d, +this gives the exact restricted operator, including its nonsemisimple data. + +## Theorem and domain + +Let F be any field, d >= 1, n > d, and let P,Q in M_n(F) be commuting +idempotents. Both leading d-by-d blocks must be I_d. Write + +```text +P = [I R; C D], Q = [I L; E F0], H = (PQ)11, +S = D−CR, T = F0−EL, K = ST−TS, +Z = (S−T)², J = H(I−H), Θ = 2H−H². +``` + +No symmetry, invertibility of H, semisimplicity, characteristic restriction, +or maximal-rank hypothesis is imposed initially. Put G=(PQ)21 and define + +```text +A = [G−EH, C−E] : F^(2d) -> F^(n−d), +U_H = [I−H −I; −J H], V_H = [I I; 0 0]. +``` + +Then the ordered identities are + +```text +S A = A U_H, T A = A V_H, +Z A = A diag(Θ,Θ). (1) +``` + +For every polynomial p in F[t] satisfying p(Θ)=0, + +```text +p(Z) K = 0, Z(Z−I) p(Z) = 0. (2) +``` + +In particular, with m_Θ the minimal polynomial of Θ, the minimal polynomial +of Z divides `t(t−1)m_Θ(t)`. One may instead use the characteristic polynomial +of Θ to get a generally weaker annihilator of degree d+2. Repeated factors +must be retained. Over an algebraic closure the spectrum of Z is contained +in `{0,1} ∪ spectrum(Θ)`; this does not imply diagonalizability. + +If additionally **rank K = 2d**, then im K = im A and A is an isomorphism +onto that subspace. Consequently: + +- the ordered pair restricted to im K is simultaneously similar to `(U_H,V_H)`; +- `Z|im K` is similar to `Θ ⊕ Θ`; +- its minimal polynomial is exactly m_Θ, and its characteristic polynomial + is exactly the square of the characteristic polynomial of Θ; +- over a splitting field, each Jordan block of Θ occurs twice in `Z|im K`. + +These conclusions concern the indicated invariant subspace, not all n−d +residual coordinates. They do not classify the entire residual pair or count +headers. The dimension minimum is the credited #4671/#4746 result, not a new +claim here. At d=1, (2) recovers #4801's scalar law with Θ=h(2−h). + +## Proof, with ordered products retained + +Let i:F^d -> F^n and π:F^n -> F^d be the coordinate inclusion and projection. +Thus πi=πPi=πQi=I and πPQi=H. Define the full-space Schur lifts + +```text +P̂ = P−PiπP, Q̂ = Q−QiπQ. +``` + +In the original block coordinates these are `diag(0,S)` and `diag(0,T)`. +For example P̂i=0 and πP̂=0, and expanding P̂² using P²=P and πPi=I gives +P̂²=P̂. Thus S,T are idempotents. The same facts hold for Q̂. + +Define two block columns and a block row: + +```text +a = PQi−QiH, b = (P−Q)i, + = [a,b], +B̂ = [π(P−Q); −πPQ+HπQ]. +``` + +Their top d rows / first d columns vanish respectively: πÂ=0 and B̂i=0. +The following expansion gives the identity-pivot specialization of Petalas's +ordered Schur factorization (#4597), also used in #4671/#4746: + +```text +[P̂,Q̂] = PQiπ(P−Q) − (P−Q)iπPQ + PiHπQ − QiHπP = ÂB̂. +``` + +Indeed expand `(P−PiπP)(Q−QiπQ)` and its reversed product, cancel PQ=QP, +and use πPQi=πQPi=H. Removing the zero first blocks gives `K=AB`, where +`B=[R−L; −(PQ)12+HL]`. This derivation does not commute any rectangular factors. + +Now compute the four actions directly: + +```text +P̂a = PQi(I−H) − Pi(H−H²) = a(I−H)−bJ, +P̂b = PiH−PQi = −a+bH, +Q̂a = a, +Q̂b = a. (3) +``` + +For example πPa=H−H² and πQa=0; πPb=I−H and πQb=H−I. +These four identities prove the first two equations of (1). Their difference +has the right-acting block matrix + +```text +U_H−V_H = [−H −2I; −J H]. +``` + +Here J=H−H² is a polynomial in H, so HJ=JH. Squaring this particular matrix, +with its order retained, gives + +```text +(U_H−V_H)² = [H²+2J 0; 0 H²+2J] = diag(Θ,Θ). +``` + +This proves the last equation of (1). The commutation used in this step is +between two polynomials in H; it is not an assumption on arbitrary original +matrix blocks. Repeated application and linear combination give +`p(Z)A = A diag(p(Θ),p(Θ))`. Multiplying by B proves the first equation of (2). + +For any two idempotents S,T, with no commutation assumption on them, + +```text +Z = S+T−ST−TS, +ZS = SZ = S−STS, ZT = TZ = T−TST, +K² = Z²−Z. (4) +``` + +Each line follows by expansion and S²=S,T²=T. These central identities are +credited to the existing projector/Schur lineage, especially Ryanson +Jonathan #4609 and Petalas #4801. Multiplying `p(Z)K=0` by K and using (4) +proves the second equation of (2), since all polynomial factors in Z commute. + +Finally K=AB implies im K ⊆ im A and rank K <= rank A <= 2d. Under the stated +sharpness hypothesis every inequality is equality. A then identifies F^(2d) +with im K, and (1) gives both restricted similarities. The minimal polynomial, +characteristic polynomial and Jordan statements follow from this actual +isomorphism, not merely from an annihilating polynomial. This completes the +all-field proof, including singular and nonsemisimple H. + +## Attained repeated roots and an indispensable endpoint factor + +Take the nilpotent three-by-three Jordan block + +```text +H = [0 1 0; 0 0 1; 0 0 0]. +``` + +The credited sector construction below produces full commuting pairs with +n=13, d=3 and rank K=6, over both F2 and F3. + +| Field | Θ | Minimal polynomial on im K | Ranks of K, ZK, Z²K, Z³K | Minimal polynomial on the whole residual | +|---|---|---|---|---| +| F2 | H² | t² | 6,2,0,0 | t² | +| F3 | 2H−H² | t³ | 6,4,2,0 | t⁴ | + +Thus replacing m_Θ by its square-free part is false even on im K. In the +ternary example, m_Θ(Z) is nonzero on the full residual, of rank one; an +additional factor t is needed there. The second identity in (2) permits it. +This is a concrete block-pivot example, beyond #4801's scalar repeated root. +The displayed whole-space values are finite exact fixture claims, verified +by the first linear dependence of complete matrix powers. + +For an example without scalar eigenvalues over F2, use +`H=[0 1; 1 1]`. Then Θ=H² and m_Θ=t²+t+1. The constructed n=8 pair has +rank K=4 and whole-space minimal polynomial `t(t²+t+1)`. Consequently a +scalar-eigenvalue check alone cannot verify this theorem. The same displayed +H over F5 supplies an odd-characteristic sign control and a repeated-root +shift; it is a separate field calculation. + +### Explicit fixture construction + +This is a padded version of Petalas #4746's all-field construction, following +ssafwann #4671's binary construction. It is included to make every example +independently reproducible, not as a new dimension result. Let W=I−H. In the +00 sector choose `X00=−W, Y00=I`, of dimension d. For each active sector +10,01,11 with target F respectively W,W,H, choose columns N complementing +im F and set `X=[F,N], Y=[I;0]`. Then X is onto, Y is injective and XY=F. + +Concatenate X's to π0 and stack Y's to i0. Their products sum to +`−W+W+W+H=I`, so π0i0=I. On the four sectors let +`P0=diag(0,I,0,I), Q0=diag(0,0,I,I)`. Take `M=[i0, basis(ker π0)]` and form +`P=M^-1 P0 M, Q=M^-1 Q0 M`. The pivots are identities and `(PQ)11=H`. +The six active ranks give sharpness by #4746; the new checker independently +checks the resulting full-matrix commutator rank in every case. Dimension is +`4d+nullity(H)+2 nullity(I−H)`, at most 6d. No optimality is claimed for the +padded 00 sector. Greedy standard-coordinate complements make the executable +construction deterministic. + +## Verification + +Python 3.12 standard library, no network, Git or predecessor-code dependency +in the scientific verifier. All checks use explicit exceptions under `-O`. + +```sh +python3.12 -B scripts/research_package.py --package research/schur-block-central-law +python3.12 -B scripts/check_research_commit.py --package research/schur-block-central-law --check-source-history +python3.12 -I -W error -B research/schur-block-central-law/verify.py +python3.12 -I -W error -O -B research/schur-block-central-law/verify.py +``` + +On macOS arm64 / CPython 3.12.11, the registered normal and optimized +replays pass in 6.32 seconds combined (local duration, not a speed comparison). +The registered replay runs both direct modes and emits +`PASS_SCHUR_BLOCK_CENTRAL_LAW`. The verifier writes no files. + +- All **1,244** H in seven complete domains: d=1,2,3 over F2 and d=1,2 over + each of F3,F5. For each it constructs P,Q, verifies their premises and H, + forms literal Schur complements, checks K=AB, both ordered actions, the + central intertwiner, both polynomial laws and exact restricted minimal + polynomial. Complete-matrix powers acting on K check the latter without + using the proposed intertwiner as an oracle. +- Every **1,472** ordered commuting identity-pivot binary projector pair at + `(n,d)=(3,1),(4,2)`: respectively 253 and 1,219 pairs. These credited small + domains test the new laws beyond the sharp fixture construction. No pair + in these domains is sharp; rank-zero and rank-one commutators occur. +- Four displayed fixtures additionally check every rank sequence + `rank((Z−λI)^j K)=2 rank((Θ−λI)^j)` for every λ in their field and + j=0,...,d+1, and compute their whole-space minimal polynomials. +- Nine rejection controls distinguish repeated roots, the full-space + endpoint factor, H from Θ, the odd-field sign, sharpness, pivot validity, + idempotency, input commutation and the census capacity limit. + +Universal claims rest on the written argument. The finite domains are prime +fields only; no characteristic-zero, extension-field or arbitrary-dimensional +census is claimed. Source-history/committed-byte checking and export transport +integrity are separate from mathematical validity. No independent human or +formal proof-kernel acceptance, Lean, Docker, full-history replay or selected +scientific cold replay is claimed. Hosted CI is reported separately in the PR. + +## Scope, overlap and attribution + +Base: canonical main `ff3cc58e370d0f678e529246f8c73e8094e18fcf`, priority revision +7, selected conditional κ=0.00302015. The scoped handoff is claimed in +[Discussion #4653](https://github.com/CrocSwap/integer-mult-bounds/discussions/4653), +with a [#1166 pointer](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19147366). +The `formal-interface-lemma` card is explicitly **changed** to a written +algebraic side result. It supplies a necessary residual constraint and, under +sharpness, one exact restricted representation. It does not audit the selected +supplier's uniform implementation. The source-binding orientation command +stopped at the sparse-omitted `certificates/checkpoints/frontier4359.json`; +no selected baseline pass is claimed. + +Initial overlap covers all 7,091 tracked in-scope notes on this base, 319 open +PR bodies and 4,505 Discussion records, with complete pagination and no coverage +warnings. The final refresh covers 322 open PRs (14:19 UTC), 4,520 Discussion +records (14:21 UTC), and all 7,091 tracked notes, without coverage warnings. +Canonical main is unchanged. TASK.json records these snapshots. +Targeted all-state PR searches supplement this, but arbitrary diffs, nested +notes, an exhaustive closed-PR body inventory and unpublished work remain +outside coverage. No absence-of-matches claim establishes novelty. + +Exact base-main README bytes are provenance-pinned in SOURCES.json; their +historical claims retain their stated review status. None is a runtime input. +The immediate #4801/#4746 predecessors were merged when checked; archive acceptance +does not imply independent scientific approval. + +- **Nick Petalas #4801**, head `98bc071317b17fd8bb4f21044328914c7561d3cb`, + supplies the scalar law and explicit block question. **#4597**, head + `dfeb8ca729a04aea4aa290438f2ed50a37a9c7cb`, supplies the ordered factorization; + #4278/#4259/#4228 retain the scalar Schur/header lineage. +- **Nick Petalas #4746**, head `5f014560d6225cae17598ac479fb29d2947d8e6b`, + supplies the signed all-field sectors and fixture construction, extending + **ssafwann #4671**, head `8d2e3bc76aa7d43e5c629daaf1e72d4dd5a81ed9`; + #4657/#4678 retain the identity-pivot and counting lineage. +- **Ryanson Jonathan #4609**, with disclosed Claude Code assistance, supplies + central-operator/idempotent context; #4617 and **lee-phys #4634** retain + their binary dimension/sharpness contributions. +- **Mihir Srivastava #4689**, **codyw912 #4735**, **MatShep #4762**, + **Nick Petalas #4915**, and **JoyboyBrian #5072** supply the distinct residual + census, recurrence, descriptor, orbit weights and scalar incidence work. + Those quantities are not repeated here. **Krzysztof Wojt #5128** supplies + arbitrary-pivot dimension minima, a different obligation. +- **Cinna Davis #4100** and the retained source527, commdata2338 and Jose + Manuel normalizer lineage supply the BIT/header context. + +Substantial predecessor AI-assistance disclosures and Apache-2.0 credit are +retained in their unchanged sources. No shared code, frozen evidence, existing +package, priority or selected-frontier file is modified. + +## Open next questions + +The block-central identity is closed at this scope. A next useful question is +whether, for one specified singular H, the extension of the restricted pair +on im K to the whole residual can be classified and weighted. Start with the +ternary H=J3 example above: its central nilpotency grows from three to four. +The missing data are how the complementary residual directions attach to +im K, and their split/header multiplicities. The present theorem is not a +complete state invariant or transition law; another dimension scan is not +needed to answer it. No follow-up claim is held. + +Nonidentity block pivots and subsequent noncommuting deletions require new +hypotheses and a new derivation. Physical production separately needs a named +header cover and priced selection/emission, reads, ownership, dirty restoration, +precision, storage, stock, dispatch and the complete consumer bill. Those costs +remain unknown, not zero. This session stops at the one-deletion theorem. diff --git a/research/schur-whole-central-class/vendor/NILPOTENT-SOURCE.md b/research/schur-whole-central-class/vendor/NILPOTENT-SOURCE.md new file mode 100644 index 0000000000..1e738614a4 --- /dev/null +++ b/research/schur-whole-central-class/vendor/NILPOTENT-SOURCE.md @@ -0,0 +1,354 @@ +# Nilpotent identity-block Schur deletion: the whole residual and its weight + +This is a written algebraic side result with bounded exact corroboration, +prepared for ssafwann with substantial OpenAI Codex (gpt-6-astra) assistance, +one agent; Apache-2.0. It answers the whole-residual extension handoff in +[PR5256](https://github.com/CrocSwap/integer-mult-bounds/pull/5256) for nilpotent +compressed products. That pending PR is motivation, not a theorem premise. +Independent human and formal proof-kernel review are unclaimed. + +**Result.** Fix a commuting idempotent pair and its four joint-sector dimensions. +Among identity-block deletions with a specified nilpotent matrix H and maximal +Schur-commutator rank, the entire ordered residual pair has one simultaneous +conjugacy orbit. We give an explicit representative over any field. In odd +characteristic its central operator has one chain of length k and one of length +k+1 for every H Jordan block of length k, plus specified scalar summands. Over +finite fields we count exactly the splits and complete headers in this fixed-H +event. This is not the unconditional mass of the residual orbit. + +The generic factor equivalence and stabilizer method are predecessor results; +the contribution is their application to this Schur family, the explicit +complementary attachments, and the resulting whole-residual Jordan law. This +does not reopen the earlier minimum-dimension problem or scalar state census. +No selected-frontier file changes: selected conditional κ remains 0.00302015. +Physical header selection/emission, reads, owned/borrowed state, dirty restoration, +precision, storage, stock, dispatch and the complete consumer bill remain +unknown, not zero. + +## Contract and statement + +Let F be any field, U=F^d with d>=1, and P0,Q0 commuting idempotents on V. +Write V as its ordered joint eigenspaces V00,V10,V01,V11, of dimensions r_j. +A split is i:U->V and π:V->U with πi=I. A complete header is an ordered basis +M=[i,B], with B an ordered basis of ker π. In that header put + +```text +P=M^-1 P0 M=[I b; c D], Q=M^-1 Q0 M=[I f; g E], +S=D-cb, T=E-gf, +H=π P0 Q0 i, K=ST-TS, Z=(S-T)^2. +``` + +Block idempotency gives S²=S and T²=T. Consequently +Z=S+T-ST-TS commutes with both residual maps. + +Restrict to headers with the displayed common identity pivot, nilpotent H, +and rank K=2d (called sharp here). Set a=dim ker H, W=I-H. Then necessarily + +```text +r00=d+s00, r10=d+s10, r01=d+s01, r11=d+a+s11, s_j>=0. (1) +``` + +Conversely every such profile admits a sharp split with that exact H. For fixed +H and profile, all resulting ordered pairs (S,T) are simultaneously similar. +Their representative is the minimal pair below, plus the scalar pairs + +```text +(0,0)^s00 direct-sum (1,0)^s10 direct-sum +(0,1)^s01 direct-sum (1,1)^s11. (2) +``` + +There is no claim that different H/profile data always give distinct orbits. + +Choose N:F^a->U whose image complements im H. On U^3 direct-sum F^a, with +coordinates (x,y,z,t), the minimal pair is + +```text +S(x,y,z,t) = (H(x-z)-Nt, 0, W(z-x)-Nt, t), +T(x,y,z,t) = (0, H(y-z)-Nt, W(z-y)-Nt, t). (3) +``` + +Its dimension is 3d+a. All choices of N yield the same ordered-pair orbit. + +If char F is not 2, put R=2I-H. In coordinates (u,v,t,c), (3) is a common +zero summand of dimension d and the following core on U^2 direct-sum F^a: + +```text + [ H/2 H/2 -N ] [ H/2 -H/2 N ] +S_core = [ R/2 R/2 N ], T_core = [ -R/2 R/2 N ]. (4) + [ 0 0 I ] [ 0 0 I ] +``` + +If the nilpotent Jordan block lengths of H are k_1,...,k_a, the complete +Jordan form of Z is + +```text +direct-sum_i (J_(k_i)(0) direct-sum J_(k_i+1)(0)) + direct-sum 0_(d+s00+s11) direct-sum I_(s10+s01). (5) +``` + +In particular, for j>=1, + +```text +rank Z^j = rank H^j + rank H^(j-1) + s10+s01, (6) +m_Z(t) = t^(max_i k_i+1) (t-1)^epsilon, +epsilon = 1 if s10+s01>0, otherwise 0. +``` + +Nilpotent Jordan blocks exist over every field. The odd-characteristic +qualification matters: for F2,d=1,H=0 and no padding, Z=0, whereas (5) would +contain J2(0). Equations (1)--(3) and the counting result below still hold in +characteristic two; (4)--(6) are not asserted there. + +Over F_q (any prime power), write G_r=|GL_r(F_q)|, G_0=1. The number of sharp +splits for the **fixed original ordered pair** and **exact matrix H** is + +```text +N_H = (G_r00 G_r10 G_r01 G_r11) / + (G_s00 G_s10 G_s01 G_s11 q^(a^2+2a s11)). (7) +``` + +The number of complete ordered headers in this event is N_H G_(n-d), where +n=sum r_j. All those headers reach the same residual orbit, but headers with +other H may reach it too. Thus (7) does not compute its unconditional transition +probability or the number of occurrences of one coordinate representative. +There is no division by GL_d or by a similarity-class size: H is fixed in the +ordered leading coordinates, and changing i's basis changes the split. + +## Proof + +### The sector data and existence + +Let E_j be the four joint-sector projectors, Y_j=E_j i and X_j=π|V_j. +The equations πi=πP0i=πQ0i=I and πP0Q0i=H give + +```text +X00Y00=-W, X10Y10=W, X01Y01=W, X11Y11=H. (8) +``` + +We use the all-field sharp-sector criterion of Nick Petalas +[PR4746](https://github.com/CrocSwap/integer-mult-bounds/pull/4746): under these +identity-pivot hypotheses, rank K=2d iff each of Y10,Y01,Y11 is injective and +each of X10,X01,X11 is onto. This criterion, and its factor-capacity consequence, +are credited premises, not newly claimed results. Since H is nilpotent, W is +invertible; (8) also makes Y00 injective and X00 onto. + +For any onto X:F^r->U and injective Y:U->F^r with XY=A, the intersection +im Y intersect ker X is Y ker A. Hence r>=d+nullity A. Applying this to (8) +gives (1). Attainment uses + +```text +X00=-W, X10=X01=W, X11=[H,N], +Y00=Y10=Y01=I, Y11=[I;0], (9) +``` + +with unused zero columns/rows for the s_j padding coordinates. Their combined +πi is -W+W+W+H=I, both compressed projectors are I, and all four X/Y pairs +have full ranks. The cited criterion gives sharpness. + +### Why the whole ordered residual is forced + +We use the inclusion/observation extension principle of codyw912 +[PR4735](https://github.com/CrocSwap/integer-mult-bounds/pull/4735), generalized +by MatShep [PR4762](https://github.com/CrocSwap/integer-mult-bounds/pull/4762). +Here is its short specialization, to expose exactly the required hypotheses. + +Suppose X,Y and X',Y' have the same ambient dimension, X,X' are onto, Y,Y' +are injective, and XY=X'Y'=A. On L=im Y, the map Yu->Y'u is an isomorphism +respecting X and X'. Its restriction sends L intersect ker X to +im Y' intersect ker X', because both are the images of ker A. Extend it to +an isomorphism ker X->ker X', and therefore to L+ker X. Complete the domain +and target bases by lifts under X and X' of the same basis of a complement +to im A in U. The resulting invertible g obeys + +```text +gY=Y', X'g=X. (10) +``` + +Apply (10) independently in the four sectors to any sharp split and (9), +including its padding. Their direct sum g commutes with P0,Q0 and satisfies +gi=i', π'g=π. For any headers M,M' completing the splits, + +```text +(M')^-1 g M = diag(I_d,L), L invertible. +``` + +The two full pairs and hence their Schur complements are conjugated by this +block-diagonal map. Thus L simultaneously intertwines S,T with S',T'. This +controls the entire residual, including coordinates outside im K. It is not +merely equality of central spectra. It also proves independence of N. + +In the padded representative, i and π vanish on each unused sector direction. +Those directions are therefore untouched scalar residual summands, giving (2). +For the minimal representative, ker π has the parametrization + +```text +(v00,v10,v01,v11,extra11) + = (x+y+W^-1 Hz+W^-1 Nt, x, y, z, t). (11) +``` + +The residual of P0 on ker π is P0-P0 i πP0, and similarly for Q0: this follows +by subtracting the lower-left times upper-right block using πP0i=πQ0i=I. +Substitution of (11) gives exactly (3). + +### The extra nilpotent chains in odd characteristic + +Both W and R are invertible. Set + +```text +u=x-y, v=x+y-2z, c=z+WR^-1 v+R^-1 Nt. +``` + +This is an invertible change of coordinates: z=c-WR^-1v-R^-1Nt, +x=z+(v+u)/2 and y=z+(v-u)/2. Substitution into (3) shows both maps kill +c-directions and have output c=0; their remaining action is (4). In particular, +with Θ=H(2I-H)=HR, + +```text +S_core-T_core = [ 0 H -2N ], + [ R 0 0 ], + [ 0 0 0 ] + +Z_core = [ Θ 0 0 ], + [ 0 Θ -2RN ], + [ 0 0 0 ]. (12) +``` + +The invertible R commutes with H, so rank Θ^j=rank H^j for every j. Thus Θ has +exactly H's nilpotent block lengths. Put B=-2RN. Since R preserves im H and +induces an invertible map on U/im H, im B complements im Θ=im H. For +E=[Θ B;0 0], acting on U direct-sum F^a, + +```text +E^j = [Θ^j Θ^(j-1)B;0 0], +im E^j = im Θ^(j-1), j>=1. (13) +``` + +Consequently E has the nilpotent chains k_i+1: their rank sequence is +sum_i max(k_i+1-j,0)=rank H^(j-1), which uniquely determines a nilpotent +Jordan partition. Combine (12), the d common zero coordinates, and the scalar +summands (2) to obtain (5), (6), and the stated minimal polynomial. + +### The exact fixed-H weight + +For a sector product A of nullity c, take r=d+c+s. The argument (10) says GL_r +acts transitively on its full-rank factor pairs. We specialize the extension +stabilizer calculation of Nick Petalas +[PR4915](https://github.com/CrocSwap/integer-mult-bounds/pull/4915); the generic +method is credited rather than presented as new. + +Put L=im Y and K0=ker X. Choose + +```text +F^r = (L intersect K0) direct-sum R0 direct-sum Z0 direct-sum J, +dimensions: c, d-c, s, c, +L=(L intersect K0)+R0, K0=(L intersect K0)+Z0. +``` + +The stabilizer gY=Y, Xg=X consists exactly of + +```text +[ I 0 U V ] +[ 0 I 0 0 ] +[ 0 0 G E ] +[ 0 0 0 I ], +``` + +where G is arbitrary in GL_s and U,V,E have dimensions c-by-s, c-by-c, +s-by-c. Indeed g-I vanishes on L and has image in K0; these are precisely +the two stabilizer equations, and invertibility is equivalent to that of G. +Its order is G_s q^(c^2+2cs), so the sector factor count is +G_r/(G_s q^(c^2+2cs)). In (8), the first three products have c=0 and the last +has c=a. The four factor choices are independent: (8) already ensures all +split/pivot equations. Their product proves (7). Every split has exactly +G_(n-d) ordered bases of ker π, proving the complete-header count. + +## Concrete first fixtures + +For F3,H=J3(0), the minimal input profile is (3,3,3,4), n=13. The residual +has dimension 10 and Z has blocks (4,3,1,1,1). This explains the t^4 whole +minimal polynomial that motivated the handoff; a restricted t^3 annihilator +cannot remove the extra length-four chain. + +For d=1,H=0, profile (1,1,1,2), over F3 equation (7) gives +2^3*48/3=128 splits and 128*|GL4(F3)|=3,105,423,360 complete headers. +The complete split inventory contains 19,602 splits; the verifier computes +literal Schur ranks on every identity-pivot H=0 candidate and constructs an +actual ordered-pair intertwiner for every sharp one. Over F2 the count is +3 splits / 60,480 headers, recovering the earlier ssafwann +[PR4678](https://github.com/CrocSwap/integer-mult-bounds/pull/4678) fixture, +not claiming it as new. Binary padding in sectors 00,10,11 gives respectively +18,18,21 splits; padding 11 to dimension 3 checks the mixed exponent 2a s11. + +## Reproduction and evidentiary limits + +```sh +python3.12 -B scripts/research_package.py --package research/schur-nilpotent-extension +python3.12 -I -W error -B research/schur-nilpotent-extension/verify.py +python3.12 -I -W error -O -B research/schur-nilpotent-extension/verify.py +``` + +The standard-library checker uses explicit exception-based checks. It does not +import predecessor executables, access the network, invoke Git, or write files. +It checks: + +- All 834 nilpotent H in the complete domains d=1,2,3 over F2/F3 and d=1,2 + over F5. Full commuting pairs are built and literal Schur complements + compared by invertible coordinate maps to (3); all 765 odd-field cases are + also compared to (4), with their full central rank sequences checked. +- 45 padded fixtures, including J3 and J3 direct-sum J1. Both ordered padding + decompositions and concrete factor/header/residual intertwiners are checked. +- Five exhaustive scalar split domains, with all 188 sharp outcomes transported + to the canonical ordered residual; six independent full-rank factor censuses + check the stabilizer denominator (including binary d=2,r=4). +- Nine rejecting controls: nonsquare/nonnilpotent H, negative padding, binary + use of the odd formula, missing extended chain, missing stabilizer exponents, + and a rank-defective factor. Normal and optimized runs exercise the same checks. + +These are finite prime-field corroborations of the written proof, not an +exhaustive theorem check over arbitrary fields or a proof-kernel certificate. +The symbolic argument covers arbitrary fields / prime powers at the stated +boundaries. General nonnilpotent H, the characteristic-two central Jordan law, +later full-guard survival, unconditional state multiplicities, physical supplier +costs and selected-caller admission are unproved here. No Lean, Docker or full +selected scientific cold replay is claimed. The prior source-binding orientation +stopped at a sparse-omitted checkpoint; it was not a baseline pass. + +The package records exact main-source pins, source-head citations, overlap +coverage, verification environment and scope change in TASK.json/SOURCES.json. +Only these five package files are proposed for archive. Committed-byte, +source-history and exported read-only checks are recorded in the PR/handoff +because a package cannot embed its own final commit ID without changing it. + +## Open next questions + +1. For this same nilpotent family in characteristic two, determine the full + central Jordan partition from (3), starting with H=J2 and H=J3. The odd + change of coordinates is invalid there. This is a distinct bounded algebraic + question; no claim is held and no further census is authorized by this note. +2. If a named consumer actually needs these states, specify its header law and + cost allowance before asking for unconditional or later-guard transition + probabilities. Equation (7) is only fixed-H event mass. Different H may + coalesce into one residual orbit; physical cover and selection costs remain + unknown. Without that contract, stop this branch at the present result. + +## Attribution and source status + +Exact main-based source bytes are pinned in SOURCES.json. These are archived +predecessors, not automatically scientifically accepted theorems. We rely on the +stated sharp criterion in #4746 and give the used factor/stabilizer specialization +above so its application is independently reviewable. + +- Nick Petalas: [#4746](https://github.com/CrocSwap/integer-mult-bounds/pull/4746) + all-field sector criterion/construction, [#4597](https://github.com/CrocSwap/integer-mult-bounds/pull/4597) + ordered Schur factorization, [#4801](https://github.com/CrocSwap/integer-mult-bounds/pull/4801) + scalar central law/block question, and #4915 extension-stabilizer weights. +- MatShep #4762 and codyw912 #4735: factor-system equivalence and extension lemma. +- ssafwann: [#4657](https://github.com/CrocSwap/integer-mult-bounds/pull/4657), + [#4671](https://github.com/CrocSwap/integer-mult-bounds/pull/4671), #4678, + and pending #5256 at `c72d6ff431cf5c979f5010018d8eba0c15577bce`; the last supplies + the handoff and adapted matrix helpers, with no runtime dependency on its branch. +- Ryanson Jonathan #4609/#4617 and lee-phys #4634 retain sharpness/seed credit. + Mihir Srivastava #4689, JoyboyBrian #5072 and Krzysztof Wojt #5128 are distinct + successor state/incidence/arbitrary-pivot results, not reclassified as ours. +- Cinna Davis #4100 and source527/commdata2338/Jose Manuel retain the BIT/header + and normalizer context. Repository workflow tooling retains its original credit. diff --git a/research/schur-whole-central-class/vendor/block_source.py b/research/schur-whole-central-class/vendor/block_source.py new file mode 100644 index 0000000000..7bfce0e512 --- /dev/null +++ b/research/schur-whole-central-class/vendor/block_source.py @@ -0,0 +1,327 @@ +#!/usr/bin/env python3 +"""Block Schur central-action law: exact finite corroboration. + +ssafwann with substantial OpenAI Codex assistance. Apache-2.0. +Sector fixtures follow Petalas #4746 and ssafwann #4671; ordered factors +follow Petalas #4597. No predecessor executable is imported. +""" +from itertools import product +import json + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def zero(n, m): + return tuple((0,) * m for _ in range(n)) + + +def eye(n): + return tuple(tuple(int(i == j) for j in range(n)) for i in range(n)) + + +def add(a, b, q, scale=1): + require(len(a) == len(b) and all(len(r) == len(s) for r, s in zip(a, b)), + 'addition shape') + return tuple(tuple((x+scale*y) % q for x, y in zip(r, s)) + for r, s in zip(a, b)) + + +def mul(a, b, q): + require(a and b and all(len(row) == len(b) for row in a), 'product shape') + require(all(len(row) == len(b[0]) for row in b), 'ragged product') + bt = tuple(zip(*b)) + return tuple(tuple(sum(x*y for x, y in zip(r, c)) % q for c in bt) + for r in a) + + +def block(a, b, c, d): + return tuple(x+y for x, y in zip(a, b)) + tuple(x+y for x, y in zip(c, d)) + + +def rref(a, q, columns=None): + m = [list(row) for row in a] + width = len(m[0]) if m else 0 + pivots = [] + for j in range(width if columns is None else columns): + pivot = next((i for i in range(len(pivots), len(m)) if m[i][j]), None) + if pivot is None: + continue + k = len(pivots) + m[k], m[pivot] = m[pivot], m[k] + inv = pow(m[k][j], -1, q) + m[k] = [(x*inv) % q for x in m[k]] + for i in range(len(m)): + if i != k and m[i][j]: + t = m[i][j] + m[i] = [(x-t*y) % q for x, y in zip(m[i], m[k])] + pivots.append(j) + return tuple(tuple(row) for row in m), tuple(pivots) + + +def rank(a, q): + return len(rref(a, q)[1]) + + +def inverse(a, q): + n = len(a) + reduced, pivots = rref(tuple(r+s for r, s in zip(a, eye(n))), q, n) + require(len(pivots) == n, 'singular matrix') + return tuple(row[n:] for row in reduced) + + +def kernel(a, q): + reduced, pivots = rref(a, q) + width = len(a[0]) + columns = [] + for j in range(width): + if j not in pivots: + v = [0]*width + v[j] = 1 + for i, p in enumerate(pivots): + v[p] = -reduced[i][j] % q + columns.append(tuple(v)) + return tuple(zip(*columns)) + + +def matrices(q, d): + require(q in (2, 3, 5) and 0 < d <= 3 and q**(d*d) <= 625, + 'census capacity') + for data in product(range(q), repeat=d*d): + yield tuple(tuple(data[i*d:(i+1)*d]) for i in range(d)) + + +def complete_factor(t, q): + """X=[T,N] is onto, Y=[I;0] is injective, XY=T (#4746).""" + d = len(t) + x = t + for j in range(d): + trial = tuple(row+(int(i == j),) for i, row in enumerate(x)) + if rank(trial, q) > rank(x, q): + x = trial + y = eye(d) + zero(len(x[0])-d, d) + require(rank(x, q) == d and mul(x, y, q) == t, 'factor fixture') + return x, y + + +def construct(h, q): + """A sharp full pair with H prescribed; the 00 sector is padded to d.""" + d = len(h) + w = add(eye(d), h, q, -1) + factors = [(add(zero(d, d), w, q, -1), eye(d))] + factors += [complete_factor(t, q) for t in (w, w, h)] + x = tuple(sum((factor[0][i] for factor in factors), ()) for i in range(d)) + y = sum((factor[1] for factor in factors), ()) + sizes = tuple(len(factor[1]) for factor in factors) + require(mul(x, y, q) == eye(d), 'split construction') + basis = tuple(a+b for a, b in zip(y, kernel(x, q))) + inv = inverse(basis, q) + sectors = sum(((j,)*s for j, s in enumerate(sizes)), ()) + p0 = tuple(tuple(int(i == j and sectors[i] in (1, 3)) + for j in range(len(y))) for i in range(len(y))) + q0 = tuple(tuple(int(i == j and sectors[i] in (2, 3)) + for j in range(len(y))) for i in range(len(y))) + return mul(mul(inv, p0, q), basis, q), mul(mul(inv, q0, q), basis, q) + + +def schur(p, d, q): + r = tuple(row[d:] for row in p[:d]) + c = tuple(row[:d] for row in p[d:]) + tail = tuple(row[d:] for row in p[d:]) + return add(tail, mul(c, r, q), q, -1) + + +def poly(a, coefficients, q): + out = zero(len(a), len(a)) + for c in reversed(coefficients): + out = add(mul(out, a, q), eye(len(a)), q, c) + return out + + +def minimal_polynomial(a, q): + """First exact linear dependence of I,A,...,A^d; no root sampling.""" + d = len(a) + powers = [eye(d)] + for degree in range(1, d+1): + powers.append(mul(powers[-1], a, q)) + system = tuple(tuple(p[i][j] for p in powers[:-1]) + + (-powers[-1][i][j] % q,) + for i in range(d) for j in range(d)) + reduced, pivots = rref(system, q, degree) + if any(not any(row[:degree]) and row[degree] for row in reduced): + continue + require(len(pivots) == degree, 'first dependence uniqueness') + coefficients = tuple(reduced[i][-1] for i in range(degree)) + (1,) + require(poly(a, coefficients, q) == zero(d, d), 'annihilator computation') + return coefficients + raise ValueError('no minimal polynomial by dimension') + + +def inspect_pair(p, t, d, q): + n = len(p) + require(q in (2, 3, 5) and 1 <= d < n <= 18, 'field/dimension contract') + require(all(len(row) == n for row in p+t) and len(t) == n, 'square pair') + require(mul(p, p, q) == p and mul(t, t, q) == t, 'idempotent premise') + pq = mul(p, t, q) + require(pq == mul(t, p, q), 'commuting premise') + require(tuple(row[:d] for row in p[:d]) == eye(d) and + tuple(row[:d] for row in t[:d]) == eye(d), 'identity pivot premise') + h = tuple(row[:d] for row in pq[:d]) + s, u = schur(p, d, q), schur(t, d, q) + m = n-d + a1 = add(tuple(row[:d] for row in pq[d:]), + mul(tuple(row[:d] for row in t[d:]), h, q), q, -1) + a2 = add(tuple(row[:d] for row in p[d:]), + tuple(row[:d] for row in t[d:]), q, -1) + a = tuple(x+y for x, y in zip(a1, a2)) + b1 = add(tuple(row[d:] for row in p[:d]), tuple(row[d:] for row in t[:d]), q, -1) + b2 = add(mul(h, tuple(row[d:] for row in t[:d]), q), + tuple(row[d:] for row in pq[:d]), q, -1) + c = add(mul(s, u, q), mul(u, s, q), q, -1) + delta = add(s, u, q, -1) + z = mul(delta, delta, q) + w, j = add(eye(d), h, q, -1), add(h, mul(h, h, q), q, -1) + ks = block(w, add(zero(d, d), eye(d), q, -1), + add(zero(d, d), j, q, -1), h) + kt = block(eye(d), eye(d), zero(d, d), zero(d, d)) + theta = add(add(h, h, q), mul(h, h, q), q, -1) + theta2 = block(theta, zero(d, d), zero(d, d), theta) + require(mul(s, s, q) == s and mul(u, u, q) == u, 'residual idempotents') + require(mul(a, b1+b2, q) == c, 'ordered Schur factorization') + require(mul(s, a, q) == mul(a, ks, q), 'S action') + require(mul(u, a, q) == mul(a, kt, q), 'T action') + require(mul(z, a, q) == mul(a, theta2, q), 'block central intertwiner') + require(mul(z, s, q) == mul(s, z, q) and mul(z, u, q) == mul(u, z, q), + 'centrality') + require(mul(c, c, q) == mul(z, add(z, eye(m), q, -1), q), 'C squared') + mp = minimal_polynomial(theta, q) + pz = poly(z, mp, q) + require(mul(pz, c, q) == zero(m, m), 'commutator annihilator') + require(mul(mul(z, add(z, eye(m), q, -1), q), pz, q) == zero(m, m), + 'whole residual annihilator') + return {'h': h, 's': s, 't': u, 'a': a, 'c': c, 'z': z, + 'theta': theta, 'mp': mp, 'n': n, 'd': d, 'q': q} + + +def sharp_checks(data): + q, d, c, z = (data[k] for k in ('q', 'd', 'c', 'z')) + require(rank(c, q) == 2*d and rank(data['a'], q) == 2*d, 'sharp fixture') + powers = [c] + for _ in range(len(data['mp'])-2): + powers.append(mul(z, powers[-1], q)) + flat = tuple(tuple(x for row in p for x in row) for p in powers) + require(rank(flat, q) == len(data['mp'])-1, 'exact restriction minimal polynomial') + + +def jordan_check(data): + q, d, c, z, theta = (data[k] for k in ('q', 'd', 'c', 'z', 'theta')) + rows = [] + for lam in range(q): + left, right = c, eye(d) + zl = add(z, eye(len(z)), q, -lam) + tl = add(theta, eye(d), q, -lam) + ranks = [] + for _ in range(d+2): + require(rank(left, q) == 2*rank(right, q), 'doubled Jordan rank sequence') + ranks.append(rank(left, q)) + left, right = mul(zl, left, q), mul(tl, right, q) + rows.append(ranks) + return rows + + +def exhaustive_nonsharp(n, d): + free = [(i, j) for i in range(n) for j in range(n) if i >= d or j >= d] + projectors = [] + for values in product(range(2), repeat=len(free)): + p = [list(row) for row in eye(n)] + for (i, j), value in zip(free, values): + p[i][j] = value + p = tuple(tuple(row) for row in p) + if mul(p, p, 2) == p: + projectors.append(p) + count, histogram = 0, {} + for p in projectors: + for t in projectors: + if mul(p, t, 2) == mul(t, p, 2): + data = inspect_pair(p, t, d, 2) + r = rank(data['c'], 2) + histogram[r] = histogram.get(r, 0)+1 + count += 1 + return {'n': n, 'd': d, 'pairs': count, 'commutator_ranks': histogram} + + +def rejected(call, label): + try: + call() + except ValueError: + return label + raise ValueError('control accepted: '+label) + + +def controls(nilpotent, ternary, odd, nonscalar): + z, c = nilpotent['z'], nilpotent['c'] + out = [] + out.append(rejected(lambda: require(mul(z, c, 2) == zero(len(z), len(z)), + 'square-free replacement'), 'drop repeated root')) + z3 = ternary['z'] + out.append(rejected(lambda: require(poly(z3, ternary['mp'], 3) == zero(len(z3), len(z3)), + 'whole-space overclaim'), 'omit endpoint factors')) + a, h = nonscalar['a'], nonscalar['h'] + bad = block(h, zero(len(h), len(h)), zero(len(h), len(h)), h) + out.append(rejected(lambda: require(mul(nonscalar['z'], a, 2) == mul(a, bad, 2), + 'H in place of Theta'), 'replace Theta by H')) + h = odd['h'] + bad_theta = add(add(h, h, 5), mul(h, h, 5), 5) + bad = block(bad_theta, zero(2, 2), zero(2, 2), bad_theta) + out.append(rejected(lambda: require(mul(odd['z'], odd['a'], 5) == mul(odd['a'], bad, 5), + 'wrong odd-field sign'), 'replace minus by plus')) + identity = inspect_pair(eye(3), eye(3), 1, 2) + out.append(rejected(lambda: sharp_checks(identity), 'drop sharpness hypothesis')) + out.append(rejected(lambda: inspect_pair(eye(3), zero(3, 3), 1, 2), 'zero pivot')) + badp = ((1, 1, 0), (0, 0, 1), (0, 0, 0)) + out.append(rejected(lambda: inspect_pair(badp, eye(3), 1, 2), 'nonidempotent input')) + p = ((1, 0, 0), (0, 1, 0), (0, 0, 0)) + t = ((1, 0, 0), (0, 0, 0), (0, 1, 1)) + out.append(rejected(lambda: inspect_pair(p, t, 1, 2), 'noncommuting inputs')) + out.append(rejected(lambda: list(matrices(3, 3)), 'census capacity')) + return out + + +def main(): + coverage = [] + for q, d in ((2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (5, 1), (5, 2)): + count = 0 + for h in matrices(q, d): + p, t = construct(h, q) + data = inspect_pair(p, t, d, q) + require(data['h'] == h, 'prescribed compressed product') + sharp_checks(data) + count += 1 + coverage.append({'q': q, 'd': d, 'all_H': count}) + fixtures = [] + for q, h in ((2, ((0, 1, 0), (0, 0, 1), (0, 0, 0))), + (3, ((0, 1, 0), (0, 0, 1), (0, 0, 0))), + (5, ((0, 1), (1, 1))), + (2, ((0, 1), (1, 1)))): + data = inspect_pair(*construct(h, q), len(h), q) + sharp_checks(data) + data['jordan_ranks'] = jordan_check(data) + data['whole_mp'] = minimal_polynomial(data['z'], q) + fixtures.append(data) + extra = [exhaustive_nonsharp(3, 1), exhaustive_nonsharp(4, 2)] + require([x['pairs'] for x in extra] == [253, 1219], 'credited small-domain sizes') + require(fixtures[0]['mp'] == (0, 0, 1), 'binary nilpotent fixture') + require(fixtures[1]['mp'] == (0, 0, 0, 1) and + fixtures[1]['whole_mp'] == (0, 0, 0, 0, 1), 'ternary endpoint multiplicity') + failure_controls = controls(*fixtures) + receipt = {'sharp_H_domains': coverage, 'nonsharp_domains': extra, + 'fixtures': [{k: data[k] for k in ('q', 'd', 'n', 'h', 'theta', 'mp', 'whole_mp', 'jordan_ranks')} + for data in fixtures], 'rejected_controls': failure_controls} + print(json.dumps(receipt, sort_keys=True, indent=2)) + print('PASS_SCHUR_BLOCK_CENTRAL_LAW') + + +if __name__ == '__main__': + main() diff --git a/research/schur-whole-central-class/verify.py b/research/schur-whole-central-class/verify.py new file mode 100644 index 0000000000..270ce70b7c --- /dev/null +++ b/research/schur-whole-central-class/verify.py @@ -0,0 +1,197 @@ +"""Corroborate the full central class with independent full-matrix invariants. + +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. +Frozen fixture construction is credited in NOTICE.md. +""" +import argparse +import hashlib +from itertools import product +import json +from pathlib import Path +import sys +HERE=Path(__file__).resolve().parent +sys.path.insert(0,str(HERE)) +from central import classify, representative +from block_source import construct, matrices + + +def need(value,message): + if not value: raise ValueError(message) + + +def ident(n): return tuple(tuple(int(i==j) for j in range(n)) for i in range(n)) + + +def plus(a,b,q,sign=1): + return tuple(tuple((x+sign*y)%q for x,y in zip(r,s)) for r,s in zip(a,b)) + + +def mm(a,b,q=None): + bt=tuple(zip(*b)) + result=tuple(tuple(sum(x*y for x,y in zip(r,c)) for c in bt) for r in a) + return result if q is None else tuple(tuple(x%q for x in row) for row in result) + + +def rank_columns(a,q): + basis={} + for column in zip(*a): + v=list(column) + for pivot in sorted(basis): + if v[pivot]: + c=v[pivot];v=[(x-c*y)%q for x,y in zip(v,basis[pivot])] + pivot=next((i for i,x in enumerate(v) if x),None) + if pivot is not None: + c=pow(v[pivot],-1,q);basis[pivot]=[(c*x)%q for x in v] + return len(basis) + + +def charpoly(a,q): + # Faddeev-LeVerrier over integer lifts; divide before reducing modulo q. + n=len(a);b=ident(n);coeff=[1] + for k in range(1,n+1): + b=mm(a,b);trace=sum(b[i][i] for i in range(n)) + need(trace%k==0,'integer characteristic division') + c=-trace//k;coeff.append(c) + b=tuple(tuple(x+c*int(i==j) for j,x in enumerate(row)) for i,row in enumerate(b)) + return tuple(x%q for x in reversed(coeff)) + + +def trim(p): + p=list(p) + while len(p)>1 and p[-1]==0:p.pop() + return tuple(p) + + +def divide(a,b,q): + work=list(a);out=[0]*max(1,len(a)-len(b)+1) + while len(work)>=len(b) and any(work): + k=len(work)-len(b);c=work[-1]*pow(b[-1],-1,q)%q;out[k]=c + for j,x in enumerate(b):work[k+j]=(work[k+j]-c*x)%q + work=list(trim(work)) + return trim(out),trim(work) + + +def factors(poly,q): + remaining=poly;out=[];degree=1 + while len(remaining)>1 and 2*degree<=len(remaining)-1: + need(q**degree<=100000,'factor oracle capacity') + for coefficients in product(range(q),repeat=degree): + f=tuple(coefficients)+(1,);used=False + while True: + quotient,remainder=divide(remaining,f,q) + if remainder!=(0,):break + remaining=quotient;used=True + if used:out.append(f) + degree+=1 + if len(remaining)>1:out.append(remaining) + return out + + +def polynomial(a,p,q): + n=len(a);out=tuple((0,)*n for _ in range(n)) + for c in reversed(p):out=plus(mm(out,a,q),ident(n),q,c) + return out + + +def signature(a,q): + cp=charpoly(a,q);result=[] + for f in factors(cp,q): + b=polynomial(a,f,q);current=ident(len(a));ranks=[len(a)] + for _ in range(len(a)+1): + current=mm(current,b,q);ranks.append(rank_columns(current,q)) + if ranks[-1]==ranks[-2]:break + need(ranks[-1]==ranks[-2],'rank sequence did not stabilize') + blocks=[];degree=len(f)-1 + for size in range(1,len(ranks)-1): + numerator=ranks[size-1]-2*ranks[size]+ranks[size+1] + need(numerator>=0 and numerator%degree==0,'invalid primary multiplicity') + blocks += [size]*(numerator//degree) + result.append({'polynomial':list(f),'exponents':sorted(blocks,reverse=True)}) + need(sum((len(r['polynomial'])-1)*sum(r['exponents']) for r in result)==len(a),'primary dimension') + return {'characteristic_polynomial':list(cp),'primary_blocks':result} + + +def pad(a,values): + n=len(a);m=len(values) + return tuple(tuple(row)+(0,)*m for row in a)+tuple((0,)*n+tuple(values[i]*int(i==j) for j in range(m)) for i in range(m)) + + +def inspect(h,q,extra=()): + p,t=construct(h,q);d=len(h) + if extra:p=pad(p,[a for a,b in extra]);t=pad(t,[b for a,b in extra]) + need(mm(p,p,q)==p and mm(t,t,q)==t and mm(p,t,q)==mm(t,p,q),'source premises') + need(tuple(row[:d] for row in p[:d])==ident(d) and tuple(row[:d] for row in t[:d])==ident(d),'identity pivot') + pq=mm(p,t,q);need(tuple(row[:d] for row in pq[:d])==h,'compressed H') + def schur(a):return plus(tuple(row[d:] for row in a[d:]),mm(tuple(row[:d] for row in a[d:]),tuple(row[d:] for row in a[:d]),q),q,-1) + s,u=schur(p),schur(t);m=len(s) + k=plus(mm(s,u,q),mm(u,s,q),q,-1);z=mm(plus(s,u,q,-1),plus(s,u,q,-1),q) + need(rank_columns(k,q)==2*d,'sharp premise') + a1=2*m-rank_columns(s+plus(u,ident(m),q,-1),q)-rank_columns(plus(s,ident(m),q,-1)+u,q) + predicted=classify(h,m,a1,q);model=representative(predicted,q) + actual=signature(z,q);expected=signature(model,q) + need(actual==expected,'full central similarity invariants differ') + return {'field':q,'h':[list(row) for row in h],'padding':[list(x) for x in extra], + 'prediction':predicted,'invariants':actual} + + +def jordan(size,lam=0,q=2):return tuple(tuple((lam*int(i==j)+int(j==i+1))%q for j in range(size)) for i in range(size)) + + +def reject(call): + try:call() + except ValueError:return + raise ValueError('control accepted') + + +def controls(): + h=jordan(3);base=inspect(h,2);zero=inspect(h,2,((0,0),));one=inspect(h,2,((0,1),)) + need(zero['prediction']['dimension']==one['prediction']['dimension'] and zero['h']==one['h'],'same input class control') + need(zero['invariants']!=one['invariants'],'opposite-sector count is necessary') + need(base['prediction']['endpoint_blocks']['0']==[2,2,2,2,1,1],'characteristic-two J3 law') + odd=inspect(h,3);need(odd['prediction']['endpoint_blocks']['0']==[4,3,1,1,1],'credited odd law') + repeated=inspect(jordan(4,1,2),2) + need(max(repeated['prediction']['endpoint_blocks']['1'])>1,'endpoint-one repeated blocks') + reject(lambda: classify(h,5,0,2)) + reject(lambda: classify(h,10,5,2)) + reject(lambda: classify(h,10,0,4)) + reject(lambda: classify(((0,1),),10,0,2)) + odd_nonsplit=inspect(((0,0,0,2),(1,0,0,0),(0,1,0,1),(0,0,1,0)),3) + need(any(len(r['polynomial'])==3 and max(r['exponents'])>1 for r in odd_nonsplit['invariants']['primary_blocks']), 'non-split repeated central factor') + return {'groups':9,'odd_nonsplit':odd_nonsplit,'same_h_dimension_different_classes':[zero,one],'binary_j3':base,'ternary_j3':odd,'endpoint_one':repeated} + + +def main(): + ap=argparse.ArgumentParser();ap.add_argument('--write',action='store_true');ap.add_argument('--small',action='store_true');args=ap.parse_args() + record=controls() + if args.small: + print('PASS_SMALL_WHOLE_CENTRAL');return + digest=hashlib.sha256();domains=[] + for q,d in ((2,1),(2,2),(2,3),(3,1),(3,2),(5,1),(5,2)): + count=0 + for h in matrices(q,d): + result=inspect(h,q);digest.update(json.dumps(result,sort_keys=True).encode());count+=1 + domains.append({'field':q,'dimension_h':d,'count':count}) + examples=[] + for q in (2,3,5,7): + for size in (2,3,5): + for lam in (0,1):examples.append(inspect(jordan(size,lam,q),q,((0,0),(1,1),(0,1),(1,0)))) + # Companion of (t^2+t+1)^2 over F2: non-split and repeated. + h=((0,0,0,1),(1,0,0,0),(0,1,0,1),(0,0,1,0)) + examples.append(inspect(h,2)) + # A mixed primary example has endpoints and a non-split component. + h=((0,1,0,0),(0,0,0,0),(0,0,0,1),(0,0,1,1)) + examples.append(inspect(h,2,((0,1),))) + record.update({'domains':domains,'exhaustive_cases':sum(r['count'] for r in domains), + 'exhaustive_result_sha256':digest.hexdigest(),'additional_examples':examples}) + sources=json.loads((HERE/'SOURCES.json').read_text()) + for r in sources['files']: + if '/vendor/' in r['path']: + local=HERE/'vendor'/Path(r['path']).name + need(hashlib.sha256(local.read_bytes()).hexdigest()==r['sha256'],'source byte drift') + record['files']={p.relative_to(HERE).as_posix():hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted(HERE.rglob('*')) if p.is_file() and '__pycache__' not in p.parts and p.name!='RESULT.json'} + if args.write:(HERE/'RESULT.json').write_text(json.dumps(record,indent=2,sort_keys=True)+'\n') + else:need(record==json.loads((HERE/'RESULT.json').read_text()),'receipt drift') + print('PASS_SCHUR_WHOLE_CENTRAL',json.dumps({'exhaustive_cases':record['exhaustive_cases'],'additional_examples':len(examples),'controls':record['groups'],'result_sha256':digest.hexdigest()})) + + +if __name__=='__main__':main()