diff --git a/research/p112-six-seven-supplement/CALLERS.md b/research/p112-six-seven-supplement/CALLERS.md new file mode 100644 index 0000000000..8ff50ac851 --- /dev/null +++ b/research/p112-six-seven-supplement/CALLERS.md @@ -0,0 +1,173 @@ +# Nine literal C1 piece profiles excluded + +## Exact source and statement + +Use the P112 evaluation code $C$ and binary support weight + +$$ + w(p)=\dim_{\mathbf F_2} + \operatorname{span}\{\ell(r):p(r)\ne0\} +$$ + +from [PROOF.md](PROOF.md), over an arbitrary characteristic-zero field. +Let independent pieces $p_1,\ldots,p_n$ span $T$, and put $D=T\cap C$. + +For each row below there is no such independent family with the displayed +weight upper bounds and $\dim D\ge d$. +The displayed $t$ and slack are the literal source tags, with +$n=d+t$ and $\text{slack}=\sum W-8d$. +The theorem uses only the independent-piece and intersection hypotheses; +it does not require a minimum basis or a decoder realization. + +| Source $t$ | $d$ | Slack | Weight bounds $W$ | Small supports remaining after the deletion | Site cap | +|---:|---:|---:|---|---|---:| +| 2 | 1 | 7 | $7,6,2$ | one rank-two piece | 2 | +| 2 | 1 | 8 | $7,6,3$ | one rank-three piece | 4 | +| 2 | 2 | 6 | $7,7,6,2$ | one rank-two piece | 2 | +| 2 | 2 | 7 | $7,7,6,3$ | one rank-three piece | 4 | +| 3 | 1 | 7 | $7,6,1,1$ | two rank-one pieces | 2 | +| 3 | 1 | 8 | $7,6,2,1$ | rank-two and rank-one pieces | 3 | +| 3 | 2 | 6 | $7,7,6,1,1$ | two rank-one pieces | 2 | +| 3 | 2 | 7 | $7,7,6,2,1$ | rank-two and rank-one pieces | 3 | +| 3 | 2 | 8 | $7,7,6,2,2$ | two rank-two pieces | 4 | + +All nine are recorded survivors in DreamingOfClouds's +[PR3154](https://github.com/CrocSwap/integer-mult-bounds/pull/3154), +pinned at +`708f0ad8928c383de8294aea3c126e9461d2066d`. +Their exact source files are + + research/p112-reduction-to-conjectures/checks/CONJG2/NOTES.md + research/p112-reduction-to-conjectures/checks/CONJG2/land_e2_k8.out + research/p112-reduction-to-conjectures/checks/CONJG2/land_e3_k8.out. + +The two output files are retained byte-for-byte under this package's +inputs and authenticated by [SOURCES.json](SOURCES.json). The first +records 35 profiles and the second 280. Those are the source's recorded +lists, not a claim about the number currently unresolved by every +subsequent public theorem. + +## Dimension-deletion lemma + +Suppose $T$ is spanned by independent pieces. Their coefficients identify +$T$ with $K^n$. If $\dim(T\cap C)\ge d$, imposing zero coefficients +on any chosen $d-1$ pieces leaves a nonzero codeword. + +Indeed, restrict the corresponding $d-1$ coordinate functionals to +$D=T\cap C$. Their common kernel has dimension at least +$\dim D-(d-1)\ge1$. A nonzero vector in that kernel is a nonzero +codeword because the original pieces are independent. This argument +allows $\dim D>d$; equality is unnecessary. + +Each table row has exactly $d$ designated rank-seven pieces. +For $d=1$, choose any nonzero word in $D$. +For $d=2$, set the coefficient of one designated rank-seven piece +to zero by the lemma. In both cases the resulting nonzero word is a +linear combination of + +* one piece of binary support rank at most seven; +* one piece of binary support rank at most six; +* the displayed small pieces, whose union has at most four sites. + +The site cap follows from the labels' leading one: +a rank-one, rank-two or rank-three support has at most $1,2,4$ sites. +Taking linear combinations does not enlarge any piece's support, and +aggregating the small pieces has support contained in their union. +Arbitrary overlap and cancellation are permitted. + +The nonzero word therefore contradicts the theorem of +[PROOF.md](PROOF.md). This proves every row of the table. +There is no quotient-normalization step and no inference from a failed +support search. + +## What the caller theorem establishes + +The source CONJG2 section3 uses $T$ as the low-weight subspace, +$d=\dim(T\cap C)$, $e=\dim T-d=t$, and slack +$\operatorname{cost}(T)-8d$. A minimum basis of that $T$, if it has +one of the nine displayed profiles, is an independent family satisfying +the exact hypotheses just excluded. Thus these nine profiles cannot +occur as such a minimum basis. + +This implication does not assume the source's N8 correction cap, the +completeness of the 35/280 lists, or its global peeling and branch-coverage +arguments. It is valid for each displayed piece family in isolation. +It also does not show that an arbitrary actual decoder basis is adapted +to $T$. A basis-surplus unit can change the number of actual low and +high members; no argument about those members' restricted dual rows is +needed here. + +Consequently this caller argument supplies nine literal T-level exclusions +with a uniform geometric mechanism. [D1.md](D1.md) separately proves the +complete actual d=1 marked/unmarked invoices and stated singleton consumer +using the additional retained matched-cut geometry. [D2.md](D2.md) extends the actual invoice to d=2. Complete C1, actual +d>=3 invoices, global normalization and supplier admission remain outside +the package result. +It does not certify a present global survivor count. + +## Boundary and further work + +The sharp partition in [PROOF.md](PROOF.md) has piece ranks $7,6,4$. +Splitting its five-site remainder into four sites and the root singleton +gives ranks $7,6,3,1$, independent pieces, code intersection dimension +one, minimum basis cost seventeen, and slack nine. Minimum cost follows +from the disjoint-support determinant matching argument in that proof. +Hence the primary obstruction cannot simply be +extended from four small sites to five, or used to discard that nearby +T-level boundary. That fixture is not an actual marked decoder. + +The actual d=1 argument in D1.md retains all basis-surplus scenarios and +closes the cost-seventeen invoice without excluding its feasible T-space. +The remaining higher-d profiles require further shared-cover or coefficient +arguments. This caller inventory does not certify a current global survivor count. + +Credit DreamingOfClouds for the source reduction, notation, filters and +recorded profiles; credit PR2816 and the retained E8/P112 lineage for the +piece model and earlier circuit/quotient methods. The new dimension-deletion +application is by conorholds with substantial OpenAI Codex assistance. + +## Appendix: inherited four-six pencil composition + +There is also a useful direct composition of the earlier coordinate-kernel +and root-pencil method. Credit Nick Petalas's PR3171, head +`95b683196950efea6f3d7ac66745e00dba73425e`, +`research/p112-quotient-parity/PROOF.md`, and DreamingOfClouds's PR2816, +head `4c32ac3b88d63ad06d2b30e526aa07a12929db36`, for the retained +root-rigidity and circuit/pencil lineage. This appendix records a caller +composition, not a new geometric mechanism. + +**Four-six-plus-nine lemma.** Suppose an independent piece family has four +designated pieces of binary support rank at most six. Suppose every other +piece is supported in one common set E of at most nine live sites. Its span +cannot meet C in dimension at least two. + +Choose a two-dimensional subspace D of that intersection, and restrict the +four designated piece-coordinate functionals to D. For any two of these +functionals, their joint kernel is zero: a nonzero vector there would be a +codeword supported on the other two rank-six pieces and E, hence on at most +`20+20+9=49<53` sites. Each single functional is consequently nonzero and +has a one-dimensional kernel, and the four kernel lines are distinct. +On each kernel line a nonzero codeword is supported on three rank-six +pieces and E, hence on at most `3*20+9=69<70` sites. Root-direction +rigidity identifies each with an E8 root line, including frame roots. +Injectivity of root evaluation puts four distinct root lines in the same +two-dimensional normal space. This is impossible: a rank-two subsystem of +the simply laced E8 root system is A1+A1 or A2 and has at most three +projective root lines. The argument works over any characteristic-zero +field by the same rational-line transfer as the retained pencil method. + +More generally, for d>=2, if the original code intersection has dimension at least d, +first kill any d-2 chosen piece coordinates. The dimension-deletion lemma +leaves an intersection of dimension at least two. The preceding lemma then +applies whenever the remaining pieces consist of four rank-at-most-six +pieces and pieces supported in a common set of at most nine sites. + +For the pinned PR3154 outputs, deleting the heaviest d-2 pieces and applying +this criterion selects two literal t2 rows and 83 literal t3 rows. In t2 +the four remaining pieces all have rank at most six. In t3 the five +remaining pieces include four of rank at most six and one of rank at most +four; the latter has support at most eight, so can serve as E. These are +implications for the literal recorded profiles, not 85 currently open +cases or 85 first closures. They neither establish completeness of those +historical lists nor bypass the actual-basis and normalization obligations +for higher-d invoices. diff --git a/research/p112-six-seven-supplement/D1.md b/research/p112-six-seven-supplement/D1.md new file mode 100644 index 0000000000..ff16374c64 --- /dev/null +++ b/research/p112-six-seven-supplement/D1.md @@ -0,0 +1,525 @@ +# Actual marked invoices at d = 1 + +Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0. +This deduction uses the supplement theorem in [PROOF.md](PROOF.md), together +with explicitly identified geometric and actual-basis lemmas from the earlier +marked-invoice package. It is a written proof, separate from the finite checks +of the supplement's core. + +## Statement and exact scope + +Use the E8/P112 code over an arbitrary characteristic-zero field K. There are +eight orthogonal frame roots f_i, 112 live root lines P, their leading-one +binary labels ell_s, and excluded frame labels z_i. Write + + C_h(s) = (r_s,h), C = {C_h : h in K^8}, + U(q) = span_F2 {ell_s : q(s) != 0}, w(q) = dim U(q). + +Let S contain C, dim S = 8+t, and let F=(q_j) be an ACTUAL basis of S. +For its actual dual basis phi_j write + + phi_j(C_h) = (x_j,h), C_h = sum_j (x_j,h)q_j. + +Assume all x_j are nonzero. A member is corrected when x_j is proportional +to a frame root f_i and z_i belongs to U(q_j). Let n_c count these actual +members, and put + + I = sum_F w(q) - n_c, + T = span_K {q in S : w(q) <= 7}, d = dim(C intersect T). + +Assume d=1 and that some actual index k has + + x_k = gamma r_v, gamma != 0, v in P. (M) + +For **either t=2 or t=3, I>=65**. + +Consequently I-epsilon>=64 for either conclusion and every epsilon in +{0,1}, including epsilon=[ell_v in U(q_k)]. The marked source's additional +witness g, with g|O_v=0 and phi_k(g)!=0, is unnecessary here. These statements +do not assume N8, distinct corrected low frame indices, a minimum actual +basis, or that F intersect T spans T. No cost-65 sharpness claim is made. + +Without (M), both values of t satisfy the **unmarked floor I>=64**. +Section 7 proves this separately. Section 8 consequently extends the +actual singleton-pivot consumer to t in {2,3},d=1 under its stated actual rank +and nonparallel hypotheses. + +The t=3 cost_w(T)=17 boundary is genuine at the T-space level: +the supplement's [7,6,3,1] witness has cost 17 and d=1. It is not an actual +marked-decoder counterexample. Section 6 handles its actual correction +budget, rather than incorrectly excluding that T-space. + +## Inputs, credits and transfer + +The actual setting and ledger are DreamingOfClouds' PR3154, head +`708f0ad8928c383de8294aea3c126e9461d2066d`, CONJ-G Section 0 and CONJG2 +Sections 0--3. We do not use its normalized N8 argument or assume its lists +cover a raw t=3/slack-nine branch. + +The raw actual correction bound is conorholds' PR3455, head +`91a5a6b2734d2bf8d7ef701423544462e83b27d0`, +`research/e8-marked-d0-invoice/RAW-COUNT.md`: under (M), for m=|F|<=11, +**n_c<=m-2**, for every d. Its proof uses the actual code expansion and +frame grouping, and neither g nor normalization. Thus n_c<=8 for t=2 and +<=9 for t=3. + +Other inputs from that package's PROOF.md are G1, G2, G4, G5 and Section 7: + +1. Binary support capacities at ranks 1,...,7 are + `(1,2,4,8,12,20,36)`. A rank-one/two live support cannot carry any frame + label. Every nonzero codeword has at least 53 live sites. Root and frame + targets have at most 32 sites in a rank-seven flat and at most 20 in a + rank-six flat. +2. A frame word has support N(f_i), of size 56. If a rank-eight hyperplane + contains z_i, at least 24 sites of N(f_i) lie outside it (matched cut G2). +3. For distinct frame indices i,j, a normal in span(f_i,f_j) with both + coefficients nonzero has one of the three support strata represented by + f_i+f_j, f_i-f_j, f_i+2f_j. For every binary hyperplane H containing z_i, + the labels of `Off(h) minus H minus {u}` have rank eight for EVERY live + site u (G4, including the generic coefficient stratum). +4. Every live root meets exactly four frame axes. The incidence blocks and + their sign choices imply that N(f_i) spans K^8; hence restriction of the + eight-dimensional root code to N(f_i) is injective. + +G4 is a genuine retained finite geometric input, not a consequence of the +new quarter-capacity proof: PR3455 identifies it with PR3166, head +`7c2a62363ad4945e8803fedea6ead78e1ad412b2`, EXTENSION Section 6's complete +56 ordered frame pairs times three support strata +times 255 matched hyperplanes, checked by two implementations. The present +argument does not claim to replace that check with a new analytic proof. + +We also use PR3455 PROOF.md Section 3's elementary restricted-axis count: +a normal supported on at most three frame axes, with at least two nonzero +coefficients, has at least76 live nonzeros. For two axes the support is76 +when their coefficients are equal up to sign, and88 otherwise. For three +axes its minimum is80. These statements follow from G5's sign +multiplicities: the two-axis strata have singleton multiplicities32 and +signed-pair multiplicities12; the three-axis strata have singleton16, +signed-pair8 and signed-triple2. With three nonzero coefficients, all +equal up to signs gives80; exactly one equal pair gives at least94; and +no equal pair gives at least102. Vanishing two signed triple forms would +force a coefficient to vanish. This calculation is valid over K in +characteristic zero, with no order or absolute-value assumption on K. +No global D7/E6 direction classification is needed below. + +The supplement's analytic capacity arguments retain Nick Petalas' +PR3269/3300 and David Arias' earlier E8 quadratic-model credit as recorded +in PROOF.md and SOURCES.json. None of the arguments here follows from a +printed census alone. + +## 1. Actual surplus bookkeeping + +We prove the stronger common budgeted lemma: if d=1 and sum_F w<=72 for +t=2, or <=73 for t=3, then I>=65. For contradiction assume I<=64 under +that budget. The mark is not used inside this lemma. It will only establish +the budget when assembling the marked theorem. +The dimension inequality dim T<=t+d follows from C+T contained in S. +The labels are nine-bit, so every piece has w<=9. An actual member +outside T cannot have weight<=7, and therefore has weight eight or nine. +The basis-free peeling inequality used here is + + cost_w(S) >= cost_w(T) + 8(dim S-dim T). + +Indeed the threshold spaces S_(<=j), j<=7, all lie in T and equal T's +corresponding threshold spaces. A greedy minimum basis therefore consists +of a minimum T-basis and dim S-dim T additional vectors of weight at least +eight. This compares minimum costs before making any assertion about F. + +If dim T=t+1, then S=C+T. Write a=dim T, f=|F intersect T|, r=a-f, +and s=cost_w(T)-8. Let c9 count actual members OUTSIDE T of weight nine, +and define + + eta = sum_(q in F intersect T) w(q) + 8r - cost_w(T). + +The actual low members are independent and can be completed to a T-basis +by r words of weight at most seven, because those words span T. Therefore +eta>=r, even when a member of F intersect T itself has weight eight. +Direct counting of the 7+r outside members gives the exact identity + + Delta := sum_F w - 64 = s + eta + c9. (1) + +Thus I<=64 implies Delta<=n_c. In the cases below this leaves eta+c9<=1, +or eta=c9=0. This is what controls the actual basis; no adaptation is +assumed. + +For t=2, dim T=3 follows automatically. Indeed dim T cannot be one: +a one-dimensional space generated by weight-at-most-seven words cannot +contain a nonzero codeword. If dim T=2, a minimum low basis whose span +contains a codeword has cost at least14: a total at most13 either has support below53, +or consists of a rank-seven part and parts of combined rank at most six, +contradicting the supplement. Peeling then gives + + cost_w(S) >= 8(10-2)+14 = 78 > 72. + +Consequently dim T=3 and cost_w(T)<=72-8*7=16. This step uses neither the +source's x=0 normalization nor its finite survivor list. + +For t=3 the same argument gives dim T=4 and cost_w(T)<=17. More explicitly, +any low space containing a nonzero codeword has minimum cost at least14: +at total cost at most13, if a weight-seven basis member occurs, all others +have combined rank at most six and the supplement excludes their cover; +if none occurs, the largest support-capacity sum is `20+20+1=41<53`. +Thus dim T<=3 would give cost_w(S)>=8(11-3)+14=78>73. Dimension four then +gives cost_w(T)<=73-8*7=17. Section 6 handles the remaining cost17 case. + +## 2. Complete minimum-profile exhaustion through cost sixteen + +Take a minimum basis of T. Its weights are positive and at most seven. +Its support covers a nonzero codeword and therefore at least53 sites. +Use the rank capacities above; if the total support bound is below70, the +covered codeword is a root/frame direction, and each seven-flat then has +the stronger target capacity32. + +For three pieces of total weight at most16: + +* If all weights are at most six, the largest support bound is + `g(6)+g(6)+g(4)=48`. +* If the largest is seven and the second at most four, the bound is at + most `36+8+8=52`. +* If the second is five, only [7,5,4] can reach53; its crude bound56 forces + a root/frame target, whose bound becomes `32+12+8=52`. +* If the second is six, the third is at most three. The supplement excludes + all [7,6,c], c<=3, since the third support has at most four sites. +* The remaining possibilities are precisely **[7,7,1] and [7,7,2]**. + +For four pieces of total weight at most16: + +* If all weights are at most six, the largest support bound is + `g(6)+g(6)+g(3)+g(1)=45`. +* If the largest is seven and the second at most three, the bound is at + most `36+4+4+4=48`. +* With second weight four, only [7,4,4,1] can reach53; target32 reduces its + bound to49. With second weight five, only [7,5,3,1] can reach53, and its + target bound is likewise49. +* With second weight six, only [7,6,1,1] and [7,6,2,1] need consideration. + The supplement excludes both: their small supports total at most three. +* The remaining possibility is precisely **[7,7,1,1]**. + +This exhausts all positive integer profiles in the stated ranges, without +the source's LP, N8, Pencil or Lemma N. Their costs and slacks are + +| t | Minimum T profile | cost_w(T) | s | +|---|---|---:|---:| +|2|[7,7,1]|15|7| +|2|[7,7,2]|16|8| +|3|[7,7,1,1]|16|8| + +For a minimum weighted basis the numbers of vectors at each weight +threshold are fixed by the dimensions of T_(<=w) (the matroid greedy +formula). We use this elementary fact to constrain actual bases next. + +## 3. The complete non-adapted boundary + +If r>0, equation(1), eta>=r and the budget force r=eta=1,c9=0. +The t=2 minimum profile must be [7,7,1]; [7,7,2] has s=8 and no surplus +available. Completing F intersect T by one weight-at-most-seven vector +must attain the minimum, so the ACTUAL inside profile is [7,1]. For t=3 +it is [7,1,1]. Let L span these actual inside members. Its support has +at most37 or38 sites, respectively, so C intersect L=0. Dimensions give + + S = C direct-sum L. + +There are exactly eight actual outside members, all of weight eight. +Their high restricted code duals form a basis. Write their code normals +as h_l and their duals as mu_l; the actual coefficient map is + + q_l=C_(h_l)+A(h_l), A(h)=-sum_(b in F intersect T) (x_b,h)b. + (2) + +All corrected high frame indices are distinct. If J is their set, a +corrected high matched to i has h_l supported on its own frame axis i and +the unmatched frame axes, with nonzero coefficient at i. These assertions +come from actual duality, not projected normalization. + +For t=2, Delta=8 and I<=64 force n_c>=8. At most one actual low is +corrected, so at least seven weight-eight highs are corrected. If all +eight are corrected, their normals are frame axes. If seven are corrected, +each normal is in span(f_i,f_j0), where j0 is the one unmatched axis. +For a non-axis such normal, put H=U(q_l). Equation(2) forces + + Off(h_l) minus H subset supp(b_7) union {u}, + +where u is the unit low's site. After deleting u those labels have rank +at most seven, contradicting G4. Hence at least seven corrected high +normals are frame axes. Each needs at least24 cancellations from the +37-site support of L by G2. Every live site meets only four frame axes, +so `7*24 <= 4*37`, a contradiction. This is exactly the actual-(7,1) +argument of PR3455 Section 7, whose proof only needs C direct-sum L and +the displayed actual profile, not L=S_(<=7). + +For t=3, Delta=9 forces n_c>=9. Only the weight-seven low can be corrected, +so it is corrected and all eight highs are corrected frame-axis normals. +For a frame axis different from the corrected low's index, equation(2) +uses only the two unit lows. Its support has at most two sites, whereas a +corrected weight-eight frame high requires24 cancellations by G2. This is +impossible. Thus EVERY non-adapted case is excluded. + +## 4. Actual adapted bases: all surplus possibilities + +Now r=0, so F intersect T is an actual T-basis and there are seven outside +members. The allowed actual inside profiles are exactly as follows: + +| Minimum profile | eta | Possible actual inside profile | +|---|---:|---| +|[7,7,1]|0|[7,7,1]| +|[7,7,1]|1|[8,7,1]| +|[7,7,2]|0|[7,7,2]| +|[7,7,1,1]|0|[7,7,1,1]| +|[7,7,1,1]|1|[8,7,1,1] or [7,7,2,1]| + +To verify exhaustiveness, the minimum [7,7,1] profile has dim T_(<=6)=1, +generated by its unique unit direction; an actual weight-two replacement +in that line still has weight one. At most one surplus unit can therefore +only raise one seven to eight. For [7,7,1,1], T_(<=6) is exactly the span +of its two unit vectors, so a surplus unit either raises one seven to +eight or changes a unit-space basis from weights [1,1] to [2,1]. Raising +both units gives surplus two. For [7,7,2] no surplus is available. The +threshold-dimension formula rules out every profile with fewer than two +members of weight at least seven. Also c9 can be one only when eta=0. + +Let C_h span C intersect T. Corrected high duals are independent and +annihilate h, so they are distinct frame axes perpendicular to h. +For independence, the seven high coordinate functionals form a basis of +Ann(T) in S*. Restriction Ann(T) to C* has kernel Ann(C+T)=Ann(S)=0, +since dim T=t+1 gives C+T=S. This proves independence of their actual +restricted duals directly. + +The minimum profiles cover Off(h) by two seven-flats and at most two +additional sites, so |Off(h)|<=74. Every row of the actual-profile table +has at most two potentially corrected inside members, since its other +weights are at most two. The actual ledger requires n_c>=Delta>=s>=7; +hence at least five independent corrected high frame axes annihilate h. +The normal h is therefore supported on at most three frame axes. The +restricted-axis count above excludes every non-axis direction with at +most74 nonzeros. Thus h must be a frame direction. This argument counts +corrected weight-nine highs too; none is silently discarded. + +## 5. The frame-direction case, including its equality obstruction + +It remains that h=f_0 up to a scalar. Let + + W0 = z_0^perp_beta, N0 = N(f_0). + +The live root labels in W0 are exactly N0. In any minimum T-basis from +Section 2, each of the two seven-flats lies INSIDE W0. Otherwise its +intersection with W0 has rank at most six and meets N0 in at most20 +sites; the other seven-flat meets N0 in at most32 and the small pieces +add at most two, totaling54<56. Thus + + supp(T) subset N0 union E, |E|<=2. (3) + +No frame label lies in W0, since beta(z_0,z_i)=1 for every frame index i. +Every weight-seven actual member can be included with a basis of the +small subspace in a minimum T-basis, by threshold dimensions. Hence its +label span lies in W0 and it is uncorrected. All weight-one/two members +are also uncorrected. In the table only a weight-eight inside member can +be corrected, so + + n_T <= eta. (4) + +Let n8 count corrected weight-eight outside members. We prove n8<=6. +Otherwise all seven outside members have weight eight and are corrected. +Their independent duals are precisely the seven frame directions f_i, +i!=0. The actual expansion evaluated at f_i then gives + + q_i = lambda_i C_(f_i) + tau_i, tau_i in T, + lambda_i != 0. (5) + +Use the eight-dimensional polar model B on root residues from PROOF.md. +For i!=0 the full32-root section + + A_i = {q=1 : B(f_i,x)=1, B(f_0,x)=0} + +contains no frame root and has leading-one label rank seven. Off its at +most two sites in E, (3)--(5) put every A_i coordinate into supp(q_i). +These at least30 sites still span the same seven-flat: a rank-six flat +has at most20 roots. Since q_i carries z_i, its rank-eight span is the +unique hyperplane obtained by adjoining z_i to that seven-flat, namely + + { (a,x) : B(f_0,x)=0 }. + +Indeed A_i's span has equations B(f_i,x)=a, B(f_0,x)=0, +whereas z_i violates the first and satisfies the second. This hyperplane +contains no live site of N0, whose residues have B(f_0,x)=1. Therefore +q_i vanishes on N0 and (5) yields + + tau_i|N0 = -lambda_i C_(f_i)|N0 for all seven i!=0. + +These seven restricted frame codewords are independent: N0 spans K^8. +For an explicit reason, all sign patterns of every four-axis incidence +block containing index 0 occur among its neighbors; their span contains +the four corresponding axes. Such blocks cover all eight axes (G5's +S(3,4,8) incidence), so their union spans K^8 over characteristic zero. +Thus dim(T|N0)>=7, contradicting dim T<=4. This proves n8<=6. + +Finally let c9_corr count corrected outside weight-nine members. Separating +actual low, corrected weight-eight and corrected weight-nine terms in +the exact ledger gives + + I = 64+s+eta-n_T-n8+(c9-c9_corr) + >= 64+s-6 >=65, (6) + +using (4) and c9_corr<=c9. This exhausts the frame case, both offsets of +the possible actual surplus, and every weight-nine status. It contradicts +I<=64 and completes the cost-at-most16 part of the budgeted lemma. + +## 6. The t3 cost-seventeen boundary + +Suppose cost_w(T)=17 at t=3. Here s=9. The raw weight budget sum_Fw<=73, +I<=64 and equation(1) force + + r=eta=c9=0, Delta=9, n_c>=9. (7) + +Thus the ACTUAL inside basis is a minimum T-basis and all seven outside +members have weight eight. This adaptation follows from equality. + +The profile exhaustion of Section 2 extends as follows. With largest +weight at most six, the maximum capacity sum at total17 is +`20+20+8+1=49<53`. With largest seven, the new profiles with capacity +sum at least53 are [7,4,4,2], [7,5,3,2], [7,5,4,1], [7,6,2,2], +[7,6,3,1], [7,7,2,1]. The first two have crude support at most54; +root/frame target32 reduces their capacities to50, excluding them. The +supplement excludes [7,6,2,2], whose small supports total at most four. +Only three profiles remain. + +**[7,5,4,1].** At most three inside members are corrected, so n_c>=9 +requires at least six independent corrected high frame axes perpendicular +to h. Thus h uses at most two frame axes. Its crude capacity57 and the +restricted-axis count force a frame direction. But its frame target +cannot fit: `32+12+8+1=53<56`, a contradiction. + +**[7,6,3,1].** Again at most three inside members are corrected, so at +least six corrected high frame axes annihilate h. Its crude capacity61 +and the restricted-axis count force a frame normal f_0. Both the +seven-flat and six-flat lie inside W0. Otherwise the former +would give `20+20+4+1=45<56`, or the latter would give +`32+12+4+1=49<56`. The two large inside members are therefore uncorrected; +only the rank-three member can be corrected. Thus n_c<=7+1=8<9. The +five-site T-space witness remains valid while failing the actual budget. + +**[7,7,2,1].** The small members cannot be corrected. Equation(7) would +require both inside sevens and all seven outside members corrected. +The independent high duals are seven frame axes perpendicular to h, +so h is their remaining frame axis f_0. Both inside seven-flats must +lie in W0, since otherwise `20+32+2+1=55<56`. They are then uncorrected, +a contradiction. No direction classification through75 sites is used. + +This excludes all cost17 cases under I<=64. Together with Sections 1--5 +it proves the common budgeted lemma. + +## 7. The unmarked floors + +First, for any actual basis in this setting with m<16, without (M), + + n_c <= m-1. (8) + +If all members were corrected, their restricted duals would lie in the +eight frame directions. These duals span the full eight-dimensional normal +space: a normal annihilated by every x_j would have C_h=0 by the actual +expansion, hence h=0. Thus all eight frame groups are nonempty. Evaluating +the expansion at a frame f_i uses only its own group. A singleton group +would force its sole q_j to be a nonzero scalar multiple of C_(f_i), +whose label span excludes z_i; it would be uncorrected. Therefore every +group has at least two members, requiring m>=16, a contradiction. This +proves (8), without normalization or any bound on repeated low indices. + +For the marked theorem, suppose I<=64. The raw marked cap n_c<=m-2 gives +sum_Fw<=64+8=72 for t=2 and <=64+9=73 for t=3. The common budgeted lemma +then gives I>=65, a contradiction. This proves the claimed marked bound. + +For the unmarked theorem, suppose I<=63. Bound (8) gives sum_Fw<=63+9=72 +for t=2 and <=63+10=73 for t=3. The SAME common budgeted lemma contradicts +I<=63, proving I>=64 without a root mark. In the unmarked [7,1] case one +can also avoid G4: I<=63 requires n_c>=9, hence a corrected seven-low and +all eight corrected frame-axis highs; away from that low's frame index +the coefficient map only uses the unit, contradicting the matched24 cut. +The common proof retains G4 because the marked boundary can have only +seven corrected highs. + +## 8. Complete actual singleton-pivot d1 consumer + +This is the consumer of PR3455 CONSUMER.md with its actual hypotheses, +and with d=1 replacing d=0. Let + + N0(s,t) = (r_s,r_t)/2 = sum_j p_j(s)q_j(t), + +be an exact factorization with 9+t terms and actual ranks +(rank P,rank Q)=(9,8+t), for t in {2,3}, +all p_j nonzero and pairwise nonparallel, and a singleton pivot +p_pi=lambda delta_v, lambda!=0, at a live root v. Rescale the pivot pair +to p_pi=delta_v. Let S span all q_j and assume + + dim(C intersect S_(<=7)) = 1. + +Then the actual binary decoder cost is at least64. As in the earlier +consumer, cost is the sum of the ranks of beta restricted to the actual +row-label and column-label support spans. No global reduction to this +rank/pivot class is asserted. + +Here is the actual data recovery, which does not use d=0. The column +space of N0 is C. Its distance excludes delta_v from C, so the actual +rank-nine condition implies span{p_j}=C direct-sum K delta_v. Therefore +every nonpivot row has a unique representation + + p_j = (1/2)C_(a_j) + omega_j delta_v. + +Nonparallelism with the pivot forces a_j!=0. Project exactness onto C and +onto its singleton complement. These two projections give + + C_h = sum_(j!=pi) (a_j,h)q_j, + q_pi = -sum_(j!=pi) omega_j q_j. (9) + +Thus the 8+t nonpivot columns span S and, because rank Q=8+t, form its +ACTUAL basis. Their restricted duals are x_j=a_j, all nonzero, precisely +as required by the invoice theorems. The projected one-sided cost is +I=sum_(j!=pi)w(q_j)-n_c, by the dense pairing's elementary rank-loss +formula for the frame-row hyperplanes. + +The row-edit geometry in PR3455 CONSUMER.md Section 3 is independent of +d=0: changing a codeword only at v can reduce its binary term cost only +when its normal is proportional to v and its own v entry is lost. +Deleting one site from a frame word preserves its rank-eight span; a +different root retains its root coloop and rank-eight nonself remainder; +the one-site root-only lemma excludes any other normal whose span drops. +All such losing actual rows are proportional, so there is at most one +by the actual nonparallel hypothesis. If present, call it k. Its projected +span is full nine and its actual span is W_v; its unique possible rebate +is epsilon=[ell_v in U(q_k)]. If c_pi is the pivot's cost, either zero or +one, the exact support comparison therefore gives + + cost(D) >= I-epsilon+c_pi, (10) + +with epsilon=0 if there is no losing row. These cited row-edit inputs, +including the one-site root-only lemma and no-coloop bounds, are the same +geometric inputs as the earlier consumer; they are not an assumption +that the positive-d space has an adapted basis. + +If no losing row exists, the unmarked I>=64 proves cost(D)>=64. If a +losing row k exists, a_k=gamma r_v, gamma!=0, supplies (M), so the marked +I>=65 proves the same conclusion even after its unit rebate, regardless +of whether the pivot is paid. This covers every actual row-edit case. + +For precision, in the free-pivot/losing-row case the earlier source's +additional witness is also recovered, without d=0. Loss of the v entry +forces omega_k=-gamma, because C_v(v)=2. Equation(9) then gives +phi_k(q_pi)=gamma!=0. Pivot cost zero means q_pi vanishes wherever +beta(ell_v,ell_s)=1, namely O_v={v} union {s:(r_s,r_v)=0}. Thus g=q_pi is +the actual source witness. The present stronger invoice does not require +it. If q_pi=0, equation(9) and the nonpivot basis force all omega_j=0, so +no losing row exists. This harmless edge case is covered as well. + +## Consequences and remaining boundary + +The tight actual marked t2/t3,d=1 branches are closed at I-epsilon>=64, for the +precise basis and root-mark hypotheses above; it is not a closure of all +positive d or of every physical decoder. The separate unmarked floor +and Section 8 settle both row-edit branches of the stated tight t2/t3,d1 +actual singleton-pivot consumer. The rank, nonparallel, singleton and +d=1 hypotheses remain explicit; no global branch normalization is claimed. + +The t3 cost17/slack-nine T-space remains feasible, but it cannot supply the +corrections needed for an actual invoice below these floors. Positive +d>=2 is outside this d=1 proof; [D2.md](D2.md) supplies the complete +actual d=2 extension. Actual d>=3, branch normalization and all other +physical rank/pivot classes remain outside the package result. No normalization or global C1 conclusion is +inferred from the nine literal-list exclusions or the d=1 invoice theorem. diff --git a/research/p112-six-seven-supplement/D2-PROFILE.md b/research/p112-six-seven-supplement/D2-PROFILE.md new file mode 100644 index 0000000000..2e5dcaa19b --- /dev/null +++ b/research/p112-six-seven-supplement/D2-PROFILE.md @@ -0,0 +1,159 @@ +# The intrinsic (7,7,5,5) profile has code intersection at most one + +Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0. +Use the roots, frame, code C and leading-one binary labels of +[PROOF.md](PROOF.md), over any characteristic-zero field K. This proof uses +its root-direction rigidity, rank-five capacity12, rank-seven root-target +capacity32 and root32-completion theorem. The quarter model and frame +punctures are those of [UNIFORM.md](UNIFORM.md), Sections 1--2. + +**Theorem.** If independent pieces A,B,L,M have binary support ranks at +most 7,7,5,5, respectively, then + + dim_K(C intersect span_K{A,B,L,M}) <= 1. + +This is an intrinsic piece-span statement. It does not assert a complete +actual d=2 invoice, actual-basis adaptation, or global C1 normalization. + +## 1. A nonframe root has no (7,5,5) cover + +Suppose a nonframe root word C_v is supported in one rank-seven and two +rank-five label flats. Its support has53 live sites. The seven-flat must +carry at least `53-12-12=29` of them. PROOF.md Section 4 therefore forces +it to be a full32-root completion X. Its complementary quarter C24 has +the model + + C24 = Omega x R, |Omega|=6, dim R=2, + +from UNIFORM.md Section 1. Omega contains no affine two-plane and every +affine hyperplane contains at most four of its points. The seven-flat +misses C24 and the self label v. One of the five-flats must carry v. +Since v is outside the quarter's label seven-flat, that five-flat meets +it in rank at most four, hence in at most eight roots. The other +five-flat has capacity twelve. + +At most four roots of C24 are removed frame roots. Covering its live part +requires at least20 sites, while the two low parts can cover at most +`8+12=20`. Equality is necessary: all four punctures lie in C24, the low +parts cover disjoint sets of eight and twelve live quarter roots, and +each attains its full section capacity. + +Here is the full-fiber consequence of equality. A rank-four label section +has affine dimension at most three. If its projection to the quotient +has dimension two, it contains at most three Omega points and its +radical fibers have size at most two, giving at most six roots. Projection +dimension three gives at most four roots. To contain eight roots it must +therefore be the lift of two Omega points, with both four-point radical +fibers present in full. + +Similarly, a rank-five label section has affine dimension at most four. +Projection dimension three gives at most `4*2=8` roots; dimension four +gives at most six. Projection dimension at most one gives at most eight. +Thus a twelve-root section must project onto three Omega points in an +affine two-plane and contain their three radical fibers in full. + +The four frame punctures form an affine plane. As in UNIFORM.md Section 2, +its direction is totally singular, whereas R contains the anisotropic +normal v. The intersection of those directions has dimension at most one. +The puncture plane cannot project to an affine plane in Omega, so it +projects onto exactly two Omega points, with two punctures in each fiber. +Only four of the six radical fibers are unpunctured. The disjoint live +eight- and twelve-root sections would require respectively two and three +full unpunctured fibers: five distinct fibers where only four exist. +This contradiction proves the lemma. + +## 2. Coordinate kernels force two frame words + +Suppose the theorem fails and choose a two-dimensional subspace D of the +code intersection. Restrict the A and B coordinate functionals to D. +Their joint kernel is zero: a nonzero word in it would be supported on +L and M, hence on at most24 sites, below code distance53. Consequently +both restrictions are nonzero and their one-dimensional kernels are +distinct. + +Killing either seven-piece leaves a codeword supported on at most +`36+12+12=60<70` sites. Root-direction rigidity makes its normal an E8 +root direction; Section 1 excludes a nonframe root. Thus the two kernel +words are scalar multiples of frame words C_a,C_b for distinct frame +axes a,b. Relabel A,B so + + C_a = alpha A + lambda L + mu M, + C_b = beta B + lambda' L + mu' M. + +Each displayed coefficient is nonzero: omitting any term leaves capacity +at most44, below the frame word's support size56. + +## 3. Equality forces the low pieces to be sign halves + +Write N(a)=supp(C_a), so |N(a)|=56. The root-target and low-rank capacities +give + + 56 <= |N(a) intersect supp A| + + |N(a) intersect supp L| + |N(a) intersect supp M| + <= 32+12+12 = 56. + +All inequalities are equalities. In particular L,M each have exactly12 +support sites, wholly inside N(a), disjoint from each other and from +A's support in N(a). Repeating the argument with C_b puts both low +supports inside N(b), disjoint from B's target support. Since +`|N(a) intersect N(b)|=24`, their union is precisely this common quarter. + +At every site in supp L the two expansions reduce to + + C_a(s)=lambda L(s), C_b(s)=lambda' L(s). + +The ratio C_b/C_a is therefore constant there, and likewise on supp M. +On the common quarter both frame pairings are +/-1, and their ratio +classes +1 and -1 each have12 sites. Thus the two low supports are exactly +the same-sign and opposite-sign halves, in either order. Disjointness +and absence of outside low support were forced by equality, not assumed. + +## 4. Each sign half has label rank at least six + +The common quarter is the model Omega x R of UNIFORM.md Section 1 with +`R=span_F2{a,b}`. Omega affinely spans the four-dimensional quotient, +since an affine hyperplane could contain at most four of its six points. + +The orthogonal reflections s_a,s_b commute. For a common neighbor r, +reflection in a negates (r,a) and preserves (r,b); reflection in b does +the reverse. Each flips their product. This product is unchanged by +r -> -r, so canonical choices of projective root representatives do +not affect the argument. On binary residues the reflections are + + x -> x+a, x -> x+b, + +because `s_a(r)=r-(r,a)a` and the coefficient +/-1 becomes one modulo two. +They act regularly on each four-point radical fiber. Each product-sign +half therefore contains two points in every fiber, whose difference is +the nonzero radical vector a+b. + +Each half projects onto all six Omega points and its affine direction +span has a nonzero kernel under that projection. Its affine span has +dimension at least `4+1=5`, so its leading-one label rank is at least six. +This contradicts the rank-at-most-five bounds on L and M and proves the +theorem. No finite exact-rank-seven premise is required. + +## 5. Literal source callers and scope + +The dimension-deletion lemma of [CALLERS.md](CALLERS.md) extends the +theorem: if a piece span meets C in dimension at least d>=2, killing any +d-2 chosen piece coordinates leaves an intersection of dimension at least +two. It cannot leave four pieces of ranks at most 7,7,5,5. + +In DreamingOfClouds's pinned PR3154 output +`research/p112-reduction-to-conjectures/checks/CONJG2/land_e2_k8.out`, +head `708f0ad8928c383de8294aea3c126e9461d2066d`, this excludes the literal +t2,d2,slack8 profile `[7,7,5,5]` and t2,d3,slack7 profile +`[7,7,7,5,5]`; delete one seven-piece in the latter. These are literal +profile implications, not a current open-case count or a claim of global +source-list completeness. This intrinsic theorem alone does not give an actual invoice; +[D2.md](D2.md) separately proves the complete actual d=2 invoice. +Actual d>=3 invoices remain open. + +Credit DreamingOfClouds's PR2816 circuit/coordinate-kernel lineage and +Nick Petalas's PR3171 root-pencil lineage, with the exact pins recorded in +CALLERS.md. The analytic capacities, quadratic model and predecessor +attributions are retained in PROOF.md and UNIFORM.md, including Nick +Petalas and David Arias. This composition is by conorholds with substantial +OpenAI Codex assistance. It is written mathematics with scoped geometric +inputs, not a Lean proof of the complete theorem. diff --git a/research/p112-six-seven-supplement/D2.md b/research/p112-six-seven-supplement/D2.md new file mode 100644 index 0000000000..e7c76aca1f --- /dev/null +++ b/research/p112-six-seven-supplement/D2.md @@ -0,0 +1,539 @@ +# Complete actual d=2 invoices, t=2 and t=3 + +Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0. +The exact actual-basis setting, geometric inputs, field transfer and credits +are those of [D1.md](D1.md), with **d=2** in place of d=1. In particular: S +contains the eight-dimensional P112 evaluation code C; dim S=8+t; F is an +actual basis of S; its restricted dual vectors x_j are all nonzero; T is the +span of **all** S-words of binary support rank at most seven; d=dim(C +intersect T)=2; and I=sum_F w-n_c uses the actual correction rule. + +## Theorem and scope + +For t=2 or t=3, if an actual restricted dual is a nonzero multiple of a +live root, **I>=65**, hence I-epsilon_k>=64 for epsilon_k in {0,1}. +The additional marked witness g is unnecessary for this invoice theorem. +Without a root mark, **I>=64**. Under the exact actual-rank and nonparallel +hypotheses in D1 Section 8, the singleton-pivot consumer therefore has +**cost at least 64** also when its nonpivot low space has d=2. + +No N8, minimum actual basis, actual adaptation to T, distinct corrected low +frame indices, or completeness of historical normalized lists is assumed. The +result is the complete stated d=2 invoice, not complete C1 or a global decoder +normalization theorem. No sharpness at64 is claimed. + +The internal budgeted lemma is stronger: for d=2, the assumptions sum_F w<=72 +(t2), or <=73 (t3), already imply I>=65, with no root mark. The proof below +derives T's dimension directly and exhausts its minimum profiles using +elementary inequalities and the intrinsic exclusions. + +## Exact ledger and raw dimension boundary + +For m=8+t, let a=dim T=d+e, x=t-e, f=|F intersect T|, r=a-f, s=cost(T)-8d, +eta=sum_(F intersect T)w+8r-cost(T), and let c9 count outside members of +weight nine. Completing the independent actual inside family by r words of +weight at most seven gives eta>=r. Exactly + + sum_F w - 64 = s+8x+eta+c9. + +For a marked actual basis with I<=64, RAW-COUNT gives the right side at most +t+6. This does not use N8, adaptation, or minimum actual bases. + +For d=2 one can prove x=0 directly, without the source's full T-level +classification. Every low-piece representation of a nonzero codeword has total +weight at least 14, by D1 Section 1's support/capacity argument. If t=2 and +a<=3, peeling and sum_Fw<=72 give cost(T)<=8a-8<=16. Kill the coefficient of +the heaviest member of a minimum T-basis. The remaining nonzero codeword has +total piece weight at most floor((a-1)cost(T)/a)<=10, contradiction. If t=3 +and a<=4, the analogous budget is cost(T)<=8a-15<=17; the remaining cost is at +most 12, again a contradiction. Thus dim T=t+2 for BOTH t=2,3. + +The intrinsic 7755 and 7764 exclusions in D2-PROFILE.md and RIGIDITY.md, +together with the following exhaustion, reduce t2 to profiles 7771,7772,7773. +All actual surplus and nonadapted cases are treated below. + +## Independent minimum-profile exhaustion at t2,d2 + +Now a=4 and cost(T)<=24. If all four weights are at most six, the retained +four-six lemma (empty exceptional set) excludes D dimension 2. If exactly one +is seven, kill its coordinate in D; the remaining three weights are at most +six and total at most 17. Their maximum capacity is g(6)+g(6)+g(5)=52, below +code distance53. + +Thus at least two weights are seven. Write the profile 77ab with a>=b and +a+b<=10. Kill one seven-coordinate and consider the nonzero word covered +by7ab. + +* If a<=4, its support capacity is at most 36+8+8=52. +* If a=5,b<=4, only b=4 can reach53 sites. Its crude capacity 56<70 + forces a root/frame target, but target capacity 32+12+8=52 excludes it. + The remaining a=b=5 profile 7755 is intrinsically excluded by D2-PROFILE. +* If a=6,b<=3, the supplement excludes the cover76 plus at most four + small sites. The remaining b=4 profile 7764 is the intrinsic exclusion in RIGIDITY.md. +* If a=7, then b<=3, leaving exactly7771,7772,7773. + +No source DP, LP, normalized correction count, or historical survivor list +completeness is needed for this exhaustion. + +## Restricted four-axis rigidity + +A nonroot/frame normal supported on at most four frame axes has at least 76 +live nonzeros. The one-, two- and three-axis cases are already in D1: one is a +frame axis; two nonzero axes give76 or88; three give>=80. + +For four nonzero coefficients, the four selected axes either form an incidence +block or do not. G5's S(3,4,8) incidence gives the following restricted forms +and multiplicities. + +* Block: six signed pairs a_i +/- a_j, each form with multiplicity8; + eight projective four-sign forms, each with multiplicity1; eight zero + sites. If all four coefficients agree up to signs, this is a root + direction. Otherwise at most three pairs agree up to sign, so the + pair forms alone contribute >=8(12-3)=72. Pairing four-sign forms by + changing the sign of one nonzero coefficient shows that at least four + survive, hence >=76 in total. +* Nonblock: each singleton has multiplicity8; each signed pair has + multiplicity4; each projective signed triple has multiplicity2. The + singletons contribute32, pairs contribute>=24, and each of four + triples has at most one vanishing sign form, contributing>=6. Thus + the total is>=80. + +All statements use equality up to sign over characteristic zero, with no +ordering or absolute-value operation on the field. Consequently a normal with +<=4 active axes and <=75 live nonzeros is a root/frame. + +## Three seven-coordinate kernels and A2 planes + +In a minimum profile 777c (c<=3), put D=C intersect T, dim D=2. Restrict the +three seven-piece coordinate functionals to D. Any pair has zero joint kernel: +otherwise a codeword is supported on one seven-piece and the small piece, at +most 40 sites. Thus their three kernel lines are nonzero and distinct. Their +codewords are supported on two seven-pieces and the small support. + +Three distinct root lines in a normal plane form A2. An A2 plane has active +frame support either four (if it contains a frame root) or six. Indeed +nonframe roots use four-axis blocks. Distinct blocks of a nonorthogonal root +pair overlap in two axes, whose pairings must align, and their third root uses +the symmetric difference; the union has six axes. In the same block a +nonorthogonal pair gives a frame root. An A2 plane with <=5 active frame axes +therefore contains a frame root f0 and has support one four-axis block. + +Write such a plane as span(f0,v), with v a nonframe root in that block. Its +f0-coordinate kernel is v-(v,f0)f0/2, a nonroot with three active axes. The +other three active frame-coordinate kernels are all the same line K f0. +Therefore among a family with distinct ROOT coordinate-kernel lines, at most +one can be corrected with a frame row. + +## Minimum profile 7771: all actual surplus cases + +Here s=6, so eta+c9<=2. Threshold dimensions force these cases: + +* r=0: actual inside profile 7771 at eta0, 8771 at eta1, and either + 9771 or8871 at eta2. Outside count six. +* r=1: actual inside 771 at eta1 or871 at eta2. Outside count seven. +* r=2: actual inside71 at eta2. Outside count eight. + +The low threshold space through weight six is exactly the unit line; this +excludes spurious replacements of the unit by weight two, etc. + +Adapted eta0: let nT count corrected inside members and J corrected outside +axes. Outside restricted duals are independent and span Ann(D). At least six +members are corrected; nT<=3, hence |J|>=3 and D has <=5 active axes. If nT=3, +each seven-coordinate kernel also kills its own corrected axis, so it has <=4 +active axes and <=73 sites and is a root. The A2 paragraph contradicts three +distinct corrected kernels. Thus nT<=2 and |J|>=4. Now all three seven-kernels +are roots, since D itself has <=4 active axes. Again D is the four-axis A2 +plane; at most one inside seven can be corrected, while J has at most four +axes. Hence n_c<=5<6, a contradiction. Weight-nine outside members only +increase the required correction count and do not invalidate independence. + +Adapted eta1: n_c>=7, nT<=3 gives |J|>=4, so the minimum-basis kernels again +force a four-axis A2 plane. There can be at most four corrected outside axes, +hence all three actual large inside members must be corrected. Kill the actual +weight-eight member's coordinate. The resulting codeword uses the other two +sevens and the unit, has <=73 sites and is a root. As a corrected +frame-coordinate kernel in the A2 plane, it must be f0. Covering N(f0) by the +two seven-flats and a unit forces BOTH seven-flats inside W0: +otherwise20+32+1<56. W0 has no frame label, so those two actual sevens are +uncorrected, contradiction. + +Adapted eta2: n_c>=8, nT<=3 forces |J|>=5 and D has <=3 active axes. All three +minimum-basis kernel words are therefore frame axes. A two-dimensional space +cannot contain three distinct orthogonal frame lines, contradiction. + +Nonadapted r2,eta2 gives actualinside71, all eight outside weight8, n_c>=8. +Its span L is disjoint from C, so S=C direct-sum L. The retained actual71 +G4/cancellation-incidence argument (D1 Section 3) applies verbatim and +excludes it. It only needs this actual profile and direct sum. + +Nonadapted r1,eta1 gives actualinside771; put L=their span. Its code +intersection is exactly one-dimensional: dimension forces at least one, while +killing a seven in a putative two-dimensional intersection leaves seven+unit, +below code distance. Thus S=C+L. D1 Sections4--5 apply to this explicit actual +minimum771 profile (including c9<=1); their frame case proves I>=65. The proof +uses this displayed inside profile and outside weights>=8, not equality L=T +for the global threshold space. + +Nonadapted r1,eta2 gives actualinside Q8,B7,u1, all seven outside weight8, +n_c>=8. Let C_h span C intersect L; this intersection is again exactly +one-dimensional. Corrected outside axes are independent in Ann(h). + +If both Q and B are corrected, at least six outside axes are corrected, so h +has <=2 active axes. If h is nonaxis, retained G4 applied to C_h=alpha Q+beta +B+gamma u and the hyperplane U(Q) is a contradiction: the cut after deleting u +has rank 8 but lies in supp B of rank 7. If h is a frame axis, Q's coefficient +is nonzero (B+unit cannot support a codeword). If B has another matched axis +its coefficient is zero, and Q is a corrected frame word plus a unit, +impossible by G2. If both inside rows have the same matched axis h, then U(Q) +meets N(h) in at most 32 sites by G2, while U(B), containing z_h and having +rank 7, meets W_h in rank at most 6 and hence meets N(h) in at most 20. Thus +their union with the unit covers at most 32+20+1=53<56 target sites. Thus +nT<=1. + +Therefore all seven outside members are corrected, h=f0 is a frame direction, +and exactly one of Q,B is corrected. If Q is corrected it must have index0 +(otherwise C_f0 is supported in B+u). For every other axis the actual +coefficient expansion uses only B+u. Seven matched frame highs then +require7*24 cancellations from <=37 sites, contradicting 7*24>4*37. + +If B is corrected at index i!=0, the f0 expansion omits B and gives Q=alpha +C_f0+beta u. Every outside frame axis j different from0,i has +q_j=C_(f_j+gamma_j f0)+delta_j u. A nonaxis normal has >=76 sites, +contradicting its cover by rank 8 q_j plus one site (<=65); the remaining +frame-axis normal contradicts G2's24 cancellation bound. If B is corrected +at0, solve the f0 expansion for Q in span(C_f0,B,u). Each outside q_j then has +form C_(f_j+gamma_j f0)+rho_j B+delta_j u, where the substitution gives +rho_j=-b*gamma_j if C_f0=a Q+b B+c u. Nonaxis normals contradict G4, while +gamma_j=0 forces rho_j=0 by the same substitution and leaves a frame word plus +a unit, contradicting G2. This exhausts the profile 7771 actual boundary. + +## Minimum profile 7772: all actual surplus cases + +Now s=7, eta+c9<=1. Adapted eta0 has actual7772; n_c>=7 and nT<=3 force >=4 +corrected high axes. The three seven-kernels have <=74 sites and <=4 active +axes, hence are roots. The A2 paragraph bounds nT<=1 and corrected highs<=4, a +contradiction. Adapted eta1 has actual8772; n_c>=8 and nT<=3 force >=5 +corrected high axes. The minimum-basis kernels are three distinct frame axes +in D2, impossible. + +The only nonadapted case is r=eta=1, actualinside772, all seven outside +weight8, n_c>=8. Its span L has one-dimensional code intersection, and at +least six corrected high axes confine its normal h to at most two axes. The +cover two7+rank 2 has <=74 sites, so h is frame. Both sevens must lie in W0 +by20+32+2<56. Hence all three inside members are uncorrected and n_c<=7<8. + +## Minimum profile 7773: no surplus + +Here s=8 forces r=eta=c9=0; all six outside members have weight8 and n_c>=8. +If the rank-three small member is corrected it has exactly three support +sites, so each seven-kernel has <=75 sites. There are at least four corrected +high axes, hence <=4 active D axes. The three kernels are roots and D is the +four-axis A2 plane. At most one seven is corrected; including the small member +gives nT<=2 and n_c<=6<8. + +If the small member is uncorrected, nT<=3 and |J|>=5. Let k be the number of +active D axes; k<=3 and k>=2. If k=3, corrections require exactly all three +sevens corrected and five outside axes corrected. Their three distinct +coordinate kernels must kill the three distinct active axes. No kernel is a +frame axis: otherwise two active coordinate functionals have the same kernel. +Thus each is a two-axis normal with <=76 sites and consequently an +equal-up-to-sign pair with exactly76 sites. All three relations force D to be +a signed sum-zero plane in the three axes. Each kernel representation has +capacity 36+36+4=76, so all three seven-supports have36 sites, the small +support has4, and all four supports are pairwise disjoint. Their union is all +112 sites. The small coordinate restriction on D is nonzero: omitting it from +any kernel word would leave at most 72 sites, below its76. The three seven +coordinate restrictions are nonzero by their pairwise zero-joint-kernel +property already proved above. But the incidence block disjoint from the three +active axes supplies eight live roots annihilating D. At each such root, only +one piece can be nonzero and its coordinate restriction on D is nonzero, +impossible. + +If k=2, exactly two sevens B,C and six outside axes must be corrected; +let A be the other seven. The two corrected coordinate kernels are the +two frame words. Their covers are A+B+small and A+C+small. A corrected +index is active, since its coordinate restriction is nonzero; the two +indices are distinct, since the two coordinate-kernel lines are distinct. +Thus the two targets really are different frame words. A corrected +seven B carrying its matched z1 has label flat outside W1 and therefore +meets N1 in at most 20 sites. Thus the frame cover forces +|supp A intersect N1|=32 from56<=32+20+4=56. Likewise A contains32 +sites of N2. Since |N1 intersect N2|=24, this forces |supp A|>=40>36. +This excludes the last case. + + +## The t=3 cases + +Assume dim S=11, d=2, sum_F w<=73, I<=64. The raw dimension argument gives dim +T=5. Put s=cost(T)-16. For adapted F, there are six outside members, their +restricted duals are independent in Ann(D), D=C intersect T, and corrected +outside frame axes J give at most 8-|J| active D axes. For nonadapted actual +inside span L of dimension four, the examples below have C intersect L +one-dimensional, so seven independent outside duals are in Ann(h). All outside +correction counts include corrected weight9 members. The root mark is not used +inside the budgeted argument. + +The three seven-coordinate restrictions in a profile with three sevens have +pairwise distinct nonzero kernels: killing two sevens leaves one seven and the +small supports, below code distance. With two sevens, their two coordinate +restrictions likewise have distinct nonzero kernels. + +## Profile 77711, s7 + +The small threshold space is the span of two unit vectors, so every vector in +it has rank<=2 and is uncorrected. The budget is eta+c9<=2. + +Adapted eta0: nT<=3, n_c>=7 imply |J|>=4, so D has <=4 active axes. The three +seven-kernel words have <=74 sites, hence are roots by the restricted +four-axis lemma. D is a four-axis A2 plane, and its kernel lemma bounds +corrected sevens by one. Then n_c<=1+4<7. Adapted eta>=1 requires n_c>=8 and +|J|>=5, so D has <=3 active axes. The same three kernel words must now be +three distinct frame axes in a plane, impossible. This also covers actual +large weights8/9 and changes of basis in the two-unit space; the small members +remain rank<=2. + +For r=2, eta=2, actual inside profile is711, all eight outside members have +weight8, and n_c>=9. Its span is disjoint from C and S=C direct-sum L. All +eight highs and the seven-low must be corrected. For any frame axis different +from the seven-low's matched axis, the actual expansion uses only the two unit +lows, contradicting G2's24-cancellation requirement. + +For r=1,eta=1, actual inside profile is7711 and n_c>=8 (possibly c9=1). Its +code intersection is one-dimensional: killing a seven in a putative +two-dimensional intersection leaves seven+two units, at most 38 sites. At most +two lows are corrected, hence at least six outside axes are corrected. Thus h +has <=2 active axes. The inside cover gives <=74 sites, forcing h frame. Both +sevens must lie in W_h, since20+32+2<56; they and the units are uncorrected, +contradicting n_c>=8 with seven outside members. + +For r=1,eta=2, actual inside profile is8711 or7721, all outside weights8, and +n_c>=9. Both large inside members and all seven outside members must be +corrected. The seven independent high axes force h frame. For 8711, Q8 has +nonzero coefficient in C_h; if B7's coefficient vanished, Q would be a +corrected frame word plus two units, impossible by G2. Thus both large rows +are matched to h, but their target capacities are 32+20+2=54<56. For 7721, +both seven coefficients are nonzero, hence both corrected sevens match h and +cover at most 20+20+3<56 sites. Contradiction. + +The actual profiles above are exhaustive by threshold dimensions and eta>=r: +at r1,eta1 complete by one seven to a minimum basis; at r1,eta2 the only extra +cost unit raises a seven to eight or a two-unit basis from11 to21; at r2,eta2 +the inside cost is9 and forces711. + +## Profile 77721, s8 + +Now eta+c9<=1. Adapted eta0: all three possible corrected inside members are +the sevens, so n_c>=8 forces |J|>=5. The three seven-kernel words have <=75 +sites and <=3 active axes, hence are three distinct frame axes in D2, +impossible. + +Adapted eta1 has actual profile 87721,77731 or77722. The last two are handled +by the next section's actual-profile arguments, which do not need that +displayed profile to be the minimum profile. For 87721, n_c>=9 forces all +three large inside members and all six outside members corrected, so D has <=2 +active axes. Kill the actual weight-eight coordinate. The remaining codeword +has <=75 sites and <=2 axes, so it is frame. Both seven coefficients are +nonzero (one7+three small sites is below distance), and hence both corrected +sevens match that frame. Their cover has capacity 20+20+3<56, contradiction. + +The only nonadapted case is r=eta=1, actual inside7721, all outside weight8, +n_c>=9. Both sevens and all seven highs must be corrected; the high axes force +h frame. Both sevens lie in W_h by20+32+3<56 and are uncorrected, +contradiction. + +## Actual profiles 77722 and77731 at total25 + +These arguments require an adapted actual inside basis with displayed weights, +six outside members of weight8 and n_c>=9; minimum-basis adaptation is not an +additional premise. + +For 77722 the small members are uncorrected. Thus all three sevens and all six +outside members are corrected. D has <=2 active frame axes, but its three +seven-coordinate kernels are distinct, so their three corrected frame indices +cannot all be among the two active axes. + +For 77731, if the rank-three member is uncorrected, the same argument applies. +If it is corrected, it has exactly three support sites, and there are at least +five corrected high axes, so D has k<=3 active axes. + +If k=3, n_c>=9 forces all three sevens, the rank-three small member, and +exactly five highs corrected. The three seven-kernels kill the three distinct +active axes. They cannot be frame directions, since otherwise two of the +active coordinate functionals have the same kernel. Each is a two-axis normal +supported on at most 36+36+3+1=76 sites, hence an equal-up-to-sign pair with +exactly76 sites. D is a signed sum-zero plane. Equality in each cover forces +all three seven supports to have36 sites, the small supports to have3 and1 +sites, and all five supports pairwise disjoint, totaling 112. All five +coordinate restrictions on D are nonzero: each included coefficient in +a76-site kernel cover must be nonzero, since deleting either small member +lowers its capacity below 76. The incidence block disjoint from the three +active axes has eight roots annihilating D, but no nonzero piece can occur at +such a site in this disjoint partition. Contradiction. + +If k=2, at most two sevens can be corrected, so exactly two sevens, the +rank-three small member and six highs must be corrected. Let A denote the +uncorrected seven, B,C the corrected sevens with distinct active axes a,b. The +rank-three member's matched axis is perpendicular to at least one of f_a,f_b. +The corresponding frame expansion omits that member and one of B,C and is +supported on A, the other corrected seven, and the unit. Its target capacity +is32+20+1=53<56. Contradiction. + +## Two-seven profile 77541, s8 + +Killing either seven yields a nonzero word covered by7541, at most 57 sites. +It is a root/frame, and a frame target cannot fit since 32+12+8+1=53<56. Hence +BOTH seven-kernel words are nonframe roots. + +Adapted eta0: nT<=4 and n_c>=8 give |J|>=4 and <=4 active D axes. +Each seven-kernel root uses all four active axes, so a corrected row +for its killed seven cannot have zero pairing with it. Thus the sevens +are uncorrected; then nT<=2 forces >=6 high axes and <=2 active D axes, +contradicting the nonframe root. Adapted eta>=1 forces n_c>=9 and +|J|>=5 directly, so D has <=3 axes, the same contradiction. The +smallest threshold is the unit line, so with surplus<=1 the actual +inside family still has an actual unit and at most four corrected members. + +The only nonadapted case is r=eta=1, actual inside7541, all seven outside +weight8, n_c>=9. Its code intersection is exactly one-dimensional: omitting +its seven leaves <=21 sites. At least six highs are corrected, so h has <=2 +active axes and must be frame. But its target cover is again32+12+8+1=53<56, +impossible. + +## Actual total25 profiles 77551,77542,77641,77632 + +All have five actual inside members and six outside members of weight8; their +inside sum is25 and n_c>=9. Each has at most four corrected inside members, so +|J|>=5 and D has <=3 active axes. Kill either seven. The remaining support has +fewer than70 sites, hence is a root/frame, and the restricted active-axis +bound forces it to be frame. The two seven-kernel directions are distinct, so +D is the full plane on two frame axes a,b. + +For 77542 the frame cover has target capacity 32+12+8+2=54<56, an immediate +contradiction. For the other three profiles, both intermediate-size pieces +must have nonzero coefficients in BOTH frame-kernel words: + +*77551: omitting either five leaves7+5+unit, at most 49 sites. +*77641: omitting six leaves7+4+unit, at most 45 sites; omitting four + leaves7+6+unit with frame target bound32+20+1=53<56. +*77632: omitting six leaves7+3+rank 2, at most 42 sites; omitting three + leaves7+6+rank 2 with target bound32+20+2=54<56. + +Neither intermediate piece can therefore be corrected: a frame row restricting +to the a,b plane vanishes on at least one of its two frame axes (and a row +outside that plane vanishes on both). The small rank-one/two piece is +uncorrected. Thus nT<=2 and n_c<=2+6=8<9. + +## Profile77631, s8 + +Adapted eta0: nT<=4, n_c>=8 give |J|>=4 and <=4 active D axes. Both +seven-kernel words have <=61 sites, so are root/frame. If either were a +nonframe root, its killed seven could not be corrected: the root uses all four +active D axes. This would give nT<=3, |J|>=5, and <=3 active D axes, +impossible for that nonframe root. Thus both kernels are frame words, and D is +a two-frame plane. + +The six-piece coefficient cannot vanish in either kernel frame word: +otherwise7+3+unit gives <=41 sites. The rank-three coefficient also cannot +vanish:7+6+unit has frame target capacity 53<56. Therefore both pieces are +uncorrected, since a corrected frame row vanishes on one of the two frame +axes. Now at most the two sevens can be corrected; to reach n_c>=8 both and +all six highs must be corrected. But each kernel frame word is then supported +on one corrected matched seven, the six-piece, the three-piece, and the unit, +with target bound 20+20+4+1=45<56. Contradiction. + +Adapted eta1 has actual profile 87631,77731 or77641. The latter two actual +profiles were excluded above without assuming minimum weights. For 87631, the +minimum-seven kernels and |J|>=5 force D to be a two-frame plane. Kill the +actual weight-eight coordinate: its kernel word lies in7631, hence is frame +(<=61 sites, <=2 active axes). Its seven-, six- and three-piece coefficients +are all nonzero, by the same omission bounds just used. None can be corrected: +if matched to this frame, the respective target bounds +are20+20+4+1=45,32+12+4+1=49, or 32+20+2+1=55, each below 56. Thus only the +weight-eight member could be corrected, contradicting n_c>=9. + +The only nonadapted case is r=eta=1, actual inside7631, all seven outside +weight8 and n_c>=9. Its code intersection is one-dimensional (killing its +seven leaves <=25 sites), and >=6 corrected high axes force its normal h to +<=2 active axes. Its <=61 sites force h frame. The seven-, six- and +three-piece coefficients are all nonzero by the same omission bounds. The +preceding matched target bounds show none can be corrected, contradicting the +required inside correction count. + +Actual profile lists at eta1 follow from threshold dimensions. Equivalently, +the ordered actual weights dominate ordered greedy minimum weights; with total +surplus one only one threshold can rise. At nonadapted r=eta=1, completing by +one word of weight<=7 must attain the minimum, so the omitted minimum weight +is seven in all the displayed cases. + +## Complete minimum-profile boundary + +With a=5 and cost(T)<=25, the elementary deletion/capacity exhaustion leaves +the ten profiles handled above, plus the one-seven profile 76651, excluded +intrinsically by RIGIDITY.md Section 7. Specifically all weights<=6 are +excluded by four-six-plus-small when the fifth is<=4; if all five are>=5, +cost<=25 forces55555, whose four-piece deletion capacity 48 is below 53. +Exactly one seven leaves four ranks<=6 of total<=18; the only +capacity-reaching shape is6651, giving76651. With at least two sevens, +write77abc with a+b+c<=11. After deleting one seven, support capacity and +root-target bounds leave +exactly77541,77542,77551,77631,77632,77641,77711,77721,77722,77731. The +supplement excludes the smaller76+small profiles with <=4 small sites. No +source slack-eight list completeness is assumed. + + +## Marked, unmarked and actual-consumer conclusions + +Under a root mark, PR3455 RAW-COUNT supplies n_c<=m-2, for every d and +m=8+t<=11. If I<=64, then sum_F w<=72 for t2 or<=73 for t3. The budgeted +contradictions above therefore prove I>=65, including every actual basis +surplus, correction on a weight-nine member, and nonadapted inside family. + +Without a mark, n_c<=m-1: if all actual rows were corrected, all eight frame +groups would be nonempty; any singleton group forces a scalar frame codeword, +which cannot carry its own frame label. Each group would thus have at least +two members, impossible for m<=11<16. Therefore I<=63 again implies the same +sum budgets, proving the unmarked floor I>=64. The raw m-1 bound is not +strengthened; it is sharp in general. + +D1 Section 8's actual singleton-pivot argument is independent of d up to its +final invoice applications. The paid-pivot branch applies the unmarked floor +and its pivot rebate compensation. The free-pivot branch retains the source's +root mark and witness and applies the marked floor. Replacing that final +invoice application by the present theorem proves the same cost 64 consumer at +d=2, with every other rank/nonparallel/exactness hypothesis retained. No +arbitrary physical-factorization reduction is inferred. + +## Finite corroboration and limitations + +The two engines independently enumerate all 203 positive four-weight profiles +of cost<=24 and386 five-weight profiles of cost<=25, reproducing the exact +intrinsic exclusions and the three and ten actual case lists. They also +reconstruct all 70 four-axis form inventories and all 1,120 A2 planes, +including 224 with four active axes and896 with six. The four-six-plus-nine +lemma is proved in CALLERS.md's appendix: its uses here are E=empty for t2, or +the smallest piece (at most eight sites) for t3. The lone all-five +boundary55555 is excluded by distance53. + +Actual factorization controls and their exact finite low-space certificates +are described in README.md and the receipt. The two complete low-space +certificates are independently replayed by a different coordinate and +Gaussian-elimination implementation modulo 5. These are nonempty examples +above the floor, not exhaustive tests of the written invoice proof. Two +read-only skeptical AI reviews found no missing implication in the case +analysis. These are internal checks, not independent human review. + +Only the retained **two-axis** G4 is used. Its tempting three-axis extension +is false: the private probe found a rank-seven cut after one-site deletion. No +proof step above imports that extension. The full invoice assembly and E8 +instantiation are handwritten rather than fully formalized. Actual d>=3 +invoices and global rank/pivot normalization remain open. + +## Threshold dimensions for the remaining invoice search + +[RAW-SHAPE.md](RAW-SHAPE.md) proves a stronger related reduction: +under the raw weight budget and a putative I<=64, every positive d has +full threshold dimension d+t. Raw budget alone suffices through d=6 +for both t2 and t3. This does not force actual adaptation or prove the +d>=3 invoices. The next raw d3 search therefore starts at dimension5 +and cost<=32 for t2, or dimension6 and cost<=33 for t3, with5+r actual +outside members still possible for a basis defect r. diff --git a/research/p112-six-seven-supplement/FORMAL.md b/research/p112-six-seven-supplement/FORMAL.md new file mode 100644 index 0000000000..3a21a95fa7 --- /dev/null +++ b/research/p112-six-seven-supplement/FORMAL.md @@ -0,0 +1,132 @@ +# Formal core + +Prepared by conorholds with substantial OpenAI Codex assistance. The mathematical +lineage and retained predecessor credits are in the package's main proof and +source manifest. + +`formal/QuarterCore.lean` is a partial Lean formalization of the new local +capacity and the final sparse-cover argument. It does **not** formalize the full +P112 theorem or the complete E8-to-binary-model reduction. +`formal/DimensionDeletion.lean` additionally formalizes the abstract +dimension-deletion argument for actual code subspaces and basis coefficients. + +## Statements checked in Lean + +The explicit four-coordinate quadratic form is +`q(x) = x₀x₁ + x₂x₃` over F₂. Binary coordinates are represented by `Bool`; +addition is `Bool.xor` and multiplication is `Bool.and`. + +| Declaration | Kernel-checked content | +| --- | --- | +| `quadric4_card` | The form has exactly six one-points. | +| `quadric_hyperplane_cap` | Every nonzero four-coordinate normal and either affine offset give at most four one-points. | +| `quadric_no_affine_plane` | Four distinct one-points never sum to zero under coordinatewise binary addition; the six one-points contain no affine two-plane. | +| `quadric_pair_avoiding_section` | Every pair of distinct one-points is avoided by a nonconstant affine hyperplane section containing exactly four one-points. | +| `quarter_card` | Repeating those six points over two free radical coordinates gives 24 points. | +| `quarter_radical_cut_card` | A cut nonconstant on the radical has exactly 12 points, for every remaining normal and either offset. | +| `quarter_constant_radical_card` | A radical-constant cut has four lifts per point of the four-coordinate section. | +| `quarter_hyperplane_cap` | Every nonconstant affine linear cut of this six-coordinate quarter has at most 16 points. | +| `quarter_capacity_sharp` | An explicit normal and offset attain 16. | +| `core_cover_card_le` | For any finite core C avoided by H, a cover by L, H and E implies `C.card ≤ (C ∩ L).card + E.card`, including arbitrary overlaps. | +| `unpunctured_quarter_exceptional_floor` | An unpunctured 24-site quarter and a capacity-16 low part force at least eight exceptional sites. | +| `no_sparse_cover_of_at_most_three_deleted` | A 24-site core, at most three deletions, a capacity-16 low part, a high part avoiding the core, and four exceptional sites cannot cover the live core. | +| `no_sparse_cover_with_self` | The same obstruction with at most four deletions holds when an additional external self site must be covered, and carrying self reduces the low part's core capacity to 12. | + +The finite-coordinate statements use `decide`: Lean's kernel checks the finite +reduction. They use neither `native_decide` nor an external computation as an +axiom. The capacity-16 theorem combines the two radical cases with the +capacity-four theorem. The covering theorems are general `Finset` proofs; their +sets may overlap, and the proofs preserve the separate self site. In the +self-carrying case they use the capacity-12 premise. Otherwise they erase self +from the exceptional set, leaving at most three exceptional core sites. + +`formal/DimensionDeletion.lean` proves the following four additional results +over any division ring. Its results concern actual vectors and scalar +coefficients, rather than a support-union relaxation. + +| Declaration | Kernel-checked content | +| --- | --- | +| `exists_nonzero_annihilating` | Any finite family of scalar linear constraints smaller than the dimension has a common nonzero kernel vector. The constraints may be dependent or zero. | +| `exists_nonzero_in_submodule_annihilating` | The vector can be required to lie in a prescribed finite-dimensional submodule; the ambient space need not be finite-dimensional. | +| `exists_nonzero_after_basis_deletion` | Deleting fewer than `dim D` basis coordinates leaves a nonzero vector of D with those coefficients zero and lying in the span of the undeleted basis vectors. | +| `exists_codeword_after_dimension_minus_one_deletions` | Given a basis of the piece span T, every choice of `d - 1` deleted pieces leaves a nonzero ambient codeword in C in the span of the undeleted pieces, where `d = dim(C.submoduleOf T) > 0`. | + +Here `C.submoduleOf T` is the code intersection viewed as a submodule of T. +The last result retains code membership, nonzero ambient value, the killed +coefficients and the remaining-span membership explicitly. It therefore +formalizes the abstract dimension-deletion mechanism used by the caller +argument, without assuming the P112 theorem or a rank-capacity conclusion. + +## Scope left outside Lean + +The handwritten proof must still supply these identifications and premises: + +* E8/P112 roots, the punctured orthogonal frame, root-code supports including + self, and their exact binary labels; root-direction rigidity and the + root32-completion argument. +* An affine quadratic isomorphism between the deleted full quarter and the + explicit 24-point normal form, and containment of a rank-six label-flat + section in one of the nonconstant affine cuts checked here. +* The frame-deletion count, avoidance by the completed rank-seven part, and + the rank-five/capacity-12 implication when the rank-six part carries self. + +These are genuine remaining formalization obligations. They are stated as +ordinary parameters in the finite-set results where relevant; no custom +axiom or theorem asserting the P112 conclusion is introduced. The formal files +also do not formalize the sharp five-site root-code witness, characteristic-zero +transfer, the exact downstream C1 row inventory, or the actual marked decoder +and full invoice bridge. The finite pair-avoidance result supplies a local +construction premise; its E8/root/frame instantiation remains outside Lean. +The additional intrinsic (7,7,5,5) theorem in D2-PROFILE.md, including +its projective-reflection and coefficient-sign argument, is also outside Lean. + +## Reproduction and observed result + +Checked with Lean `4.21.0`, mathlib commit +`308445d7985027f538e281e18df29ca16ede2ba3`. Existing cached oleans were used; +no `lake build`, download, or dependency update was performed. + +Set `MATHLIB` to that cached mathlib checkout, `LEAN` to its Lean 4.21.0 binary, +and `PACKAGE` to this package's absolute directory. The exact compile invocation, +apart from those machine-specific directory values, is: + +```sh +cd "$MATHLIB" +LEAN_PATH='.lake/build/lib/lean:.lake/packages/batteries/.lake/build/lib/lean:.lake/packages/aesop/.lake/build/lib/lean:.lake/packages/Qq/.lake/build/lib/lean:.lake/packages/proofwidgets/.lake/build/lib/lean:.lake/packages/LeanSearchClient/.lake/build/lib/lean:.lake/packages/importGraph/.lake/build/lib/lean:.lake/packages/plausible/.lake/build/lib/lean' "$LEAN" -DwarningAsError=true "$PACKAGE/formal/QuarterCore.lean" +``` + +Compile `formal/DimensionDeletion.lean` with the same command, replacing the +final filename. The two targeted checks were scheduled sequentially and both +exited `0` on 2026-10-18, with warnings treated as errors. The measured real +times for the completed versions were 14.93 seconds for `QuarterCore.lean` +and 20.01 seconds for `DimensionDeletion.lean`. + +`#print axioms` is included for every public theorem. All seventeen report exactly +`[propext, Classical.choice, Quot.sound]`; none reports `sorryAx`, a custom axiom, +or a native-evaluation axiom. This is a passing check of the listed formal core, +not a kernel proof of the entire package theorem. + +## Additional shared-piece algebraic core + +`formal/SharedPiece.lean` adds two checked declarations: + +* `shared_piece_cross_product`: four evaluations supplied by one piece + satisfy A*D=B*C under explicit associative, commutative multiplication. +* `no_shared_piece_at_two_root_self_sites`: self entries2 and a common + off-diagonal entry0,+1 or-1 contradict that identity. The injective + natural-number embedding and the four needed square laws are explicit + ordinary parameters, not custom axioms. + +This file imports **Init only**. Its ring instantiation, identification of +root pairings and assembly with the RIGIDITY.md geometry remain outside +Lean. The identity reports no axioms; the self-site theorem reports only +`propext`. The existing seventeen declarations are unchanged and retain +exactly their earlier reported standard axioms. + +The new file passes Lean4.21.0 with `--threads=1 -DwarningAsError=true`, +1.173s and measured peak RSS242.48MiB under a256MiB external watchdog. +Earlier Mathlib-import variants were stopped at the512MiB resident limit; +no success is claimed for them or for their extra kernel-vector theorem. +The final Init-only file needs no Mathlib imports or LEAN_PATH setting. +The complete d2 invoice and both new intrinsic geometric exclusions are +written proofs, not fully formalized theorems. diff --git a/research/p112-six-seven-supplement/NOTICE.md b/research/p112-six-seven-supplement/NOTICE.md new file mode 100644 index 0000000000..7302d55465 --- /dev/null +++ b/research/p112-six-seven-supplement/NOTICE.md @@ -0,0 +1,16 @@ +New contribution: conorholds, with substantial OpenAI Codex assistance, +including GPT-6.1 SOL agents at xHigh reasoning for proof development, +separate implementation, formal cores and internal read-only review. +No independent human certification is claimed. Apache-2.0. + +Retained source lineage: DreamingOfClouds's PR2816/3154 P112 model and +recorded lists (originally prepared with Anthropic Claude assistance); +Nick Petalas's PR3161/3162 geometry, PR3269/3300 analytic capacities and +adjacent PR3418 support theorem; joaqcoo and the earlier E8/P112 decoder +lineage retained by those sources; David Arias's earlier E8 quadratic-model +work in `masked-root-star-assembly`. Their frozen files are unchanged. +PR3171 supplies the coordinate-kernel/root-pencil mechanism used by the +CALLERS appendix. PR3166 and PR3455 supply the retained matched-cut, +raw-count and singleton-consumer inputs, with their predecessor credits +preserved in SOURCES.json and the written proofs. +The two PR3154 output excerpts have their own notice under inputs/pr3154/. diff --git a/research/p112-six-seven-supplement/PROOF.md b/research/p112-six-seven-supplement/PROOF.md new file mode 100644 index 0000000000..9426eda99f --- /dev/null +++ b/research/p112-six-seven-supplement/PROOF.md @@ -0,0 +1,521 @@ +# The sharp five-site supplement for a six-flat and a seven-flat + +## Statement + +Let $\Phi$ be the E8 roots normalized to squared norm two. Work with their +120 unoriented lines, choosing one rational representative on each line. +Let $F$ be any eight mutually orthogonal root lines and put +$P=\Phi/\{\pm1\}\setminus F$. Thus $P$ has 112 lines. + +Let $L$ be the E8 lattice and $V=L/2L$. A root line $r$ has label + +$$ + \ell(r)=(1,\bar r)\in\mathbf F_2\oplus V. +$$ + +For a binary linear space $U\subseteq\mathbf F_2\oplus V$, write +$\Lambda(U)=\{r\in P:\ell(r)\in U\}$. For a characteristic-zero field +$K$, define + +$$ + c_h(r)=\langle r,h\rangle,\qquad + C=\{c_h:h\in K^8\},\qquad + \operatorname{Off}(h)=\{r\in P:c_h(r)\ne0\}. +$$ + +Write $w(S)=\dim_{\mathbf F_2}\operatorname{span}\ell(S)$ for a site +set, and $w(p)=w(\operatorname{supp}p)$ for a piece. +For a finite-dimensional piece space $T$, let +$\operatorname{cost}_w(T)=\min_{\mathcal B}\sum_{p\in\mathcal B}w(p)$, +where the minimum ranges over its bases. + +**Theorem.** For every nonzero $h\in K^8$ and binary spaces $U_6,U_7$ +of dimensions at most six and seven, + +$$ + \left|\operatorname{Off}(h)\setminus + \bigl(\Lambda(U_6)\cup\Lambda(U_7)\bigr)\right|\ge5. \tag{1} +$$ + +The constant five is attained on the fixed puncture in the pinned source. +Equivalently, no nonzero word in $C$ is a sum of one piece of binary +support rank at most six, one of rank at most seven, and an arbitrary +piece supported on at most four sites. The pieces may overlap and have +arbitrary coefficients and cancellations; independence is unnecessary. +In particular, support-rank bounds $3,6,7$ cannot represent a nonzero +word, since a rank-three support has at most four sites. + +The standard real Weyl-chamber theorem is the classical input in the +root-rigidity step below. All subsequent support bounds and the new +deleted-quarter argument are analytic binary linear algebra. No printed +flat census, decoder normalization, correction bound or supplier premise +is used. + +## 1. Bind the quadratic space and the literal labels + +Use the standard realization + +$$ + L=\{x\in\mathbf Z^8:\textstyle\sum_i x_i\in2\mathbf Z\} + \ \cup\ + \{x\in(\mathbf Z+\tfrac12)^8:\textstyle\sum_i x_i\in2\mathbf Z\}. +$$ + +It is even and unimodular. For example, its integral part is $D_8$; +the displayed half-integral coset makes an index-two extension of +$D_8$, whose determinant is four. Therefore $L$ has determinant one. +The form + +$$ + q(\bar x)=\langle x,x\rangle/2\bmod2,\qquad + B(\bar x,\bar y)=\langle x,y\rangle\bmod2 +$$ + +is well defined on the eight-dimensional binary space $V$, and $B$ +is nondegenerate. Here $B(x,y)=q(x+y)+q(x)+q(y)$. + +The ambient signed sum is + +$$ + \sum_{x\in V}(-1)^{q(x)}=16. \tag{2} +$$ + +One direct proof, fixing its sign, uses the following four lattice vectors, +with coordinate indices $0,\ldots,7$: + +$$ + 2e_7,\quad e_0+e_1+e_2+e_3,\quad + e_0+e_1+e_4+e_5,\quad e_0+e_2+e_4+e_6. +$$ + +Their residues are independent, each has $q=0$, and all mutual pairings +are even. For independence, every nonempty combination of the last three +has a nonzero even/odd coordinate pattern with coordinate seven even, so +it is neither all even nor all odd and cannot belong to $2L$. +The remaining vector $2e_7$ is not in $2L$, because $e_7\notin L$. +They span a totally singular four-space $R$. Nondegeneracy gives +$R^\perp=R$. Summing over cosets of $R$, every coset other than $R$ +cancels by a nonzero character of $R$; the coset $R$ contributes 16. +This proves (2). + +The 120 root lines give 120 distinct residues with $q=1$. Indeed, if +two nonparallel roots $\alpha,\beta$ had the same residue, then +$(\alpha-\beta)/2\in L$, but its squared norm is +$1-\langle\alpha,\beta\rangle/2\in\{1/2,1,3/2\}$, impossible in the +even lattice $L$. Equation (2) says that there are exactly +$(256-16)/2=120$ value-one vectors. Thus root lines are in bijection +with the $q=1$ vectors of $V$. + +The source representatives are doubled roots. Their integral coordinates +in the doubled simple-root basis give exactly the same lattice residues; +the common doubling changes no support. The nine-bit label's leading +one is the low bit in the source files. The pinned source geometry uses +the following doubled simple roots: + + (1,-1,-1,-1,-1,-1,-1, 1) + (2, 2, 0, 0, 0, 0, 0, 0) + (-2,2, 0, 0, 0, 0, 0, 0) + (0,-2, 2, 0, 0, 0, 0, 0) + (0, 0,-2, 2, 0, 0, 0, 0) + (0, 0, 0,-2, 2, 0, 0, 0) + (0, 0, 0, 0,-2, 2, 0, 0) + (0, 0, 0, 0, 0,-2, 2, 0). + +After dividing by two these form a lattice basis of $L$; their Gram +determinant is one. Hence their coordinate residues identify $V$ with +$\mathbf F_2^8$. PR2816's alternative label map pairs a root modulo two +against a unimodular root basis. Unimodularity makes that an invertible +linear change of the eight residue coordinates. The leading bit remains +one. Root ordering, root signs and this label change preserve every +support-rank statement here. Exact retained inputs and byte bindings are +listed in [SOURCES.json](SOURCES.json). + +## 2. Three global support capacities + +We reproduce the signed argument of PR3269 and PR3300 so that the +capacities used in the proof do not depend on a census receipt. + +A nonempty support whose nine-bit labels have rank at most $d$ lies in +the leading-one section of its binary span. Forgetting the leading bit +identifies this section with an affine space $a+H\subseteq V$ of +dimension at most $d-1$. Lower-dimensional affine spaces may be +extended. Thus it suffices to count the value-one points of $q$ on +affine spaces. + +Let $k=\dim H$, let the polar restriction to $H$ have rank $2r$, +and let $R_H=H\cap H^\perp$ have dimension $t=k-2r$. +Nondegeneracy of the ambient polar form gives $t\le8-k$. Put + +$$ + S(a+H)=\sum_{x\in H}(-1)^{q(a+x)}. +$$ + +Polarization and character cancellation give + +$$ + S(a+H)^2 + =2^k\sum_{z\in R_H}(-1)^{q(z)+B(a,z)}. \tag{3} +$$ + +The exponent on $R_H$ is linear. If nonzero, then $S=0$. +Otherwise $|S|=2^{k-r}$. + +There is a useful sign refinement when $k+t=8$. In the latter case +$H=R_H^\perp$, and $q_a(x)=q(x)+B(a,x)$ vanishes on $R_H$. +Cosets of $R_H$ outside $H$ cancel, so + +$$ + \sum_V(-1)^{q_a(x)}=\sum_H(-1)^{q_a(x)}. +$$ + +Translating $q$ by $a$ and using (2) shows + +$$ + S(a+H)=+16. \tag{4} +$$ + +This is a positive signed value, not merely an absolute-value bound. +The number of roots in $a+H$ is $(2^k-S(a+H))/2$. + +For $k=4$, polar ranks zero, two and four give at most $8,12,10$ +value-one points, respectively: in the rank-zero, unbalanced case +(4) gives zero points rather than sixteen. For $k=5$, polar rank +zero is impossible; rank two gives at most sixteen by (4), and rank +four gives at most twenty. For $k=6$, polar ranks four and six give +at most thirty-two and thirty-six. Therefore + +| Binary support rank at most | 5 | 6 | 7 | +|---|---:|---:|---:| +| Full-root support size at most | 12 | 20 | 36 | + +All three bounds remain true after puncturing. Also a support of rank +$d$ has at most $2^{d-1}$ sites from the leading-one coordinate alone. + +We will also use the ambient Walsh identity, an immediate translation +of (2): + +$$ + \sum_{x\in V}(-1)^{q(x)+B(y,x)}=16(-1)^{q(y)}. \tag{5} +$$ + +## 3. A small codeword is a scalar root word + +We need the following standard E8 consequence of the real Weyl-chamber +theorem: + +$$ + |\operatorname{Off}(h)|<70 + \quad\Longrightarrow\quad h\text{ is a scalar root direction}. + \tag{6} +$$ + +Here is the argument and its finite root-system input. Move a real +nonzero normal into a closed fundamental Weyl chamber. Its perpendicular +roots are generated by the simple roots on which it vanishes. +A subsystem on at most six simple nodes has at most 36 root lines, +by the ADE root counts. The same bound holds for any root set of +rational span at most six: all roots in that span form a root +subsystem of rank at most six. For the displayed simple-root order, deleting +one node gives + +| Deleted node | Remaining type | Root lines | +|---:|---|---:| +| 0 | $D_7$ | 42 | +| 1 | $A_7$ | 28 | +| 2 | $A_6+A_1$ | 22 | +| 3 | $A_4+A_2+A_1$ | 14 | +| 4 | $A_4+A_3$ | 16 | +| 5 | $D_5+A_2$ | 23 | +| 6 | $E_6+A_1$ | 37 | +| 7 | $E_7$ | 63 | + +The table follows by deleting nodes in that Dynkin diagram and using +the usual ADE root counts; it is not an inference from a search maximum. +Only the last face can contain more than 42 root lines. Its normal is +the root $e_6+e_7$: it is perpendicular to the first seven displayed +simple roots. Below 70 nonzero live sites means at least 43 live +perpendicular roots, so the moved normal is this root direction. +This argument is uniform over the puncturing frame. + +For arbitrary characteristic-zero $K$, let $Z\subseteq P$ be the live +rational root representatives annihilated by $h$. Rational matrix rank is unchanged after extension +to $K$, so their rational span has dimension at most seven. +The live roots span eight dimensions: in the norm-two convention their +outer-product sum is $28I_8$ (the full-root sum is $30I_8$, and the +orthogonal frame contributes $2I_8$). Thus a nonzero $h$ has at +least one nonzero live evaluation. +Its rational annihilator contains a rational vector with exactly the +same root zeros: every additional nonzero-root equation cuts out a +proper rational hyperplane, and finitely many such hyperplanes do not +cover a rational vector space. Apply the real argument to this vector. +Its full perpendicular roots form an $E_7$ system. The live set +$Z$ itself has at least 43 lines, more than the rank-six bound +36, so $Z$ spans dimension seven. Its one-dimensional rational +annihilator contains $h$ after scalar extension. This proves (6) +over $K$, without ordering $K$ or sampling a finite field. + +For a root $v$, a different root line has pairing $0$ or $\pm1$. +Consequently + +$$ + \operatorname{Off}(v) + =\{r\in P:B(\bar v,\bar r)=1\} + \ \cup\ \bigl(\{v\}\cap P\bigr). \tag{7} +$$ + +The full nonself neighborhood has 56 lines, from (5) with one constraint. +If $v\notin F$, it has exactly four nonorthogonal frame neighbors: +$\sum_{f\in F}\langle v,f\rangle^2=2\langle v,v\rangle=4$. +If $v\in F$, its other frame partners are orthogonal. Hence the live +root-word support sizes are 53 and 56, respectively. + +## 4. A large rank-seven residual forces a full 32-root completion + +Suppose a root normal $v$ satisfies + +$$ + R\subseteq\operatorname{Off}(v),\qquad |R|\ge29,\qquad + \operatorname{rank}_{\mathbf F_2}\ell(R)\le7. \tag{8} +$$ + +The rank is exactly seven, since rank six supports at most twenty +points. Its leading-one section is a unique affine six-space $A$. +Write $v$ also for its residue when it occurs inside $B$ or $q$. + +If $B(v,\cdot)$ varied on $A$, its value-one slice would be an +affine five-space with at most twenty roots. Equation (7) permits at +most one further root, the self line $v$, so $|R|\le21$, a +contradiction. If the value were constantly zero, there would be at +most the self line. Thus + +$$ + A\subseteq\{x:B(v,x)=1\}. \tag{9} +$$ + +The perpendicular plane to the direction of $A$ contains $v$. +Choose an independent vector $s$ in it and write + +$$ + A=\{x:B(v,x)=1,\ B(s,x)=\theta\}. +$$ + +Equation (5) gives + +$$ + \sum_{x\in A}(-1)^{q(x)} + =4\sum_{a,b\in\mathbf F_2} + (-1)^{q(av+bs)+a+b\theta} + =4\sum_{a,b}(-1)^{b(q(s)+\theta)+abB(v,s)}. \tag{10} +$$ + +If $B(v,s)=1$, this sum is eight, so $A$ has 28 roots. +If $B(v,s)=0$, it is zero or sixteen, so $A$ has 32 or 24. +Condition (8) forces the 32 case. Set $u=s+q(s)v$. Then + +$$ + q(u)=0,\quad B(v,u)=0,\quad + A=\{x:B(v,x)=1,\ B(u,x)=1\}. \tag{11} +$$ + +In particular $u,v$ are independent. The parallel affine six-space + +$$ + A_C=\{x:B(v,x)=1,\ B(u,x)=0\} +$$ + +has exactly 24 roots, again by (10). Denote that root set by $C_v$. +It has binary label span $W_C$ of dimension seven, since 24 is +larger than the rank-six capacity twenty. The self label $\ell(v)$ +does not belong to $W_C$, because $B(v,v)=0$ while every +leading-one point in $W_C$ satisfies $B(v,x)=1$. + +The original residual spans the entire seven-space of (11). +Thus any rank-seven label space containing $R$ is precisely that +space; it contains none of $C_v$, and it does not contain the +live self line $v$. + +## 5. The deleted quarter has six-flat capacity sixteen + +**Quarter lemma.** Any binary label space $W$ of dimension at most six +contains at most sixteen roots of $C_v$. If it contains $\ell(v)$, +it contains at most twelve roots of $C_v$. + +For the first assertion, enlarge $W\cap W_C$, if necessary, to a +hyperplane in $W_C$. Its leading-one section is either empty or a +proper affine hyperplane of $A_C$, so it adds a constraint +$B(s,x)=\theta$ with $s\notin\langle v,u\rangle$. +The resulting affine five-space has 32 points. Its signed quadratic +sum is + +$$ + \frac{16}{8}\sum_{a,b,c\in\mathbf F_2} + (-1)^{q(av+bu+cs)+a+c\theta}. \tag{12} +$$ + +Using $q(v)=1,q(u)=0,B(v,u)=0$, the exponent simplifies to + +$$ + c(q(s)+\theta)+acB(v,s)+bcB(u,s). +$$ + +The $c=0$ contribution is four. The $c=1$ contribution is zero +if either coupling is one, and otherwise it is $+4$ or $-4$. +Hence (12) is eight, sixteen or zero. The root count is respectively +twelve, eight or sixteen. This proves the bound sixteen. + +If $\ell(v)\in W$, the fact $\ell(v)\notin W_C$ gives +$\dim(W\cap W_C)\le5$. The global rank-five capacity from section 2 +then gives the stronger bound twelve. This proves the lemma. + +## 6. Prove the five-site floor + +Suppose, contrary to (1), that + +$$ + \operatorname{Off}(h)\subseteq + \Lambda(U_6)\cup\Lambda(U_7)\cup E,\qquad |E|\le4. +$$ + +The global capacities give $|\operatorname{Off}(h)|\le20+36+4=60<70$. +By (6), rescale $h$ to a root $v$. The residual + +$$ + R=\operatorname{Off}(v)\setminus(\Lambda(U_6)\cup E) +$$ + +has at least $53-20-4=29$ sites and lies in $U_7$. +Section 4 therefore identifies $U_7$ with the full 32-root completion. +Its deleted quarter $C_v$ and any live self line must be covered by +$\Lambda(U_6)\cup E$. + +Let $f=|C_v\cap F|$. Equation (7) and the frame identity give +$f\le4$; if $v\in F$, then $f=0$. + +If $f\le3$, at least 21 live quarter roots must be covered. +The quarter lemma and $E$ cover at most $16+4=20$, a contradiction. + +It remains to consider $f=4$. Then $v\notin F$, the live quarter +has twenty sites, and the self line $v$ must also be covered. +If $\ell(v)\in U_6$, the stronger quarter bound leaves capacity +at most $12+4=16<20$. If $\ell(v)\notin U_6$, then $v\in E$. +Since $v\notin C_v$, at most three sites of $E$ remain available +for the quarter, giving $16+3=19<20$. + +Every case is impossible. This proves (1). + +For the equivalent piece statement, the supports of the rank-six and +rank-seven pieces lie in their binary label spans. The remaining +piece supplies at most four sites. Conversely, a hypothetical cover +allows the codeword to be partitioned among these three support sets. +Thus the two formulations are equivalent, with no restriction on +coefficients or overlap. + +## 7. A literal five-site coefficient partition + +Use the fixed frame +$e_0\pm e_1,e_2\pm e_3,e_4\pm e_5,e_6\pm e_7$. +Take $v=e_0+e_2$, $w=e_0-e_2$, and $a=e_0+e_1+e_2+e_3$. +The live support of $c_v$ is a disjoint union $X\sqcup Y\sqcup E_5$: + +* $X$ consists of the 32 half-integral root lines with equal + coordinates zero and two. Equivalently its residues satisfy + $B(v,x)=1,B(w,x)=0$. +* $Y=\{e_0\pm e_j,e_2\pm e_j:j=4,5,6,7\}$, sixteen lines. + It is the section $B(v,x)=B(w,x)=B(a,x)=1$. +* The remaining five lines are + +$$ + E_5=\{e_1-e_2,\ e_1+e_2,\ e_0-e_3,\ e_0+e_3,\ v\}. +$$ + +These descriptions follow directly from the two-coordinate and +half-integral root forms. The four deleted frame neighbors are +$e_0\pm e_1,e_2\pm e_3$. +Thus $|X|=32,|Y|=16,|E_5|=5$ and their union is exactly +$\operatorname{Off}(v)$, which has 53 sites. + +The residues $v,w,a$ are independent: $v+w=2e_0$ is nonzero +modulo $2L$, and the odd coordinates one and three of $a$ put it +outside their span. The two affine equations give $w(X)\le7$, +while $|X|>20$ gives $w(X)=7$. The three independent equations give $w(Y)\le6$, +while $|Y|>12$ gives $w(Y)=6$. The labels of the first four +lines of $E_5$ sum to zero, since $2e_i$ has the same residue +for every $i$. Consequently $w(E_5)\le4$; five distinct +leading-one labels cannot have rank at most three, so $w(E_5)=4$. + +Define each of three pieces to equal $c_v$ on its displayed set +and zero elsewhere. They are nonzero, disjoint and sum to $c_v$ +over every characteristic-zero field, with support ranks $7,6,4$. +In the doubled source convention the scalar value is +$R\mathbin{\cdot}V/4$, where $R=2r$ and $V=2v$. +This is an actual rational coefficient witness, rather than just a +support mask. It attains the five-site supplement in (1). + +Splitting $E_5$ into its first four sites and $\{v\}$ gives +four independent pieces of ranks $7,6,3,1$, with sum $c_v$. +Their span intersects $C$ in exactly one dimension: every codeword +in their span vanishes on the 59 live roots perpendicular to $v$; +those roots span dimension seven, because a root subsystem of +rank at most six has at most 36 lines. Its normal is therefore $v$. +The displayed basis is also a minimum-weight basis. More generally, +let disjoint-support nonzero pieces $p_1,\ldots,p_m$ form a basis. +A linear combination has support equal to the union of the supports +whose coefficients are nonzero, so its weight is at least that of +each participating $p_j$. The coefficient matrix of any other basis +is invertible. A nonzero term in its determinant matches its rows +bijectively to distinct columns with nonzero coefficients. Summing +the corresponding lower bounds gives a total weight at least +$\sum_j w(p_j)$. For these four pieces the minimum is therefore +$7+6+3+1=17$. This supplies a genuine nearby $d=1$, +$\operatorname{cost}_w(T)=17$, T-space with slack nine. +It supplies no marked decoder or correction-invoice counterexample. + +## 8. Scope, source dependencies and credit + +The exact earlier one-extra-site check is PR2816 at +`4c32ac3b88d63ad06d2b30e526aa07a12929db36`, +in `research/one-sided-decoders-all-m/checks/cover761.py`. +For a 53-site root target it retains seven-flat sections of size at +least 32 and six-flat sections of size at least 20. Those thresholds +are sound for its question: covering with one further site needs +at least 52 sites from the two flats, whose target capacities are +32 and 20. Its printed minimum of nine uncovered sites ranges over +that pruned domain. It is not a global minimum over all six/seven-flat +pairs. The present literal 32-plus-16 partition leaves five sites and +does not enter the predecessor's six-section domain. Thus it is a +counterexample to interpreting the printed nine as a global bound, while the +predecessor's no-one-extra-site theorem remains valid. + +The new ingredients are the root-specific 32-point completion, the +deleted-quarter capacity sixteen and its self-line refinement, and the +resulting sharp six/seven-flat supplement theorem. The signed character +method and global capacities are credited to PR3269 and PR3300, with the +full arguments reproduced above. David Arias's retained +`masked-root-star-assembly` is earlier E8 quadratic-model work credited +by those sources. The E8 root code, frame, labels and +root-rigidity lineage come from PR2816, PR3154 and the retained +PR3161/3162 geometry, including joaqcoo's earlier decoder formulation. +PR2816 already records the numerical 32-point root-target capacity; +the present argument identifies the completion and its deleted quarter. +Exact heads and source files are recorded in [SOURCES.json](SOURCES.json). + +[CALLERS.md](CALLERS.md) gives the nine literal PR3154 implications. +They are statements about independent pieces and their code intersection. +The support theorem alone does not validate N8, the source's global branch +reduction, C1 as a whole or supplier admission. [UNIFORM.md](UNIFORM.md) +adds the complete root-word equality classification. [D1.md](D1.md) uses +additional retained matched-cut inputs to derive the actual d=1 invoices +and the stated singleton-pivot consumer, including all actual-basis surplus. +[D2.md](D2.md) separately closes the actual d=2 invoices. +Actual d>=3 invoices and global normalization remain separate. + +The mathematical proof uses the standard Weyl-chamber theorem; finite +coordinate checks corroborate its declared E8 inputs and the literal +witness rather than replacing that theorem. Any formal cores have only +their separately stated scope. Neither executable success nor a partial +formalization would constitute a proof-kernel verification of the entire +argument. + +New work is by conorholds with substantial OpenAI Codex assistance. +Predecessor authorship and licensing remain as recorded in the retained +sources. diff --git a/research/p112-six-seven-supplement/RAW-SHAPE.md b/research/p112-six-seven-supplement/RAW-SHAPE.md new file mode 100644 index 0000000000..6964b1c3ff --- /dev/null +++ b/research/p112-six-seven-supplement/RAW-SHAPE.md @@ -0,0 +1,246 @@ +# No raw threshold-dimension defect in a putative bad invoice + +Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0. +Definitions, characteristic-zero setting and predecessor credits are those +of D1.md and D2.md. This is a written theorem, not a full Lean theorem. + +## Statement + +Let S contain C, dim S=8+t, t in {2,3}. Let F be an actual basis, with +every restricted dual x_j nonzero. Put T=span{q in S:w(q)<=7}, +d=dim(C intersect T)>0, a=dim T, and I=sum_F w-n_c. Assume + + sum_F w <=72 for t2, or <=73 for t3, and I<=64. + +Then **a=d+t**, for every 1<=d<=8. For d<=6 the raw weight budget alone +suffices: the I and nonzero-dual assumptions are not used. + +The marked contradiction regime I<=64 implies these raw budgets by +PR3455's raw correction cap; the unmarked regime I<=63 also implies +them. Thus no positive-d invoice search in these regimes needs a +lower-dimensional T branch. This does not force F intersect T to span T, +bound repeated corrected indices, prove N8, or settle the d>=3 invoices. +Global rank/pivot normalization remains separate. + +## 1. Peeling and small residual spans + +Choose a minimum-weight basis of T, all of whose weights are <=7. Write +f=|F intersect T|, r=a-f, c9 for the number of actual outside weight-nine +members, and eta=sum_(F intersect T)w+8r-cost(T). Completing the inside +independent family with r low generators gives eta>=r. Exactly + + sum_F w = cost(T)+8(8+t-a)+eta+c9. (1) + +Consequently cost(T)<=8a-8 at t2, and <=8a-15 at t3. Dimension gives +d<=a<=d+t. The case a=d is impossible: T would be contained in C, which +has no nonzero words of weight <=7, whereas T is generated by such words. + +We use three established inputs: every representation of a nonzero +codeword by pieces of weight at most seven has total covering weight +at least14; ranks6 and7 alone cannot cover a nonzero codeword; +and the four-six, intrinsic7755 and intrinsic7764 exclusions proved in +CALLERS.md, D2-PROFILE.md and RIGIDITY.md. Deleting k basis coordinates +from a d-dimensional code intersection leaves dimension at least d-k. + +For t2 and a<=d+1, delete the d-1 heaviest coordinates. A nonzero +codeword remains at covering weight at most + + floor((a-d+1)cost(T)/a). + +At a=d this is <=7. At a=d+1 it is at most +floor(16-16/(d+1)), which is <=13 through d=6. This contradicts14 and +proves a=d+2 for those d. + +For t3, d=1 is immediate: a<=3 would give cost(T)<=9<14. For d>=2, +the case a=d+1 is also impossible. Delete the d-2 heaviest coordinates, +leaving a two-dimensional code intersection in the three smallest +pieces. Every one of their weights must be seven: otherwise killing +another coordinate covers a nonzero word by ranks6 and7. Hence every +minimum weight is seven, so 7a<=8a-15 would require a>=15, whereas a<=9. + +For the remaining t3 defect a=d+2, delete d-2 heaviest coordinates. +The four smallest weights support a two-dimensional code intersection. +They must dominate one of the necessary lower profiles + + 7666, 7765, 7771. (2) + +Indeed four ranks<=6 are excluded. With exactly one seven, killing it +forces the other three weights to be666, since20+20+12<53. With at least +two sevens, the intrinsic7755 and7764 exclusions leave either a third +seven or a six followed by at least five. No feasibility of (2) is claimed. + +The first two alternatives force total minimum cost >=7a-3; the third +forces >=7a-6. Comparison with8a-15 excludes a<=8. This proves the t3 +raw-dimension statement through d=6. It leaves only the exact boundaries +listed in Sections 3--4. + +## 2. Two actual boundary-profile lemmas + +First suppose t2, F consists of eight weight-seven members and two +weight-eight members, L spans the eight sevens, and dim(C intersect L)=7. +Then **I>=65**. + +Let D=C intersect L. Both outside duals are nonzero multiples of a normal +h spanning Ann(D). The eight inside coordinate restrictions on D are +nonzero and pairwise independent. To see this, write D=ker lambda in L. +Every coordinate of lambda is nonzero: otherwise its basis vector lies +in C, impossible at weight seven. A relation involving at most two +coordinate restrictions cannot be a multiple of this full-support lambda. +Corrected inside frame indices are therefore distinct. + +If h is not a frame direction, neither outside member is corrected. +Assuming n_c>=8 forces all eight sevens corrected, one per frame axis. +Choose two active coordinates i,j of h. The two-axis normal +u=(h,f_j)f_i-(h,f_i)f_j is nonzero and perpendicular to h. Its codeword +belongs to D and uses only the two corresponding seven-pieces. It has +at most72 sites, contrary to the retained two-axis minimum76. + +If h=f_0, no inside corrected row has index0. Under n_c>=8, at least +six of the eight sevens are corrected. Seven corrected rows leave one +uncorrected piece A. Any other frame word is covered by its matched +seven, of target capacity20, and A, of frame-target capacity32. This +would give56<=52. + +Six corrected rows leave two uncorrected pieces A,B and one missing +frame index b!=0. The word C_(f_b) uses only A,B. Both their label flats +lie inside W_b: otherwise their frame-target capacities total at most +20+32<56. Thus both pieces vanish outside N(f_b). For any corrected +index i, its piece must contain all32 sites N(f_i) minus N(f_b). +Those labels span rank seven and exclude z_i (the two orthogonal-frame +completion equations). Its entire rank-seven span is that span, so it +cannot carry z_i. This contradiction proves n_c<=7 and I>=65. + +Second suppose t3, F consists of eight sevens, one unit piece and two +eights, and L spans the nine inside pieces with dim(C intersect L)=7. +Again **I>=65**. The outside normals lie in Kh=Ann(C intersect L). +If h is not frame, n_c<=8 because the unit cannot be corrected. +Otherwise h=f_0 and n_c>=9 forces at least seven corrected sevens. +Inside corrected indices may repeat. The argument counts their groups +and uses a singleton group; it does not require pairwise distinctness. + +Every other frame index needs a corrected group. An absent group would +leave its frame word supported by at most one uncorrected seven plus +the unit, of target capacity<=33. Seven corrected sevens therefore give +seven singleton groups; each frame word is covered by its matched +seven, the uncorrected seven and the unit, with capacity20+32+1=53<56. +With eight corrected sevens there is still a singleton group among the +seven required indices. Its frame word has capacity20+1<56. These are +the only cases, so n_c<=8 and I>=65. + +## 3. The t2 boundary d=7 or8 + +At d=7 a defect has a=8. Killing the six largest minimum coordinates +leaves two pieces covering a nonzero word, so their weights total at +least14. Both are <=7; hence all eight minimum weights are seven. +Thus cost(T)=56 and (1) forces r=eta=c9=0 and the actual profile7^8,8^2. +Its eight-low span is T and meets C in dimension seven. The first +boundary lemma excludes I<=64. + +At d=8, a=8 is already impossible. At a=9 the same tail argument forces +nine minimum weights seven, cost63, and eta+c9<=1. Adaptation r=0 +would give an outside actual dual vanishing on C, since C is contained +in T. Hence r=eta=1,c9=0. The actual inside sum is56, so it consists +of eight sevens; all nonzero T-words have weight at least seven here. +The two outside members are eights. Their inside span L meets C in +dimension at least seven, and cannot meet it in dimension eight: +otherwise C is contained in L and the outside duals vanish on C. +The first boundary lemma again applies. This completes t2. + +## 4. The t3 boundary d=7 or8 + +At d=7 the only defect is a=9. The lower bounds in (2) and cost<=57 +force minimum profile1,7^8 with cost57. Equation(1) forces actual +adaptation and the same inside minimum profile, followed by two eights. +The second boundary lemma excludes I<=64. + +At d=8 the only defect is a=10. Minimum cost is <=65, whereas the first +two alternatives in (2) require at least67. Thus only the minimum +profiles1,7^9 (cost64) or2,7^9 (cost65) remain. The latter forces r=0, +impossible because C is contained in T and an outside dual would vanish. +In the former, eta+c9<=1 and r>=1, so r=eta=1,c9=0. The actual inside +sum is57. The threshold space through weight six is the unit line; +therefore its nine independent actual inside members are one unit and +eight sevens. Their span L has code intersection exactly seven by the +same dimension and nonzero-outside-dual argument. The two outside members +are eights. The second boundary lemma excludes I<=64 and completes t3. + +The new common-profile arguments use actual coordinate expansions and +corrections. They do not assert that T-level deletion preserves an +invoice. All geometric premises are the retained support capacities, +two-axis support minimum and orthogonal-frame completion bounds already +identified in D1.md and PROOF.md. No normalized source list is needed. + +## 5. Actual d=3 defect branches closed by transfer + +Retain the statement's hypotheses and put d=3. Then every putative bad +invoice has either **r=0**, or **r=1 and eta>1**. In particular all r>=2 +branches, and every nonadapted branch eta=r, are excluded. This is a +partial actual invoice result, not the complete d3 invoice. + +First, the intrinsic low-family bounds give cost(T)>=29 at t2 and >=30 +at t3. For t2, five pieces of ranks<=6 cannot have code intersection +three: delete one coordinate and apply four-six. Otherwise delete a +seven. The remaining four pieces have code intersection at least two +and minimum total weight22, with unique equality profile7771. Thus +cost29 forces minimum profile77771. + +For t3, suppose the six-piece cost is<=30 and all weights are<=6. +Deleting a heaviest coordinate leaves five pieces with cost<=25 and +code intersection at least two. The intrinsic five-piece exhaustion in +D2.md excludes all such profiles with weights<=6 (four-six-plus-small, +or55555). Hence a seven exists. Deleting it uses the five-piece lower +bound23, with unique equality profile77711. This proves cost>=30, +with equality profile777711. + +Equation(1) now gives eta+c9<=3, so r<=3. At r=3 equality forces +eta=3,c9=0 and the two displayed minimum profiles. Actual inside cost +is8 at t2 and9 at t3. Their threshold filtrations force actual inside +profiles71 and711 respectively: below rank seven the spaces are the +unit line and the two-unit plane. The actual inside span L is disjoint +from C by support distance53, and S=C direct-sum L. All eight outside +members have weight eight. The actual71 argument of D1 Section3 +(reused in D2's r2 case) excludes n_c>=8. For711, n_c>=9 forces all +eight highs and the seven-low corrected; every other frame axis has an +actual expansion whose low contribution uses only the two unit lows, +contrary to G2's required24 cancellations. This excludes r=3. + +For eta=r>0, complete the actual inside family to T by r low generators. +Their cost is at most7r, whereas eta=r gives + + cost(T)=sum_inside w+7r. + +Thus the completion attains the minimum and all new generators have +weight seven. Replacing the inside family by a minimum basis of L while +keeping those completion vectors still gives a basis of T, so + + cost(L) <= sum_inside w = cost(T)-7r <= cost(L). + +Hence the actual inside family is a minimum basis of L. At r=1, L has +dimension4/cost<=24 at t2, or dimension5/cost<=25 at t3; its code +intersection has dimension exactly two. At r=2 these are dimension3/ +cost<=16 or dimension4/cost<=17, with code intersection exactly one. +The lower bounds just proved, the four-piece bound22 and the two-piece +covering-weight bound14 rule out larger intersections by deletion. +In each case C+L=S. Hence the actual outside restricted duals are +independent in the appropriate annihilator. The adapted eta0 arguments +of D2 (r=1) and D1 (r=2) apply to this explicit L and exclude the bad +invoice. This reuses their actual-profile proofs, not their theorem +statements with L substituted for the global threshold space. + +It remains to exclude r=2,eta=3. The budget forces c9=0 and cost(T)=29/ +30. The same threshold filtrations give actual inside profile871 at +t2, or8711/7721 at t3. Their code intersection is exactly one: it is +at least one by dimension, and killing one large coordinate in a +putative two-dimensional intersection leaves a support below53. +Thus C+L=S and all seven actual outside members have weight eight. +These are precisely the actual-L configurations excluded by D2's +nonadapted871 argument at t2 and8711/7721 argument at t3. Those proofs +use the displayed actual coefficients, independent outside duals and +n_c>=8/9, all available here; they require neither minimum L nor L=T. +This completes the stated defect-branch exclusion. + +The remaining adapted d3 cases and r=1 with eta>1 need new invoice +arguments. For example, minimum77771 with r=1,eta=2 permits actual +inside8771; one cannot infer a7771 minimum basis of that L. Also the +three-dimensional code intersection can contain three independent +frame lines, so the d2 root-plane contradiction does not transfer. diff --git a/research/p112-six-seven-supplement/README.md b/research/p112-six-seven-supplement/README.md new file mode 100644 index 0000000000..15c4bd4330 --- /dev/null +++ b/research/p112-six-seven-supplement/README.md @@ -0,0 +1,221 @@ +# Sharp P112 six/seven-flat bounds and actual d=1,2 invoices + +[D1.md](D1.md) closes the actual **d=1 invoice for t=2 and t=3**: +the root-marked invoice is `I>=65`, and the unmarked floor is `I>=64`. +It also proves the cost-64 floor for the stated actual singleton-pivot +consumer. The proof includes every non-adapted basis and the t=3 +cost-seventeen/slack-nine boundary, without N8 or a minimum actual basis. +[D2.md](D2.md) extends all three conclusions to **d=2, t=2 and t=3**. +It exhausts the actual basis, including every nonadapted and weight-nine +surplus case, and derives the low-space dimension without source-list +completeness. Its new intrinsic inputs in [RIGIDITY.md](RIGIDITY.md) exclude +**7,7,6,4** and **7,6,6,5,1** at code intersection at least two. +[RAW-SHAPE.md](RAW-SHAPE.md) also removes every positive-d threshold-dimension +defect under the raw budgets and a putative I<=64. It does not force basis +adaptation. Its actual d3 transfer also excludes every r>=2 defect and every +nonadapted eta=r branch. Complete d>=3 invoices and the global decoder +reduction remain open. + +[D2-PROFILE.md](D2-PROFILE.md) additionally excludes any independent +four-piece family of support ranks at most **7,7,5,5** whose span meets +the code in dimension at least two. The proof uses actual coefficient +ratios after forcing two frame directions. It closes that literal d=2 +profile and, by dimension deletion, the recorded d=3 profile 7,7,7,5,5. +The full d=2 actual invoice is proved separately in D2.md. + +Every nonzero P112 evaluation-code word over a characteristic-zero field +leaves **at least five sites** outside one binary rank-six flat and one +rank-seven flat. [UNIFORM.md](UNIFORM.md) proves that five is attained for +every nonframe root and every puncturing frame, by a coefficient partition +of sizes **5,16,32** and support ranks **4,6,7**. It classifies exactly +three optimal pairs per nonframe root. Frame-root words have sharp +remainder eight and exactly 945 optimal pairs; nonroot directions leave +at least fourteen sites. + +Equivalently, no nonzero codeword is a sum of a rank-six piece, a rank-seven +piece and a piece on at most four arbitrary sites. All overlaps, coefficients +and cancellations are allowed. In particular, ranks **3,6,7** are impossible. + +The [analytic proof](PROOF.md) identifies a 32-root completion and its +24-root deleted quarter. A six-flat meets that quarter in at most sixteen +sites; carrying the self root reduces the capacity to twelve. Keeping that +self root is essential to the sharp four-versus-five boundary. + +## Named applications + +[CALLERS.md](CALLERS.md) proves nine independent-piece exclusions from the +literal positive-d C1 lists in [PR3154](https://github.com/CrocSwap/integer-mult-bounds/pull/3154) +at `708f0ad8928c383de8294aea3c126e9461d2066d`. Four are t=2 profiles and +five are t=3 profiles. The implication uses a dimension-deletion lemma; +it does not assume a minimum basis, N8, completeness of those lists or the +source's global normalization. + +The support theorem supplies nine T-level applications; D1.md adds the +actual d=1 invoice and consumer using the retained matched-cut geometry. +D2.md closes the corresponding actual d=2 invoice and consumer. +The CALLERS appendix also composes PR3171's coordinate-kernel/root-pencil +method with dimension deletion, giving 85 further literal profile +implications (two t=2, 83 t=3). These are historical-list implications, +not a claim of 85 currently open cases or first closures. +The new shared-frame coefficient argument supplies the two further +literal t=2 applications described in D2-PROFILE.md. +Complete C1, the global P112 decoder floor, d>=3 invoices, supplier +admission and a selected-frontier change remain outside the result. + +## Evidence and scope + +Two separately implemented exact engines reconstruct the declared geometry +and its historical label convention. The primary uses simple-root coordinates +and polar equations. The second reconstructs roots and quadratic coordinates +independently and uses ordinary-dot RREF annihilators. Their complete results +and completion-set digest agree: + +| Finite input | Coverage | +|---|---:| +| Full root lines / live lines / punctured frame | 120 / 112 / 8 | +| Affine six-spaces, including all four offsets | 43,180 | +| Root/affine-space intersections | 5,181,600 | +| Classified live residuals of size at least 29 | 6,216 | +| All ordered orthogonal-root completions | 7,560 | +| Unordered 24-root quarter families | 3,780 | +| Nonzero hyperplane functionals per quarter | 127 | +| Literal historical profile applications | 9 | +| Optimal five-site / eight-site root covers | 336 / 7,560 | +| Matched frame-plane cuts, with every one-point deletion | 42,840 | +| Root planes, each containing at most three root lines | 4,900 | +| Credited four-six pencil profile implications | 85 | +| Shared-frame sign halves / literal profile implications | 56 / 2 | +| Distinct complementary 28-root sections / root-high cases | 12,000 / 15,360 | +| Six-quadric affine-four / affine-five sections | 2,604 / 126 | +| Four-axis form inventories / A2 planes | 70 / 1,120 | +| d2 cost-24 four-weight / cost-25 five-weight profiles | 203 / 386 | + +The numerical counts corroborate finite proof inputs; the theorem is the +written argument. The root-rigidity step retains the standard real +Weyl-chamber theorem, with a rational-nullspace transfer to every +characteristic-zero field. The global 12/20/36 support capacities and +the new completion/quarter bounds are proved analytically. + +The exact sharpness witness is checked on all 112 scalar coordinates. +Splitting its five-site remainder gives an independent-piece space of +profile 7,6,3,1, code intersection dimension one and minimum basis cost +seventeen: a genuine nearby slack-nine T-space boundary. D1.md proves +that its actual correction budget cannot lower the invoice below the +stated floors. It is not a decoder counterexample. + +The newly used inherited frame-plane no-coloop input is recomputed on +all 42,840 cases: one engine enumerates ambient dual restrictions, while +the other tracks fundamental binary dependencies. Both agree. Separate +profile enumerations check every minimum-profile case through cost17. +Two actual d=1 factorizations verify all 25,088 Gram entries, actual +factor ranks, nonparallel factors, restricted duals, term costs and the +complete low-space support strata. These controls use one audited +implementation and attain costs 71 and 72. Two further **actual d=2** +controls, for t2 and t3, have live-root marks and three corrected weight-nine +highs each. They check all 25,088 additional Gram entries, actual ranks, +nonparallel factors, restricted duals and exact term costs (77 in both). +Their invoices are 76 and 77; no sharpness at 64 is claimed. + +For both d2 controls the complete threshold space is certified, rather +than inferred from selected low pieces. Outside each of all 43,180 +affine-six flats, disjoint low-piece coordinates are eliminated; the +remaining six-dimensional C/T evaluation matrix has rank six modulo3. +Its nonzero integer minor proves the same full rank in every +characteristic-zero field. Thus any low word lies in the exhibited T, +of dimension 4 or 5 and code intersection dimension two. The complete low-space certificates are +independently replayed in +`independent_d2.py`: ordinary-dot RREF coordinates and full evaluation-matrix +elimination over F5 replace the primary polar coordinates and F3 anchor +differences. It authenticates its inputs separately and rejects a zeroed +quotient column. The exact factorization/term-cost construction itself uses +one implementation, separately reviewed as code and mathematics. These +fixtures do not exhaust all actual decoder factorizations. + +Meaningful controls distinguish the self root from its open neighborhood, +reverse the completion, alter a coefficient, omit a live root, omit the +puncturing frame and change the quadratic sign. The CLI controls execute +nine scientific code mutants on private copies, including the actual +singleton compensation sign, along with changed/linked source and +strict-receipt controls. Default replay changes no input bytes. + +[FORMAL.md](FORMAL.md) describes nineteen kernel-checked Lean declarations: +the concrete split four-dimensional quadric, its radical lift and cap16, +and the finite-set sparse obstruction with its self-site case. They also +prove pair-avoiding sections, the frame-eight bound and the actual-vector +dimension-deletion mechanism. Two further Init-only declarations prove the +actual shared-piece cross-product identity and self-site obstruction, +with explicit multiplication/embedding premises. The complete E8 identification, +root-completion +theorem, field transfer and invoice/consumer assembly remain outside Lean. +Internal AI cross-checks are separate from +independent human or full proof-kernel review. + +## Relation to earlier work + +PR2816's `cover761.py` excludes the **one-extra-site** shape. Its printed +nine-site minimum uses pruning that retains only target intersections of +sizes at least 32 and 20. That figure is not a global minimum over all +six/seven-flat pairs: the present 32+16 cover leaves five sites and falls +outside that pruned domain. The earlier one-extra-site result remains valid. + +PR3269 and PR3300 supply the signed-quadratic method and analytic global +capacities. PR3418 treats the distinct four-piece shape sparse-four plus +ranks 5,6,6. The present proof handles a rank-seven piece directly. +PR3455 establishes the marked d=0 invoice. This package extends its actual +basis and consumer arguments to d=1 and d=2, retaining its raw marked correction +cap and geometric row-edit inputs. Sources and exact predecessor heads +are in [SOURCES.json](SOURCES.json). + +## Reproduce + +Use Python 3.12 and the standard library, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/p112-six-seven-supplement --check-only +python3.12 -B scripts/research_package.py --package research/p112-six-seven-supplement +``` + +Direct replay is also available: + +```sh +python3.12 -I -O -Werror -B research/p112-six-seven-supplement/verify.py +python3.12 -I -O -Werror -B research/p112-six-seven-supplement/test_package.py +python3.12 -I -O -Werror -B research/p112-six-seven-supplement/independent_d2.py +``` + +`verify.py --emit` deliberately replaces RESULT.json; default verification +compares its exact typed scientific content. `--sources-only` reports only +input integrity and has a distinct PASS label. Lean reproduction is separate +and explicit in FORMAL.md. Hosted CI, a repository-wide build and the selected +cold replay are not claimed or needed for this isolated theorem. + +## Open next questions + +1. Bind the remaining E8/label/completion steps to the formal cores. First + formalize the quadratic affine normal-form map; the present handwritten + bridge is the missing premise of a full kernel proof. +2. Resolve actual d>=3 C1 invoices, retaining their actual coefficient and + correction contracts; d=1 and d=2 are closed here. First kill d-2 minimum + low-piece coordinates and apply the intrinsic 7755/7764/76651 exclusions + where the remaining profile is dominated by one of those shapes. A + T-level deletion alone does not preserve the actual invoice or correction + ledger. RAW-SHAPE.md already proves full threshold dimension under a putative bad + invoice for every positive d (raw budget alone through d=6). Actual + higher-d invoices and surplus cases are open. Global rank/pivot normalization remains separate. + +These scoped next steps and blockers are recorded in TASK.json. Neither +requires another global flat census as an initial experiment. + +## Credit + +DreamingOfClouds supplies the P112 piece model, earlier cover and circuit +methods and PR3154's reduction and literal lists. Nick Petalas supplies +PR3269/3300's analytic capacities and the adjacent PR3418 support work. +PR3171 supplies the coordinate-kernel/root-pencil method composed in +the CALLERS appendix; that mechanism is credited predecessor work. +David Arias's `masked-root-star-assembly` supplies earlier E8 quadratic-model +work explicitly credited by those predecessors. +The retained geometry follows PR3161/3162 and the E8/P112 lineage including +joaqcoo. The new theorem, witness, caller implications and verification are +attributed to conorholds. Substantial AI assistance and exact retained-source +credits are disclosed in TASK.json and NOTICE.md. Apache-2.0. diff --git a/research/p112-six-seven-supplement/RESULT.json b/research/p112-six-seven-supplement/RESULT.json new file mode 100644 index 0000000000..e100593b6b --- /dev/null +++ b/research/p112-six-seven-supplement/RESULT.json @@ -0,0 +1,782 @@ +{ + "actual_d2_factorization_controls": { + "cases": [ + { + "actual_cost": 77, + "corrected_weight9": 3, + "d": 2, + "dimension_T": 4, + "exact_Gram_entries": 12544, + "invoice": 76, + "low_space_flats": 43180, + "n_c": 3, + "nonparallel_factors": true, + "quotient_minor_rank_mod3": 6, + "rank_P": 9, + "rank_Q": 10, + "t": 2, + "term_costs": [ + 1, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "weights": [ + 7, + 7, + 7, + 7, + 8, + 9, + 9, + 9, + 8, + 8 + ] + }, + { + "actual_cost": 77, + "corrected_weight9": 3, + "d": 2, + "dimension_T": 5, + "exact_Gram_entries": 12544, + "invoice": 77, + "low_space_flats": 43180, + "n_c": 3, + "nonparallel_factors": true, + "quotient_minor_rank_mod3": 6, + "rank_P": 9, + "rank_Q": 11, + "t": 3, + "term_costs": [ + 1, + 7, + 7, + 7, + 7, + 0, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "weights": [ + 7, + 7, + 7, + 7, + 1, + 8, + 9, + 9, + 9, + 8, + 8 + ] + } + ], + "scope": "nonempty-marked-actual-d2-controls-not-sharpness" + }, + "actual_factorization_controls": { + "cases": [ + { + "actual_cost": 71, + "basis_weights": [ + 7, + 7, + 1, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "code_intersection_dimension": 1, + "exact_Gram_entries": 12544, + "factor_nonparallel": true, + "invoice": 71, + "losing_indices": [ + 2 + ], + "low_qualifying_digest": "7b674dbfeb8ac8fc5ec9acc7124080191782da0e893377da5b9840d16f2c2e0a", + "low_root_strata": 1440, + "low_space_dimension": 3, + "n_c": 0, + "pivot_cost": 1, + "rank_P": 9, + "rank_Q": 10, + "t": 2, + "term_costs": [ + 1, + 7, + 7, + 0, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "unit_roots": [ + 43 + ] + }, + { + "actual_cost": 72, + "basis_weights": [ + 7, + 7, + 1, + 1, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "code_intersection_dimension": 1, + "exact_Gram_entries": 12544, + "factor_nonparallel": true, + "invoice": 72, + "losing_indices": [ + 2 + ], + "low_qualifying_digest": "7b674dbfeb8ac8fc5ec9acc7124080191782da0e893377da5b9840d16f2c2e0a", + "low_root_strata": 2880, + "low_space_dimension": 4, + "n_c": 0, + "pivot_cost": 1, + "rank_P": 9, + "rank_Q": 11, + "t": 3, + "term_costs": [ + 1, + 7, + 7, + 0, + 1, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "unit_roots": [ + 43, + 49 + ] + } + ], + "root_direction_rigidity_premise": "support-at-most68-is-below70", + "scope": "nonempty-actual-d1-consumer-controls-not-sharpness" + }, + "consumed_source_sha256": { + "SOURCES.json": "4c978c34ca183a1193168e2f113390259589ddb31959a60b97c72ed3213ba76a", + "inputs/pr3154/land_e2_k8.out": "35f5413be06664509d82ffa290eddf1b5182b6c8b292b83b8a8697781465ee87", + "inputs/pr3154/land_e3_k8.out": "72d5c61eb46b09fc85f3d1996220aa0dba9ed157b6ce21594703f655d3e1a037", + "research/one-sided-decoders-all-m/data/data.json": "8e4b2a306dfe3499b9d2104753a4cb203e14fbfa94fda03f6a415da956ba642b", + "research/p112-root-simplex-exclusion/geometry.py": "b8ac379e41f5ad83bdb6c7f7c55129fc3d9c07801ea61591478f25d72ff0b021" + }, + "controls": { + "five_site_positive": true, + "full_E8_missing_frame_sites": 4, + "omitted_live_root_rejected": true, + "quadric_hyperplane_maxima": { + "minus": 6, + "plus": 4 + }, + "self_omission_exact_defect": 1, + "slack9_outside_four_site_gate": true, + "typed_receipt_and_strict_json": true, + "wrong_coefficient_rejected": true, + "wrong_completion_orientation_rejected": true + }, + "finite_inputs": { + "affine6_sections": { + "cardinality_histogram": { + "24": 5355, + "28": 16320, + "32": 16065, + "36": 5440 + }, + "completion_digest": "7600cacf1cb70437cbd4f4db7915fded7ae22a11e825c95490f7cb4c8555076c", + "count": 43180, + "qualifying29": 6216 + }, + "callers": [ + { + "d": 1, + "slack": 7, + "t": 2, + "weights": [ + 7, + 6, + 2 + ] + }, + { + "d": 1, + "slack": 8, + "t": 2, + "weights": [ + 7, + 6, + 3 + ] + }, + { + "d": 2, + "slack": 6, + "t": 2, + "weights": [ + 7, + 7, + 6, + 2 + ] + }, + { + "d": 2, + "slack": 7, + "t": 2, + "weights": [ + 7, + 7, + 6, + 3 + ] + }, + { + "d": 1, + "slack": 7, + "t": 3, + "weights": [ + 7, + 6, + 1, + 1 + ] + }, + { + "d": 1, + "slack": 8, + "t": 3, + "weights": [ + 7, + 6, + 2, + 1 + ] + }, + { + "d": 2, + "slack": 6, + "t": 3, + "weights": [ + 7, + 7, + 6, + 1, + 1 + ] + }, + { + "d": 2, + "slack": 7, + "t": 3, + "weights": [ + 7, + 7, + 6, + 2, + 1 + ] + }, + { + "d": 2, + "slack": 8, + "t": 3, + "weights": [ + 7, + 7, + 6, + 2, + 2 + ] + } + ], + "core_sections": { + "aggregate_histogram": { + "0": 3780, + "12": 362880, + "16": 56700, + "8": 56700 + }, + "forms_per_pair": 127, + "pairs": 3780, + "uniform_sharpness": { + "cover_digest": "94f0cf9c2228a5109091f76f2bb506b2bffc85dc1268bcb016748bba228e4b04", + "covers_per_frame_word": 945, + "covers_per_nonframe_word": 3, + "eight_site_covers": 7560, + "extra_orthogonal_roots": 3, + "five_site_covers": 336, + "frame_words": 8, + "nonframe_small_flat_roots": 8, + "nonframe_small_flats": 336, + "nonframe_words": 112, + "partition_ranks": [ + 7, + 6, + 4 + ] + } + }, + "d2_profiles": { + "4:24": { + "actual_profiles": [ + [ + 7, + 7, + 7, + 1 + ], + [ + 7, + 7, + 7, + 2 + ], + [ + 7, + 7, + 7, + 3 + ] + ], + "examined": 203, + "intrinsic_exclusions": [ + [ + 7, + 7, + 5, + 5 + ], + [ + 7, + 7, + 6, + 4 + ] + ] + }, + "5:25": { + "actual_profiles": [ + [ + 7, + 7, + 5, + 4, + 1 + ], + [ + 7, + 7, + 5, + 4, + 2 + ], + [ + 7, + 7, + 5, + 5, + 1 + ], + [ + 7, + 7, + 6, + 3, + 1 + ], + [ + 7, + 7, + 6, + 3, + 2 + ], + [ + 7, + 7, + 6, + 4, + 1 + ], + [ + 7, + 7, + 7, + 1, + 1 + ], + [ + 7, + 7, + 7, + 2, + 1 + ], + [ + 7, + 7, + 7, + 2, + 2 + ], + [ + 7, + 7, + 7, + 3, + 1 + ] + ], + "examined": 386, + "intrinsic_exclusions": [ + [ + 7, + 6, + 6, + 5, + 1 + ] + ] + } + }, + "four_axes": { + "block_multiplicities": { + "four": 1, + "pair": 8, + "zero": 8 + }, + "block_sets": 14, + "nonblock_multiplicities": { + "pair": 4, + "singleton": 8, + "triple": 2 + }, + "nonblock_sets": 56, + "sets": 70 + }, + "frame_plane": { + "all_one_point_deletions_preserve_rank": true, + "case_digest": "1491c229e6168bd24a26a9b28447d31d08684754e5a8222f03e883da4cccd465", + "cases": 42840, + "minimum_deleted": 34, + "rank": 8 + }, + "frame_sign_halves": { + "binary_rank": 7, + "case_digest": "f9b5e7ffab8c58b2f1743d72f8cc28b9a4d8203fb777d00427f3e5ae2f767a3e", + "frame_pairs": 28, + "half_points_per_fiber": 2, + "half_size": 12, + "radical_fibers_per_pair": 6, + "sign_halves": 56 + }, + "invoice_profiles": { + "3:16": { + "examined": 73, + "survivors": [ + [ + 7, + 7, + 1 + ], + [ + 7, + 7, + 2 + ] + ] + }, + "4:16": { + "examined": 114, + "survivors": [ + [ + 7, + 7, + 1, + 1 + ] + ] + }, + "4:17": { + "examined": 130, + "survivors": [ + [ + 7, + 5, + 4, + 1 + ], + [ + 7, + 6, + 3, + 1 + ], + [ + 7, + 7, + 1, + 1 + ], + [ + 7, + 7, + 2, + 1 + ] + ] + } + }, + "pencil_callers": { + "application_digest": "0b602350ab7d75d2f792be235c01aa8c136e7b13e9ae79600930f997acec244a", + "shared_frame_7755": [ + [ + 2, + 2, + 8, + [ + 7, + 7, + 5, + 5 + ] + ], + [ + 2, + 3, + 7, + [ + 7, + 7, + 7, + 5, + 5 + ] + ] + ], + "t2": 2, + "t3": 83, + "total": 85 + }, + "quotient6": { + "4": { + "10": 336, + "4": 315, + "6": 1008, + "8": 945 + }, + "5": { + "12": 63, + "16": 63 + } + }, + "root764": { + "c28_digest": "a8f158a546373f1753b1c093eb6fbfaa9b6175f69e1d541c8001bb060300ccc1", + "c28_section_histogram": { + "0": 1, + "12": 63, + "16": 63 + }, + "c28_sections": 12000, + "root_high_pairs": 15360 + }, + "root_inventory": { + "frame": 8, + "full": 120, + "live": 112 + }, + "root_planes": { + "a2_active_axes": { + "4": 224, + "6": 896 + }, + "distinct_planes": 4900, + "plane_digest": "f2d3dcc95790f37884e28bc2078c9c3ddc7e24dd16773e9f62135f62fadbfa70", + "root_line_histogram": { + "2": 3780, + "3": 1120 + }, + "root_pairs": 7140 + }, + "witness": { + "ranks": [ + 4, + 6, + 7 + ], + "sizes": [ + 5, + 16, + 32 + ], + "slack9": { + "code_rank": 8, + "cost": 17, + "joint_rank": 11, + "pieces_rank": 4, + "ranks": [ + 7, + 6, + 3, + 1 + ], + "sizes": [ + 32, + 16, + 4, + 1 + ] + }, + "sparse_indices": [ + 0, + 2, + 3, + 12, + 13 + ] + } + }, + "independent_engine": { + "annihilator_directions": 10795, + "coordinate_method": "independent root polar-pairing basis", + "full_completions": 7560, + "old_label_transfer": [ + 1, + 96, + 212, + 426, + 462, + 156, + 388, + 490, + 260 + ], + "section_method": "ordinary-dot left-pivot RREF annihilators", + "simple_label_transfer": [ + 1, + 2, + 128, + 384, + 64, + 160, + 80, + 40, + 22 + ], + "source_hashes": { + "data": "8e4b2a306dfe3499b9d2104753a4cb203e14fbfa94fda03f6a415da956ba642b", + "geometry": "b8ac379e41f5ad83bdb6c7f7c55129fc3d9c07801ea61591478f25d72ff0b021" + } + }, + "primary_engine": { + "ambient_gauss_sum": 16, + "chamber_receipt": { + "rank_six_parabolic_counts": [ + 21, + 21, + 12, + 12, + 15, + 21, + 30, + 16, + 13, + 12, + 13, + 16, + 21, + 12, + 10, + 10, + 12, + 16, + 10, + 8, + 8, + 10, + 13, + 12, + 13, + 21, + 21, + 36 + ], + "ray_zero_counts": [ + 42, + 28, + 22, + 14, + 16, + 23, + 37, + 63 + ], + "root_support_histogram": { + "53": 112, + "56": 8 + }, + "simple_reflection_checks": 960 + }, + "full_ordered_completions": 7560, + "polar_rank": 8 + }, + "schema_version": 1, + "scientific_sha256": { + "CALLERS.md": "21b6f87004b64ceddfb82010840be41474730189fe4bc2dcfcc8e8560e244003", + "D1.md": "e51383e4e3c53e958b1c5a20c10a4325c150e270d9abc63a26353123c9049ccb", + "D2-PROFILE.md": "8916be70f5f9425f345a33537e8c06c6ba42564d707974d916fe1fc6564e97df", + "D2.md": "f355dbee2bc1fdd1fbe531ca6a1ac900b46c6ce29f364ce0cd3701d1fb573ff5", + "FORMAL.md": "c4de0857c063e03d423658861b0e0c9add198abd4c97aae196e274622b5f8ff7", + "NOTICE.md": "26bea19e600f3b953d9b1debe74d6c975daf4eb4d7223fc7bb86ff1a0b6a85fe", + "PROOF.md": "d1a611aa76c42f578ff139e5a6b6d509afc522f570d44a25079309ee431577a9", + "RAW-SHAPE.md": "75da77b922de5ba8a149a48ea05740733cdfbf472a56bd154533d6ffe8ebf996", + "README.md": "5fcc3cce62e6e4a38270c814ba5b6d2a8aa0fa444fdccc2e683bf18872099e52", + "RIGIDITY.md": "b184f2939573d2de62445fee950a948beae3fd7726ec77eb710a8502d26ef503", + "UNIFORM.md": "e037a0a85373f4c2c112e1bb6f7ada4bc040f830b511f3ff5f9292d20cd38137", + "actual_controls.py": "3a6f59675f20d54fd58523266db660ab49a34461fc4375c4bbb2ecd46d055458", + "controls.py": "f9d3c13541e3ec3f45f9ad0ea3cec38521a9418c0d0c071091fd8ef928a05b3f", + "d2_controls.py": "2819755f899e0bf54f614eb0c6ed4e902dc9b9ec86d9a844f242ada2e1bb9b3f", + "formal/DimensionDeletion.lean": "62000af5d0f465277f5caad7c959292f7b56a1f84a4d4661ce3bce795ea74970", + "formal/QuarterCore.lean": "478d519f892444e7f133374dc07b49ff4573c0c07bfb3f8a49690cc19cbe8331", + "formal/SharedPiece.lean": "1e091eb416b17240d3d62d7148ab308a4100cd12434e1141f3fd9bb5743d3bbd", + "independent.py": "174f91fd6c1af3d23598ff1252170795b788677c2bc425041f02225e3bca0275", + "independent_d2.py": "659737d9441d6474300611df917831e96d14b78c0f01551e04aa222b0054566c", + "inputs/pr3154/NOTICE.md": "802cbdd701c94b52c6cbb5d701807f3cc1d8fa8cbda3adf1c91e49d8a1ac256e", + "model.py": "c24811753c69b1424ba01bc160d2127591e28d0d1fd530854b82fbe5a7ad9c8c", + "test_package.py": "3d81d98dfac3cb3d4464a0827fb456656d1ce1893b7d517a46b9b7ae9298c055", + "verify.py": "d7ee5b14a175b51472ba7184eb9a8f2814bbb0fe31b4d79aef41c7022a0993f3" + } +} diff --git a/research/p112-six-seven-supplement/RIGIDITY.md b/research/p112-six-seven-supplement/RIGIDITY.md new file mode 100644 index 0000000000..6dada52d0a --- /dev/null +++ b/research/p112-six-seven-supplement/RIGIDITY.md @@ -0,0 +1,261 @@ +# Intrinsic (7,7,6,4) and (7,6,6,5,1) exclusions + +Prepared by conorholds with substantial OpenAI Codex assistance. Apache-2.0. +The retained geometry and predecessor credits are those of +[PROOF.md](PROOF.md), [UNIFORM.md](UNIFORM.md), [D2-PROFILE.md](D2-PROFILE.md) +and SOURCES.json. These are written characteristic-zero proofs; finite +corroboration and partial formal cores are distinguished below. + +Use their E8/P112 roots, arbitrary orthogonal removed frame F, labels +ell(r)=(1,r mod 2L), characteristic-zero field K and root code C. + +## First theorem + +For independent pieces A,B,L,M of binary support ranks at most 7,7,6,4, +respectively, + + dim_K(C intersect span_K{A,B,L,M}) <= 1. + +The key statement is stronger than the sharp five-site supplement: every +actual coefficient representation of a root word by ranks (7,6,4) is one of +the sharp partitions, even though a rank-four support can have eight sites. +This statement is about a three-piece root representation; it does not +classify arbitrary covers with a genuinely arbitrary eight-site supplement. + +## 1. A root (7,6,4) cover forces a 32-root completion + +Let a root word C_v be supported in U7 union U6 union U4, where the U_i are +label spaces of the displayed dimensions. Its support has 53 live sites for +nonframe v and 56 for frame v. The high flat therefore carries at least +53-20-8=25 target sites. + +The leading-one section of U7 is an affine six-space H. If B(v,.) varies on H, +the nonself target slice is an affine five-space with at most 20 roots; self v +could add at most one. If it is constantly zero, only self could contribute. +Thus H is contained in B(v,x)=1. In particular the high flat misses self. The +signed quadratic calculation in PROOF.md Section 4 gives high-root section +size 24, 28 or 32. Size 24 is too small. + +If size 28 occurs, the parallel complementary section C28 has 28 roots and +nondegenerate six-dimensional direction space. Every affine hyperplane of this +section has at most 16 roots, by the Walsh calculation in UNIFORM.md Section +4. Hence a rank-six label space meets C28 in at most 16 roots. + +If v is frame, all C28 roots are live, but U6 and U4 cover at most 16+8=24. +This is impossible. If v is nonframe, at least 24 C28 roots are live, and self +v must be in one low flat. Self is outside the label span of C28. If self lies +in U6, the intersection rank drops to at most five, giving C28 capacity at +most 12+8=20. Otherwise self is in U4, whose intersection rank drops to at +most three, giving capacity at most 16+4=20. Again impossible. + +Consequently U7 is a 32-root completion X and its deleted quarter C24 has the +model Omega times R from UNIFORM.md Section 1. Here R has dimension two; Omega +consists of six points in an affine four-space, contains no affine plane, and +its affine hyperplane sections have size two or four. The quarter has label +rank seven and misses self v. + +## 2. Nonframe self cannot be in U6 + +Suppose v is nonframe and ell(v) is in U6. Then U6 intersects the quarter +label space in rank at most five, so its quarter capacity is at most 12. U4 +has capacity at most eight. The live quarter has at least 20 roots. Equality +is necessary: all four frame neighbors of v lie in C24, and the two low flats +cover disjoint live quarter sections of sizes 12 and 8. + +An eight-root rank-four quarter section is exactly two complete radical +fibers. To see this, its affine dimension is at most three. Projection +dimension zero gives at most four roots; dimension two gives at most 3*2=6 +roots because Omega has no plane; projection dimension three gives at most +four. Thus eight requires a one-dimensional projection and the full +two-dimensional radical. + +Likewise a twelve-root rank-five quarter section is exactly three complete +radical fibers. Its affine dimension is at most four. Projection dimensions +zero or one give at most eight roots; dimension three gives at most 4*2=8; +dimension four gives at most six. Thus twelve requires projection dimension +two and full radical fibers, with three Omega points in the projected affine +plane. + +The four deleted frame roots form an affine plane in C24. Its direction is +totally singular, whereas q on R is nonzero, so its intersection with R has +dimension at most one. Its projection cannot be a plane inside Omega. Thus it +projects onto exactly two Omega points, with two deleted roots in each fiber. +There are only four unpunctured fibers. The disjoint twelve- and eight-root +live sections would require five distinct complete unpunctured fibers, a +contradiction. + +This proves ell(v) is not in U6. Self must therefore be in U4. + +## 3. The actual nonframe coefficient partition is forced + +Since self lies in U4 but outside the quarter label space, the quarter +capacity of U4 is at most four. Together with U6's quarter capacity 16, +covering the at least 20 live quarter roots forces equality. All four frame +neighbors lie in C24; U6 contains exactly sixteen live quarter roots; U4 +supplies the other four. + +UNIFORM.md Section 1 identifies the sixteen-root section as a full lift of a +four-point affine hyperplane section of Omega. It spans U6, so all full-root +labels in U6 are these sixteen roots Y. The omitted pair of Omega points lifts +to an affine three-space of eight roots. The deleted frame plane is one affine +plane inside this space, and its four remaining points are the complementary +parallel affine plane E4. Thus E4 has label rank three. The high section X has +no deleted frame roots, since all four frame neighbors lie in C24. + +Because ell(v) is outside the quarter label space, the labels of E4 and self +span U4 in dimension four. Their intersection with the root-neighbor label +hyperplane B(v,x)=leading_bit is exactly span ell(E4). Accordingly U4 has no +further neighbor roots. Any additional root labels in U4 are orthogonal to v. +In an actual coefficient representation + + C_v = alpha A + lambda L + mu M, + +with support ranks 7,6,4, these extra sites of M must have coefficient zero: A +and L are supported entirely in B(v,x)=1, whereas C_v vanishes there. Every +displayed coefficient is nonzero, since deleting any piece leaves root-target +capacity at most 32+20=52. + +The representation therefore has the exact disjoint support partition + + supp(A)=X32, supp(L)=Y16, supp(M)=E4 union {v}, + +and each scaled piece is the restriction of C_v to its support. This is +precisely the nonframe sharp partition of UNIFORM.md. + +## 4. The actual frame coefficient partition is also forced + +For frame v the whole C24 is live. Its cover by U6 and U4 has capacities 16 +and 8, so equality forces disjoint full sections of those sizes. The rank-six +section is a full lift of four Omega points, and its complement is the full +lift of the omitted pair, an affine three-space of eight roots. These root +sets span their entire respective label spaces, so neither low piece has any +additional root sites. The high piece is the disjoint X32 restriction. +Therefore the exact actual partition is + + supp(A)=X32, supp(L)=Y16, supp(M)=E8. + +This is the frame sharp partition of UNIFORM.md. In particular a shared +rank-four actual piece in a nonframe representation has exactly five support +sites, and in a frame representation exactly eight. + +## 5. Two-dimensional code intersection is impossible + +Suppose a two-dimensional code subspace D lies in the span of independent +A,B,L,M. Restrict the A and B coefficient functionals to D. Their joint kernel +is zero, since a codeword supported on L and M has at most 28 sites, below +distance 53. Thus their two one-dimensional kernels are distinct. Killing +either high coordinate leaves support size at most 36+20+8=64<70; root +rigidity makes the two kernel words scalar root words C_a and C_b in distinct +root directions. Relabeling the highs, write + + C_a = alpha A + lambda L + mu M, + C_b = beta B + lambda' L + mu' M. + +All six coefficients are nonzero: each root word has at least 53 sites, and +deleting a low piece leaves target capacity at most 52; the high coefficient +is nonzero by injectivity of the pair of high coordinates. + +If exactly one of a,b is frame, Sections 3--4 force the same actual piece M to +have support size both five and eight, impossible. + +If both are nonframe, Section 3 forces M to contain both self sites a,b, and +the ratio C_b/C_a is the fixed nonzero scalar mu'/mu on its support. If a and +b are orthogonal this ratio is zero at a, impossible. Otherwise, after signs, +(a,b)=epsilon in {+1,-1}. Its values at the two self sites are epsilon/2 and +2/epsilon, which are unequal in characteristic zero. Again impossible. +Root-representative signs cancel from these ratios. + +If both are frame, Section 4 puts the sixteen-site support of L inside their +common 24-root quarter, and C_b/C_a is constant there. The two ratio classes ++1 and -1 in that quarter have twelve roots each, as proved in D2-PROFILE.md +Sections 3--4. A constant-ratio set cannot have sixteen sites. This is the +last contradiction. + +## 6. A six-dimensional plus quadric has affine-four capacity ten + +The affine quadratic quotient used below has nondegenerate polar form in +dimension six and signed sum +8, hence 28 one-points. Its affine-five sections +have capacities twelve or sixteen: the nonzero linear Walsh coefficients are ++8 or -8, and splitting the ambient sum gives section signed sums zero or +8. + +For an affine-four section a+H, the polar restriction to H has rank four or +two; its radical has dimension at most two by ambient nondegeneracy. Rank four +gives signed sum +/-4 and thus at most ten one-points. For rank two put +R=rad(H), dim R=2; necessarily H=R-perp. If the affine quadratic function +varies on R, cancellation gives eight one-points. Otherwise a+H is the unique +parallel H-coset on which the radical character vanishes: all other parallel +cosets cancel. Its signed sum is therefore the full ambient +8, giving four +one-points. In particular the putative twelve-point negative-sign case is +impossible. This proves the sharp capacities ten and sixteen without a flat +census. + +Both exact engines separately check all 2,604 affine-four sections and 126 +affine-five sections of q=x1*x2+x3*x4+x5*x6. Their histograms are respectively +{4:315,6:1008,8:945,10:336} and {12:63,16:63}. + +## 7. Second theorem: intrinsic (7,6,6,5,1) + +For any independent five pieces of support ranks at most 7,6,6,5,1, their span +meets C in dimension at most one. This permits overlap and cancellation in the +original family. + +Otherwise choose a two-dimensional code intersection and kill the seven-piece +coordinate. A nonzero codeword remains in pieces of ranks 6,6,5,1, with total +support capacity 20+20+12+1=53. Root rigidity forces a nonframe root word C_v: +a frame needs 56 sites and a nonroot at least 70. Equality forces all four +coefficients nonzero and the four actual supports to be disjoint, wholly +inside Off(v), of sizes 20,20,12,1. + +Self cannot belong to a twenty-site piece. Containing self reduces its +neighbor-intersection rank to at most five, hence its target capacity to +12+1=13. Similarly a rank-five piece containing self has target capacity at +most 8+1=9, rather than twelve. Thus the unit piece is exactly self. + +On the affine seven-space B(v,x)=1, translation by v preserves q since +q(x+v)=q(x)+q(v)+B(x,v)=q(x). Quotienting by this direction turns the 56-root +neighborhood into the six-dimensional nondegenerate affine quadric with 28 +roots and signed sum +8 of Section 6. + +Each twenty-site piece spans an affine five-space, and the twelve-site piece +spans an affine four-space: otherwise the smaller global capacities would +preclude their sizes. If its direction omitted v, projection would inject its +roots into an affine-five or affine-four quotient section. The capacities +sixteen and ten exclude these possibilities. Each piece's direction therefore +contains v. Saturation of the global 20/20/12 capacities also says its actual +support is the complete full-root section of its label span. Consequently each +support is stable under translation by v. + +Their union would make the punctured neighborhood N(v) minus F stable. But +every removed frame neighbor f has a live root partner f+v. It is a root by +q(f+v)=1; it is not another frame point, since f+v=f' would give +q(v)=q(f+f')=0 for distinct orthogonal frame roots. Thus a live neighbor would +translate to a removed one. This contradiction proves the theorem. + +## Verification and proof boundary + +The first theorem uses the actual coefficient partition, rather than assuming +that an arbitrary rank-four piece has only five sites. The eight-root closure +of every one of the 336 nonframe sharp covers has exactly the five target +sites plus three orthogonal sites; both engines check this explicitly. Actual +root representations must have zero coefficients on those extra sites, as +Section 3 explains. + +Both engines also examine all 15,360 root/high complementary cases, 12,000 +distinct 28-root sections, and every hyperplane restriction of each section. +The nonzero functional histogram is {0:1,12:63,16:63}, corroborating the cap +sixteen used to exclude the 28-root branch. These finite checks corroborate +the analytic proofs. The complete E8 instantiation and the assembly of both +intrinsic theorems remain outside Lean. No source-list completeness, N8 or +correction count is a premise. + +## Dimension-deletion consequences + +For an independent family with code intersection dimension d>=2, killing any +d-2 piece coordinates leaves a code intersection of dimension at least two in +the remaining span (CALLERS.md; formal/DimensionDeletion.lean). Thus, for +every d>=2, the first theorem excludes the T-level profile consisting of d +sevens followed by6,4. The second excludes d-1 sevens followed by6,6,5,1. +Coordinatewise smaller profiles are excluded as well. These are intrinsic span +exclusions. Deletion does not by itself preserve an actual basis or its +correction ledger, so no actual d>=3 invoice is claimed from these +corollaries. \ No newline at end of file diff --git a/research/p112-six-seven-supplement/SOURCES.json b/research/p112-six-seven-supplement/SOURCES.json new file mode 100644 index 0000000000..b3c5338f3f --- /dev/null +++ b/research/p112-six-seven-supplement/SOURCES.json @@ -0,0 +1,197 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/one-sided-decoders-all-m/data/data.json", + "usage": "input", + "git_blob": "2b799f9238d11018edb2aa6ac542024dfabcb1b3", + "sha256": "8e4b2a306dfe3499b9d2104753a4cb203e14fbfa94fda03f6a415da956ba642b" + }, + { + "path": "research/p112-root-simplex-exclusion/geometry.py", + "usage": "input", + "git_blob": "222ea556faf2b275f73815c4e7d0d5f1e3294f2f", + "sha256": "b8ac379e41f5ad83bdb6c7f7c55129fc3d9c07801ea61591478f25d72ff0b021" + }, + { + "path": "research/p112-root-simplex-exclusion/PROOF.md", + "usage": "provenance", + "git_blob": "ccae08212784114e732da1192b336e47fc6a2091", + "sha256": "2b5d70570e3a13d2ccc71c1fc7eef113f0d049993cb9bb24007166223ac7b734" + }, + { + "path": "research/e8-quadratic-support-capacity/PROOF.md", + "usage": "provenance", + "git_blob": "4da8e98edcfbbb9d5cd17b7ee921aa323d2fc724", + "sha256": "0a68df931e4da65a9568a5ad3731c2a6c6f6b6fca57839d7d4c12a6fba0b333e" + }, + { + "path": "research/e8-rank7-capacity/PROOF.md", + "usage": "provenance", + "git_blob": "a85d734bf81511139b7651b5d54b0e3fa8284df4", + "sha256": "96769d503752d6c1fb16ab3fb4fc456c62f623537385594dd88c1f87c3e3e2cf" + }, + { + "path": "research/one-sided-decoders-all-m/checks/cover761.py", + "usage": "provenance", + "git_blob": "f0bc5265bd515239b1a54a9a83c669a8a45bbdc3", + "sha256": "f5c252427d6612e7d27e2cf5e94d540116d7f5e5bc07fe1b150966a038544416" + }, + { + "path": "research/one-sided-decoders-all-m/README.md", + "usage": "provenance", + "git_blob": "614ff7397c3510ca740b09bf8846034fef16fa13", + "sha256": "7c22a8d73d8e2cf1ec9ce259035fe97be7261b0f71d5555ee50fc4b821872bf8" + }, + { + "path": "research/p112-four-piece-rank3/PROOF.md", + "usage": "provenance", + "git_blob": "0f778490ef327971eee50662f6e849ac09aa990a", + "sha256": "17ae621b09e6615765554af1230609fd72bf2183b5388d3ba850c5e8b59d77b6" + }, + { + "path": "formal/lean/lean-toolchain", + "usage": "provenance", + "git_blob": "980709bbbae28702ec58c368b84fdf6638093c63", + "sha256": "d24fed434d3b13adfaab57724a0a7f270ea8bf1c818b5ae5cf25cbce24dd685c" + }, + { + "path": "formal/lean/lake-manifest.json", + "usage": "provenance", + "git_blob": "36433bd6697cc16c39ff03acf97431386cb0f2c2", + "sha256": "702bd5bcfbf4a4739bea2e1cba72b471e8f0680520c67547f5daf3d0f26b6ddf" + }, + { + "path": "research/e8-marked-d0-invoice/PROOF.md", + "usage": "provenance", + "git_blob": "960aae5e0c1ac819af2aa4643e855360ea671c28", + "sha256": "c1f501f447bad9eba3500158f1d46e35d5f24aa3af8713b913fa4c8d5b8067db" + }, + { + "path": "research/e8-marked-d0-invoice/RAW-COUNT.md", + "usage": "provenance", + "git_blob": "ca31cfb78abe3b69ad360014f1563d548819e8a9", + "sha256": "8dff4309f8b66a8f4eba2dcc874865659e87f2d004e259bc0c504afdbcaccc2d" + }, + { + "path": "research/e8-marked-d0-invoice/CONSUMER.md", + "usage": "provenance", + "git_blob": "1b55bb3a29b9363da2560b3939ee037ac90f6081", + "sha256": "cead8459f18a647b52007f30acc019abfff09861c5408a040c437eff96c4d101" + }, + { + "path": "research/e8-d0-root-swaps/EXTENSION.md", + "usage": "provenance", + "git_blob": "99dc1c21b72e90e7669386d77506334900992286", + "sha256": "47f86fca33843bb2bc2b5ddbc07b91d846fe04952b8c133ff02dcbb9637b6357" + }, + { + "path": "research/p112-quotient-parity/PROOF.md", + "usage": "provenance", + "git_blob": "1d69dbd345365e8e28dcc9d789a6308bc5a6dcee", + "sha256": "2ddb0e19c26cffaee80e305c66834f6c927f07f0b4b970a29ce93b21b7753535" + } + ], + "retained_pr_sources": [ + { + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3154, + "author": "DreamingOfClouds", + "commit": "708f0ad8928c383de8294aea3c126e9461d2066d", + "original_path": "research/p112-reduction-to-conjectures/checks/CONJG2/land_e2_k8.out", + "retained_path": "inputs/pr3154/land_e2_k8.out", + "sha256": "35f5413be06664509d82ffa290eddf1b5182b6c8b292b83b8a8697781465ee87" + }, + { + "repository": "CrocSwap/integer-mult-bounds", + "pr": 3154, + "author": "DreamingOfClouds", + "commit": "708f0ad8928c383de8294aea3c126e9461d2066d", + "original_path": "research/p112-reduction-to-conjectures/checks/CONJG2/land_e3_k8.out", + "retained_path": "inputs/pr3154/land_e3_k8.out", + "sha256": "72d5c61eb46b09fc85f3d1996220aa0dba9ed157b6ce21594703f655d3e1a037" + } + ], + "references": [ + { + "path": "research/masked-root-star-assembly", + "author": "David Arias", + "role": "Predecessor E8 quadratic model, explicitly credited by PR3269; the model credit is preserved here." + }, + { + "pr": 2816, + "author": "DreamingOfClouds", + "head": "4c32ac3b88d63ad06d2b30e526aa07a12929db36", + "role": "Earlier one-extra-site (7,6,1) exclusion; its printed nine-site minimum is restricted by target-specific pruning." + }, + { + "pr": 3269, + "author": "Nick Petalas", + "head": "ebe02d33157dc6c6d3b35df204e4a39242b7429e", + "role": "Analytic full-root capacities 12 and 20 and the signed quadratic model." + }, + { + "pr": 3300, + "author": "Nick Petalas", + "head": "cd2cab515db136d7eb49242fc1111299f28a53a8", + "role": "Analytic rank-seven capacity 36 and affine-six section classification." + }, + { + "pr": 3418, + "author": "Nick Petalas", + "head": "370a2f5dd376f2c2686cf2ed3664aa30f59d6edc", + "role": "Adjacent four-piece sparse-four plus ranks5,6,6 obstruction; not a premise." + }, + { + "pr": 3455, + "author": "conorholds", + "head": "91a5a6b2734d2bf8d7ef701423544462e83b27d0", + "role": "Marked d=0 invoice; positive-d and raw slack-nine questions remain outside that result." + }, + { + "pr": 3166, + "author": "conorholds", + "head": "7c2a62363ad4945e8803fedea6ead78e1ad412b2", + "role": "Matched frame-plane no-coloop input; the present package recomputes all 42,840 cases by two different criteria." + }, + { + "pr": 3171, + "author": "Nick Petalas", + "head": "95b683196950efea6f3d7ac66745e00dba73425e", + "role": "Prior coordinate-kernel/root-plane method; credited for the four-six-plus-exceptions caller corollary." + }, + { + "pr": 3154, + "author": "DreamingOfClouds", + "head": "708f0ad8928c383de8294aea3c126e9461d2066d", + "role": "Original actual-basis contract and marked C1 handoff. These manuscript references are not runtime inputs or a reliance on source-list completeness.", + "notes": [ + { + "path": "research/p112-reduction-to-conjectures/checks/CONJ-G/NOTES.md", + "git_blob": "fe45a56747f1bf91805e79283abe5c4279d9acae", + "sha256": "8609121fe3d6c0fbab5c2fbdfbd87fffb20a91452f1d3bcc3d0697a9b3dfabf8", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/708f0ad8928c383de8294aea3c126e9461d2066d/research/p112-reduction-to-conjectures/checks/CONJ-G/NOTES.md" + }, + { + "path": "research/p112-reduction-to-conjectures/checks/CONJG2/NOTES.md", + "git_blob": "6de90e8f0f0d80cad1c1228d8cd3f19d8f1569be", + "sha256": "0e2a78bd38f68fcfbf922c6eb6485b7f114c856a0db416d8f6823c5ebdc67740", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/708f0ad8928c383de8294aea3c126e9461d2066d/research/p112-reduction-to-conjectures/checks/CONJG2/NOTES.md" + } + ] + } + ] +} diff --git a/research/p112-six-seven-supplement/TASK.json b/research/p112-six-seven-supplement/TASK.json new file mode 100644 index 0000000000..c3067981b8 --- /dev/null +++ b/research/p112-six-seven-supplement/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "changed", + "actual_scope": "Uniform sharp P112 six/seven-flat bounds and optimal-cover classification; complete actual d=1 and d=2 marked/unmarked invoices and the stated singleton-pivot consumer for t=2,3; intrinsic 7755,7764 and 76651 exclusions; nine direct and 85 credited historical pencil-profile implications. Also removes all positive-d threshold-dimension defects under the raw budgets and I<=64, without assuming adaptation or N8. At d3, excludes all actual defects r>=2 and every nonadapted eta=r branch; adapted and r1 extra-surplus cases remain.", + "scope_change_reason": "The user selected a live C1 mathematical handoff after a full overlap/source scouting hour. This is a scoped geometric theorem, not the original card's full changed-rank supplier.", + "bottleneck_link": "Closes the actual d=1 and d=2 C1 invoices, including nonadapted bases, corrected weight-nine members and the t3 raw slack-nine boundary. The intrinsic coefficient and radical-fiber obstructions remove the last d2 minimum profiles. Actual d>=3 and global rank/pivot normalization remain open.", + "budget_minutes": 60, + "stop_rule": "Stop if a valid four-site cover is found, a source-complete predecessor subsumes the theorem, or the completion/quarter proof fails. Finish one theorem, its named callers, bounded independent verification and local audit; no upstream action.", + "outcome": "completed", + "evidence": "Written d=2 proofs and two skeptical read-only AI reviews cover all actual t=2/t=3 cases. Two exact geometry engines agree on the retained inventories, 12,000 complementary 28-root sections, 2,604 six-quadric affine-four sections, 70 four-axis inventories and 589 minimum profiles. Two marked actual d=2 controls certify complete low spaces and exact Gram factorizations, including three corrected weight-nine members each. Seventeen unchanged Mathlib declarations retain their prior checks; two new Init-only algebraic declarations pass under 256 MiB. Full replay and exact publication-artifact checks are recorded in the local draft. A separate full-matrix F5 implementation independently replays both d2 low-space certificates. A further twice-reviewed actual boundary-profile argument removes all positive-d threshold-dimension defects under the raw budgets and I<=64; raw budget alone suffices through d=6 for both t2/t3. It does not force adaptation or settle higher-d invoices. A further two-reviewer transfer closes d3 actual defects r>=2 and nonadapted eta=r, without identifying L with global T.", + "author": "conorholds", + "ai_assistance": "Substantial OpenAI Codex assistance, including GPT-6.1 SOL agents at xHigh reasoning. Internal AI reviews are not independent human certification.", + "open_questions": [ + { + "question": "Formalize the E8/label-to-quadratic normal-form and root32-completion bridge.", + "why_it_matters": "This would connect the concrete core16 and abstract sparse-cover Lean theorems to the full P112 theorem.", + "first_step": "Define the affine quadratic isomorphism and its action on leading-one root labels.", + "blocked_by": "The current complete bridge and root classification are handwritten, not Lean declarations." + }, + { + "question": "Resolve actual C1 invoices for d>=3 and validate the global rank/pivot reduction.", + "why_it_matters": "The complete d1 and d2 invoice theorems still do not cover higher code intersections or every physical factorization class.", + "first_step": "Start with d3 full threshold dimension. Its actual r>=2 and nonadapted eta=r branches are now excluded. Resolve adapted r0 and r1 eta>1 while preserving actual coefficients and corrections.", + "blocked_by": "The full-threshold-dimension theorem does not force actual adaptation or prove the d>=3 invoices. T-level deletion does not preserve actual corrections automatically. Global rank/pivot normalization remains separate." + } + ], + "coordination": { + "status": "LOCAL-ONLY; no Discussion post or claim because the donor prohibits upstream writes before final approval", + "canonical_thread": "https://github.com/CrocSwap/integer-mult-bounds/discussions/3156", + "main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "entry_snapshot": { + "open_prs": 326, + "discussions": 2444, + "closed_prs": 2959, + "through_utc": "2026-10-18 09:09:54 UTC", + "complete_pagination": true + }, + "overlap_limits": "Titles/bodies, Discussion records and relevant exact source inspections; arbitrary diffs and unpublished work are not exhaustively covered.", + "extension_overlap": { + "through_utc": "2026-10-18 13:30:00 UTC", + "main": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "coverage": "Latest 100 updated all-state PRs: 50 updates since 10:20 UTC. Latest 100 Discussion records; complete 3156 and 1163 comments/replies; latest 100 of 573 handoff comments with replies. PR3154 head is unchanged.", + "adjacent_work": "PR3632 concerns physical P112 scatter/restoration; PR3625 a lost-free plane-port size bound; PR3604 tetrad coefficient fusion; PR3639/3643 named-class C5 charging. PR3658 five-cell block-basis floor is a different problem. Discussion3622 screens other labels/line systems. None supplies this actual d2 invoice in the inspected material.", + "conclusion": "No matching completion or active C1 claim in the inspected delta; bounded, non-atomic metadata and exact-target review, not a novelty guarantee." + } + }, + "budget_extension_reason": "The donor explicitly requested another full hour beyond the frozen d1/profile candidate. This extension closes both actual d2 invoices and their last intrinsic profile obligations, with bounded finite checks and skeptical reviews. The user interruption/pause is excluded from active research time. No upstream write is authorized." +} diff --git a/research/p112-six-seven-supplement/UNIFORM.md b/research/p112-six-seven-supplement/UNIFORM.md new file mode 100644 index 0000000000..74bfd870ad --- /dev/null +++ b/research/p112-six-seven-supplement/UNIFORM.md @@ -0,0 +1,333 @@ +# Uniform sharpness and the five-site equality geometry + +Use the root, lattice, label and code conventions of [PROOF.md](PROOF.md). +In particular roots have squared norm two, an arbitrary orthogonal frame +`F` of eight root lines is removed, and `P` is the remaining 112 lines. +All support statements are unchanged by choices of signs for root representatives. +The coefficient field is any characteristic-zero field. + +The arguments below use the analytic support capacities 12/20/36, the +root-rigidity implication `|Off(h)|<70 => h is a scalar root direction`, +and the quadratic character identities proved or explicitly assumed in +PROOF.md. The standard real Weyl-chamber theorem and ADE root-system facts +remain inherited mathematical inputs. No additional census or executable +receipt is a premise of these extensions. + +For spaces of dimensions at most six and seven write + + e(h;U6,U7) = |Off(h) \ (Lambda(U6) union Lambda(U7))|. + +The following conclusions hold uniformly in the orthogonal frame. + +* If `h` is a scalar nonframe-root direction, then `e>=5`, and five is + attained. Every such root has exactly three pairs `(U6,U7)` attaining five. +* If `h` is a scalar removed-frame-root direction, then `e>=8`, and eight + is attained. Every frame root has exactly 945 pairs attaining eight. +* If `h` is not a scalar root direction, then `e>=14`. Sharpness of fourteen + is not asserted. + +The first bound is the theorem of PROOF.md. The new assertions here are its +uniform sharpness, the equality description, and the two normal-type bounds. +These statements do not assert priority over all earlier unpublished work. +PR2816 already records the numerical three large seven-sections for each +nonframe-root target; the arguments below identify the complete five-site +equality pairs and their intrinsic geometry. + +## 1. The 24-root quarter and its four-dimensional quotient + +Let `v,w` be distinct orthogonal root lines, represented by roots, and put +`u=v+w` in `V=L/2L`. Thus + + q(v)=1, q(u)=0, B(v,u)=0, u!=0. + +Define the two affine six-spaces + + X = {x : B(v,x)=1, B(u,x)=1}, + A_C = {x : B(v,x)=1, B(u,x)=0}. + +Their root sections have 32 and 24 points, respectively. Write `C` for the +24-root section. The full nonself neighborhood of `v` is their disjoint +union. This is the completion and quarter calculation in PROOF.md. + +The direction space of `A_C` is `H=^perp`. Its polar radical is +`R=`, of dimension two. For `x in A_C`, translation by either radical +generator preserves the value of `q`: + + q(x+v)+q(x) = q(v)+B(x,v) = 1+1 = 0, + q(x+u)+q(x) = q(u)+B(x,u) = 0. + +Consequently `q` descends to an affine quadratic function `Q` on the +four-dimensional affine quotient `A_C/R`. Its polar form is nondegenerate. +The signed sum on `A_C` is 16, and every quotient fiber has four points, +so the quotient signed sum is `+4`. Thus `Q` has exactly six value-one +points. We call this six-point set `Omega`. This description of the plus +four-dimensional quadric includes its sign; only nondegeneracy and that +positive signed sum are used below. + +### No affine plane lies in Omega + +Suppose an affine plane `a+T` of dimension two had constant value one. +Polarization makes `T` totally isotropic. Nondegeneracy in dimension four +then gives `T^perp=T`. The restriction of the quadratic function to every +coset of `T` is a constant times a character of `T`. Precisely one coset +has trivial character: the other cosets cancel in its signed sum. The +coset `a+T` is that coset, and contributes `-4`. The total signed sum would +therefore be `-4`, contrary to `+4`. Thus Omega contains no affine plane. + +### Fifteen four-point hyperplane sections + +For every nonzero linear functional on the four-dimensional direction +space, nondegeneracy gives a quadratic Walsh sum of absolute value four. +The signed character sum over Omega is consequently `+2` or `-2`. +The two parallel affine hyperplanes therefore meet Omega in two and four +points. There is one four-point side for each of the fifteen nonzero +functionals. + +Four distinct points of Omega cannot have affine span two, by the preceding +paragraph. Hence each four-point section spans its unique affine hyperplane +of dimension three. The fifteen sections are distinct. Their complements +are fifteen distinct pairs of points of Omega, so every pair occurs exactly +once, since `binomial(6,2)=15`. + +Lifting a four-point section gives sixteen roots of C in an affine +five-space, and lifting its omitted pair gives eight roots in an affine +three-space. All sixteen-root sections have binary support rank six: +their label rank is at most six, and sixteen exceeds the rank-five +capacity twelve. + +Conversely, every rank-six label space meeting C in sixteen roots is one +of these lifts. Indeed, C spans its seven-dimensional label space `W_C`. +A sixteen-point intersection has rank at least six, again by capacity +twelve, so the rank-six space is contained in `W_C`. Its leading-one +section is an affine hyperplane of `A_C`. If its defining functional were +nonzero on R, it would keep exactly two points from each of the six root +fibers and contain only twelve roots. Thus the functional descends to +the quotient, where its section must be one of the fifteen four-point sides. + +## 2. Uniform attainment for every nonframe root + +Let `v` be a root outside the removed frame. Exactly four frame roots have +nonzero pairing with v. Choose signed representatives `f1,...,f4` and signs +`epsilon_i` so that + + v = (epsilon_1 f1 + epsilon_2 f2 + + epsilon_3 f3 + epsilon_4 f4)/2. + +This follows from orthogonality of the frame and the identity +`sum_(f in F) ^2=4`: the four nonzero pairings are `+1` or `-1`. +Flip exactly two signs, for example set + + w = v - epsilon_3 f3 - epsilon_4 f4. + +The vector w belongs to L, has squared norm two, and is orthogonal to v. +It is therefore a root. Set `u=v+w` and use X and C from Section 1. +For each of the four frame neighbors, + + B(v,f_i)=1, B(w,f_i)=1, B(u,f_i)=0. + +Thus all four deleted neighbors lie in C, and none lies in X. The other +four frame roots have `B(v,f)=0` and lie in neither section. In particular +all 32 roots of X are live. + +The four distinct residues of `f1,...,f4` sum to zero: modulo `2L`, signs +are irrelevant and the signed sum is `2v`. They form an affine plane in +`A_C`. Its image in `A_C/R` has dimension at most one, since Omega has no +affine plane. Choose a pair of Omega containing that image, and take the +four-point hyperplane section whose omitted pair it is. Its lift Y has +sixteen roots and avoids all four deleted frame neighbors. All of Y is live. + +In fact the frame plane projects onto exactly two quotient points. Let D +be its two-dimensional direction space. Every nonzero vector of D is the +sum of two orthogonal frame roots and has q-value zero. But q on +`R=` is nonzero, since `q(v)=1`. Consequently `dim(D intersect R)<=1`; +the image of D has dimension at least one. Combined with the preceding +upper bound it has dimension exactly one. The omitted pair, and hence Y, +is therefore unique for this choice of X. + +The eight roots lifted from that omitted pair form an affine three-space. +The four deleted frame neighbors form an affine plane inside it. Its other +four points form the complementary parallel affine plane, consisting of +live roots. Call this four-point set E4. The complete live root-word support +is the disjoint union + + Off(v) = X disjoint-union Y disjoint-union E4 disjoint-union {v}, + sizes 32 16 4 1, + ranks 7 6 3 1. + +The first two ranks follow from capacities twenty and twelve. The four +points of an affine plane have leading-one label rank three. The self +label is outside `W_C` and outside the high section: `B(v,v)=0`, whereas +the leading-one points in both spaces satisfy `B(v,x)=1`. Hence +`E4 union {v}` has binary support rank four. This proves uniform attainment +five by a profile `(7,6,4)`, with sizes `(32,16,5)`. + +Give each part the actual coefficient `` of the root word at its +sites and zero elsewhere. These are characteristic-zero coefficient +identities on every live site, rather than support-only covers. Splitting +off the self site gives the disjoint profile `(7,6,3,1)` above. + +## 3. The sharp frame-normal supplement is eight + +Suppose v is one of the removed frame roots and at most seven sites remain +outside `U6 union U7`. Its support has 56 sites. Deleting the six-flat +and those seven sites leaves at least `56-20-7=29` sites in U7. +The completion theorem of PROOF.md therefore forces U7 to be a 32-root +completion X as above. Its complementary quarter C has 24 roots. +None of C is removed: every frame root has even pairing with v. A six-flat +meets C in at most sixteen roots. At least `24-16=8` sites therefore remain, +a contradiction. This proves the lower bound eight. + +To attain it, choose any other frame root w. The sections X and C from +Section 1 contain no frame roots, because all their points have `B(v,x)=1`. +Choose any of the fifteen sixteen-root lifts Y in C. Its complement E8 +in C is the lift of a pair in Omega, hence is an affine three-space of +eight live roots and has binary label rank four. Thus + + Off(v) = X disjoint-union Y disjoint-union E8, + sizes 32 16 8, + ranks 7 6 4. + +Restricting the actual root-word coefficients to these parts gives the +sharp frame-normal coefficient partition. No claim of sharpness for a +smaller binary rank of the eight-site part is made; its rank is exactly four. + +Both uniform constructions have a three-piece space of minimum basis cost +`7+6+4=17`; the nonframe split has four-piece minimum cost `7+6+3+1=17`. +For disjoint nonzero supports, the determinant-matching argument in +PROOF.md proves this minimum. Their code intersection is exactly one +dimensional: every codeword in the piece span vanishes on the live roots +perpendicular to v. There are respectively 59 or 56 such roots, exceeding +the rank-six root-system bound 36, so they span the seven-dimensional +perpendicular hyperplane. Its annihilator is the line of v. +Thus these are genuine intrinsic slack-nine spaces: `d=1`, cost seventeen, +with `t=2` for the three-piece spaces and `t=3` for the nonframe split. +They are not actual marked decoders. + +## 4. Every five-site equality cover has the preceding form + +Assume a nonzero codeword has exactly five uncovered sites outside U6 and +U7. Its total support is at most `20+36+5=61`, so root rigidity makes its +normal a scalar root v. Section 3 excludes a frame normal. Hence v is a +nonframe root and its support has 53 sites. + +After deleting U6 and the five uncovered sites, at least 28 target sites +remain in U7. They have label rank exactly seven, since a six-flat holds +at most twenty roots. Let A be the affine six-space of U7. If `B(v,.)` +varied on A, its value-one slice would be an affine five-space with at +most twenty roots; the self root could add at most one. A constant-zero +value would leave only that self root. Neither case holds 28 targets. +Therefore A is contained in `B(v,x)=1`. + +Write A using a second equation `B(s,x)=theta`, with s independent of v. +The character calculation of PROOF.md gives 24 or 32 roots when +`B(v,s)=0`, and 28 when `B(v,s)=1`. The first case cannot have 24 roots +because at least 28 targets remain. We next exclude the 28-root case. + +### The 28-root complementary section has six-flat capacity sixteen + +When `B(v,s)=1`, the direction space `^perp` is nondegenerate of +dimension six. The parallel section + + A' = {x : B(v,x)=1, B(s,x)=theta+1} + +also has 28 roots and signed quadratic sum `+8`. For every nonzero +functional on its direction space, nondegeneracy gives a Walsh sum of +absolute value eight. The signed sums on its affine hyperplanes are +therefore `(8+8)/2=8` or `(8-8)/2=0`. Their root counts are twelve or +sixteen. An arbitrary rank-six label space meets this 28-root section +in at most sixteen roots: intersect with its seven-dimensional label +span and enlarge to a hyperplane there if needed. + +At most four roots of A' can be deleted by the frame, since every one is +nonorthogonal to v. Thus at least 24 live roots in A' must be covered by +U6 and the five uncovered sites. Their combined capacity is at most +`16+5=21`, a contradiction. This excludes the 28-root case analytically. + +### Equality forces the full 32+16 partition + +Consequently U7 is a full 32-root completion X, with complementary C of +size 24. Let f be the number of deleted frame neighbors in C; `f<=4`. +If U6 contained the self label, its C-capacity would be at most twelve +by PROOF.md, leaving at least `24-f-12>=8` quarter sites uncovered. +It does not contain self. The uncovered count is therefore at least + + 1 + (24-f) - 16 = 9-f >= 5. + +Equality forces `f=4`, exactly sixteen live C roots in U6, and no deleted +frame root in that sixteen-root section. Section 1 identifies U6 with +the unique four-point quotient section avoiding the projected frame pair. +The uncovered set is exactly self plus the complementary live affine plane. + +There are exactly three possible high completions. Indeed, put `w=v+u` +for its associated orthogonal root. All four frame neighbors lie in C, +so `B(w,f_i)=1` for each. The frame norm identity for w forces its four +pairings there to be `+1` or `-1` and every other frame pairing to be zero. +Thus w has the same four-axis expression as v. Orthogonality requires +exactly two sign changes. Six choices of two signs become three root lines +after identifying w with -w. Conversely each such choice gives Section 2's +construction. Distinct w give distinct completions: the perpendicular +two-space has the unique nonzero singular vector u. Each completion has +the unique low section just proved. Hence exactly three `(U6,U7)` pairs +attain five for each nonframe root. + +This also describes any representation with support-rank bounds +`(7,6,3,1)`. Its small supports have union at most five sites, while the +main theorem requires at least five uncovered sites. They must be disjoint +and exactly fill the uncovered set. The rank-three piece occupies the +four-point affine plane and the singleton piece occupies self: a set +consisting of self and three quarter points would have rank four. +The high and low root sections are disjoint and contain only sites of +the root word. Thus cancellation outside that word is impossible, and +each of the four pieces is, up to its nonzero combination coefficient, +the restriction of the root word to its corresponding part. + +### Every frame-normal eight-site equality pair + +Suppose a frame root v has exactly eight uncovered sites. Deleting U6 and +those sites leaves at least `56-20-8=28` targets in U7. The same argument +forces its affine six-space into `B(v,x)=1`, with either 28 or 32 roots. +In the 28-root case its parallel complementary section has 28 roots, +all live, and six-flat capacity sixteen. It would leave at least twelve +sites uncovered, so that case is impossible. Thus U7 is a 32-root +completion, and its complementary quarter C has 24 live roots. Exactly +sixteen must be in U6. Section 1 gives precisely its fifteen quotient +hyperplane lifts; all are live because C has no frame roots. + +The possible completions are in bijection with the 63 root lines w +orthogonal to v. Equivalently, these are the 63 nonzero singular vectors +u perpendicular to v, by `w=v+u`. The root count 63 is the inherited E7 +perpendicular-root count. Distinct w determine distinct completions, +because u is the unique nonzero singular vector of ``. +There are consequently exactly `63*15=945` equality pairs per frame root, +or 7,560 across its eight directions. Their uncovered eight points always +form an affine three-space and have binary label rank four. + +## 5. Nonroot directions and caller scope + +For a normal that is not a scalar root direction, inherited root rigidity +gives `|Off(h)|>=70`. The two global capacities give the elementary bound + + e(h;U6,U7) >= 70-20-36 = 14. + +This bound is not claimed sharp. In particular, a cover with at most +thirteen extra sites forces a root direction; a frame direction requires +at least eight, and a nonframe direction requires at least five. + +The equality classification supplies a complete intrinsic geometric normal +form for the nearby `d=1`, `t=3`, cost-seventeen profile `(7,6,3,1)`. +Its feasibility is uniform, so it cannot be discarded by a stronger +unqualified support obstruction. A decoder application must additionally +use the actual coefficient maps, correction witnesses, restricted duals +and actual-basis surplus hypotheses. None of those follows merely from +this classification. No additional positive-d profile exclusion, marked +invoice floor, C1 completion, decoder floor, physical supplier or new +multiplication exponent is asserted here. + +Credit DreamingOfClouds for PR2816's code, cover/circuit framework and +three large target sections, and PR3154's caller context; Nick Petalas for +the retained PR3161/3162 geometry, PR3269/3300 signed-capacity arguments +and adjacent support work; David Arias for the earlier E8 quadratic model; +and joaqcoo and the retained E8/P112 lineage. New derivations in this +supplement are by conorholds with substantial OpenAI Codex assistance. +Internal analytic checking is separate from independent human review and +from a complete proof-kernel formalization. diff --git a/research/p112-six-seven-supplement/VERIFY.json b/research/p112-six-seven-supplement/VERIFY.json new file mode 100644 index 0000000000..5fe1c3ea4b --- /dev/null +++ b/research/p112-six-seven-supplement/VERIFY.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/one-sided-decoders-all-m/data/data.json", + "research/p112-root-simplex-exclusion/geometry.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Two exact geometry engines: all 43,180 affine six-spaces, 7,896 optimal root covers, 42,840 matched frame-plane no-coloop cuts and 4,900 root planes; complete invoice-profile arithmetic; nine direct and 85 credited pencil caller implications; two actual d1 factorization controls with full Gram/rank/cost and low-space checks. All 56 shared-frame coefficient-sign halves, radical-fiber multiplicities and two additional literal profile applications. Also all 12,000 complementary 28-sections, 2,604 six-quadric affine-four sections, 70 four-axis form inventories, 589 d2 minimum profiles and two marked actual-d2 factorization controls with full low-space certificates and corrected weight-nine terms." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/test_package.py" + ], + "timeout_seconds": 180, + "checks": "Sixteen actual optimized Git-free CLI control groups: nine scientific mutants including wrong actual pivot compensation, genuine engine disagreement, changed/linked or repinned sources, strict typed receipt and original-byte preservation. The additional d2 shear mutation fails actual restricted-dual expansion." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-Werror", + "-B", + "{package}/independent_d2.py" + ], + "timeout_seconds": 60, + "checks": "Independent reconstruction and full evaluation-matrix elimination over F5 on all 43,180 affine-six complements for each d2 fixture. No primary model or difference-elimination import. Exact low/code dimensions, source SHA256 binding, and a zeroed quotient-column rank-deficit control." + } + ] +} diff --git a/research/p112-six-seven-supplement/actual_controls.py b/research/p112-six-seven-supplement/actual_controls.py new file mode 100644 index 0000000000..0c490b582d --- /dev/null +++ b/research/p112-six-seven-supplement/actual_controls.py @@ -0,0 +1,185 @@ +"""Exact nonempty d=1 invoice/actual-consumer controls. + +conorholds, with substantial OpenAI Codex assistance. Apache-2.0. +The finite support strata certify the low space using the written <70 +root-direction rigidity argument; they do not enumerate arbitrary fields. +""" + +from fractions import Fraction + + +def run(model): + g = model.Geometry() + live = list(model.indices(g.live)) + position = {root: i for i, root in enumerate(live)} + frame = list(model.indices(g.frame)) + f0, w0 = frame[:2] + model.need(g.dots[f0][w0] == 0, "actual control frame pair changed") + xmask = g.neighbors[f0] & ~g.neighbors[w0] & g.live + cmask = g.neighbors[f0] & g.neighbors[w0] & g.live + model.need(xmask.bit_count() == 32 and cmask.bit_count() == 24, + "actual control quarter sizes") + + def word(normal): + return [Fraction(g.dots[normal][root], 4) for root in live] + + def unit(root): + return [Fraction(root == site) for site in live] + + def support(values): + return [g.labels[root] for root, value in zip(live, values) if value] + + def weight(values): + return model.rank(support(values)) + + def independent_rows(rows): + basis = {} + for value in rows: + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + break + return list(basis.values()) + + def term_cost(left, right): + rb = independent_rows(support(left)) + cb = independent_rows(support(right)) + matrix = [sum((((a & 1) * (b & 1)) ^ g.b(a >> 1, b >> 1)) << j + for j, b in enumerate(cb)) for a in rb] + return model.rank(matrix) + + def nonparallel(rows): + keys = [] + for row in rows: + first = next((value for value in row if value), None) + if first is None: + return False + keys.append(tuple(value / first for value in row)) + return len(keys) == len(set(keys)) + + cf0 = word(f0) + gx = [value if xmask >> root & 1 else Fraction(0) + for root, value in zip(live, cf0)] + bc = [value if cmask >> root & 1 else Fraction(0) + for root, value in zip(live, cf0)] + candidates = [root for root in model.indices(xmask) if g.dots[f0][root] == 4] + model.need(len(candidates) >= 2, "actual control lacks positive unit sites") + code = [word(normal) for normal in frame] + outside = [[Fraction(value, 2) for value in g.roots[root]] + for root in live if not (g.neighbors[f0] >> root & 1)] + model.need(model.rational_rank(outside) == 7, "actual control code intersection") + results = [] + + for t in (2, 3): + units = candidates[:t - 1] + uu = [unit(root) for root in units] + bx = [value - sum(u[i] for u in uu) for i, value in enumerate(gx)] + high = [] + high_normals = [normal for normal in frame if normal != f0] + for normal in high_normals: + original = word(normal) + high.append([value - sum(Fraction(g.dots[root][normal], 4) * u[i] + for root, u in zip(units, uu)) + for i, value in enumerate(original)]) + columns = [bx, bc] + uu + high + low = [bx, bc] + uu + expected_weights = [7, 7] + [1] * (t - 1) + [8] * 7 + weights = [weight(q) for q in columns] + model.need(weights == expected_weights, "actual d1 basis weights changed") + model.need(model.rational_rank(columns) == 8 + t, + "actual d1 columns are not a basis") + model.need(model.rational_rank(low) == t + 1 + and model.rational_rank(code + low) == 8 + t, + "actual d1 low/code intersection rank") + + # Restricted duals are x_bX=x_bC=f0/2, x_unit=u, x_high=fi/2. + # Store their root index and scalar, preserving the literal normalization. + duals = [(f0, Fraction(1, 2)), (f0, Fraction(1, 2))] + duals += [(root, Fraction(1)) for root in units] + duals += [(root, Fraction(1, 2)) for root in high_normals] + for axis in frame: + coefficients = [scale * Fraction(g.dots[root][axis], 4) + for root, scale in duals] + target = word(axis) + model.need(all(sum(coefficient * q[i] for coefficient, q + in zip(coefficients, columns)) == value + for i, value in enumerate(target)), + "actual d1 restricted dual expansion") + corrections = [] + for j, ((normal, _), q) in enumerate(zip(duals, columns)): + if normal in frame: + carried = model.rank(support(q) + [g.labels[normal]]) == weight(q) + if carried: + corrections.append(j) + model.need(not corrections, "actual d1 control unexpectedly corrected") + invoice = sum(weights) + + # Every low word is Ch + alpha*gx + unit edits. Its support cap36 + # forces |Off(h)|<=36+32=68<70, hence h=0 or a root/frame direction. + # At nonunit X sites the only support-changing alpha ratios are + # 0,+/-1,+/-2. Alpha=3 represents every other characteristic-zero + # ratio. At each unit site both zero/nonzero support states are tested. + qualifying = [] + for normal in range(120): + base = word(normal) + for alpha in (-2, -1, 0, 1, 2, 3): + for state in range(1 << len(units)): + q = [value + alpha * edit for value, edit in zip(base, gx)] + for j, root in enumerate(units): + q[position[root]] = Fraction((state >> j) & 1) + if weight(q) <= 7: + model.need(normal == f0, + "actual d1 low-space certification found another normal") + qualifying.append((normal, alpha, state)) + model.need(qualifying, "actual d1 low-space certification is vacuous") + # h=0 words are supported in X, whose label rank is seven; h=f0 + # words lie in span(Cf0,gx,units)=T. Thus these complete support + # strata prove S_(<=7)=T, not merely that selected lows lie in T. + model.need(model.rank(g.labels[root] for root in model.indices(xmask)) == 7, + "actual d1 zero-normal low space") + + pivot = units[0] + pivot_unit = uu[0] + eta = [1, 0] + [1] * len(units) + [0] * 7 + model.need(all(sum(coefficient * q[i] for coefficient, q in zip(eta, columns)) + == value for i, value in enumerate(gx)), "actual d1 pivot word") + left = [] + for (normal, scale), coefficient in zip(duals, eta): + original = word(normal) + left.append([scale * value / 2 - coefficient * pivot_unit[i] + for i, value in enumerate(original)]) + all_left, all_right = [pivot_unit] + left, [gx] + columns + model.need(model.rational_rank(all_left) == 9 + and model.rational_rank(all_right) == 8 + t, + "actual d1 consumer ranks") + model.need(nonparallel(all_left) and nonparallel(all_right), + "actual d1 consumer zero/parallel factors") + for i, root_i in enumerate(live): + for j, root_j in enumerate(live): + actual = sum(p[i] * q[j] for p, q in zip(all_left, all_right)) + model.need(actual == Fraction(g.dots[root_i][root_j], 8), + "actual d1 consumer is not the exact Gram factorization") + costs = [term_cost(p, q) for p, q in zip(all_left, all_right)] + expected_costs = [1, 7, 7] + [0] + [1] * (len(units) - 1) + [8] * 7 + model.need(costs == expected_costs and sum(costs) == invoice, + "actual d1 consumer term costs") + losing = [j for j, ((normal, scale), p) in enumerate(zip(duals, left)) + if scale * Fraction(g.dots[normal][pivot], 8) != 0 + and p[position[pivot]] == 0] + model.need(losing == [2], "actual d1 consumer losing root row") + results.append({"t": t, "basis_weights": weights, "n_c": 0, + "invoice": invoice, "low_space_dimension": t + 1, + "code_intersection_dimension": 1, + "low_root_strata": 120 * 6 * (1 << len(units)), + "low_qualifying_digest": model.digest(qualifying), + "rank_P": 9, "rank_Q": 8 + t, + "factor_nonparallel": True, "exact_Gram_entries": 112 * 112, + "pivot_cost": costs[0], "losing_indices": losing, + "term_costs": costs, "actual_cost": sum(costs), + "unit_roots": units}) + return {"scope": "nonempty-actual-d1-consumer-controls-not-sharpness", + "root_direction_rigidity_premise": "support-at-most68-is-below70", + "cases": results} diff --git a/research/p112-six-seven-supplement/controls.py b/research/p112-six-seven-supplement/controls.py new file mode 100644 index 0000000000..643982a2e1 --- /dev/null +++ b/research/p112-six-seven-supplement/controls.py @@ -0,0 +1,88 @@ +"""Independent-oracle and hypothesis-boundary controls for the supplement. + +conorholds, with OpenAI Codex assistance. Apache-2.0. +These are mathematical/endpoint controls, not a machine-execution claim. +""" + +from fractions import Fraction +from itertools import product + + +def run(model): + g = model.Geometry() + v = g.index[(2, 0, 2, 0, 0, 0, 0, 0)] + w = g.index[(2, 0, -2, 0, 0, 0, 0, 0)] + high = g.neighbors[v] & ~g.neighbors[w] & g.live + low_roots = {tuple(2 if j == center else sign * 2 if j == other else 0 for j in range(8)) + for center in (0, 2) for other in range(4, 8) for sign in (-1, 1)} + low = sum(1 << g.index[r] for r in low_roots) + target = g.off[v] & g.live + sparse = target & ~(low | high) + + def endpoint(parts, all_sites=False): + errors = [] + domain = range(120) if all_sites else model.indices(g.live) + for i in domain: + actual = sum(Fraction(g.dots[v][i], 4) * coefficient + for support, coefficient in parts if support >> i & 1) + if actual != Fraction(g.dots[v][i], 4): + errors.append(i) + return errors + + valid = [(sparse, 1), (low, 1), (high, 1)] + model.need(not endpoint(valid), "five-site positive oracle") + no_self = [(sparse ^ (1 << v), 1), (low, 1), (high, 1)] + model.need(endpoint(no_self) == [v], "self omission must change the real codeword") + model.need((g.neighbors[v] & g.live) & ~(low | high) == sparse ^ (1 << v), + "open-neighbor false four-site cover") + model.need((sparse ^ (1 << v)).bit_count() == 4, + "the self control must hit the exact four-site boundary") + wrong_orientation = g.neighbors[v] & g.neighbors[w] & g.live + model.need(endpoint([(sparse, 1), (low, 1), (wrong_orientation, 1)]), + "wrong completion orientation accepted") + model.need(endpoint([(sparse, 1), (low, -1), (high, 1)]), + "wrong coefficient sign accepted") + shifted_low = low ^ (1 << next(model.indices(low))) + model.need(len(endpoint([(sparse, 1), (shifted_low, 1), (high, 1)])) == 1, + "omitted live root not detected") + full_errors = endpoint(valid, all_sites=True) + model.need(len(full_errors) == 4 and all(g.frame >> i & 1 for i in full_errors), + "puncturing convention not essential to the witness") + + # Both affine offsets are tested. A minus-type four-dimensional form + # has a six-point hyperplane section, so nonsingularity alone is insufficient. + values = list(product((0, 1), repeat=4)) + plus = lambda x: (x[0] * x[1] + x[2] * x[3]) % 2 + minus = lambda x: (plus(x) + x[0] + x[1]) % 2 + maximum = {} + for name, q in (("plus", plus), ("minus", minus)): + maximum[name] = max(sum(q(x) == 1 and sum(a * b for a, b in zip(normal, x)) % 2 == theta + for x in values) + for normal in values if any(normal) for theta in (0, 1)) + model.need(maximum == {"plus": 4, "minus": 6}, "Gauss-sign countermodel") + + # The demonstrated slack-nine space is not excluded: its two small + # supports use five sites. Raising the four-site gate would be false. + capacities = {1: 1, 2: 2, 3: 4} + model.need(capacities[3] + capacities[1] == 5 > 4, + "slack-nine witness erroneously covered by the caller rule") + witness = model.witness_checks(g) + model.need(witness["slack9"]["code_rank"] + witness["slack9"]["pieces_rank"] + - witness["slack9"]["joint_rank"] == 1, + "slack-nine control lacks its actual code intersection") + need_failure = [] + for wrong in (True, 1.0, "1", 2): + need_failure.append(model.canonical_json({"n": wrong}) != model.canonical_json({"n": 1})) + model.need(all(need_failure), "scientific receipt weakened JSON number types") + for raw in ('{"a":1,"a":2}', '{"a":NaN}', '{"a":Infinity}'): + try: + model.strict_json(raw) + except ValueError: + continue + raise ValueError("ambiguous/nonfinite JSON accepted") + + return {"five_site_positive": True, "self_omission_exact_defect": 1, + "wrong_completion_orientation_rejected": True, "wrong_coefficient_rejected": True, + "omitted_live_root_rejected": True, "full_E8_missing_frame_sites": 4, + "quadric_hyperplane_maxima": maximum, "slack9_outside_four_site_gate": True, + "typed_receipt_and_strict_json": True} diff --git a/research/p112-six-seven-supplement/d2_controls.py b/research/p112-six-seven-supplement/d2_controls.py new file mode 100644 index 0000000000..abc37a45f8 --- /dev/null +++ b/research/p112-six-seven-supplement/d2_controls.py @@ -0,0 +1,181 @@ +"""Nonempty marked actual-d2 controls, with complete low-space certificates. + +conorholds, substantial OpenAI Codex assistance. Apache-2.0. +The modulo-three minors certify characteristic-zero ranks; payloads and +the Gram factorization are checked over the rationals. These examples lie +above the invoice floor and do not replace its written proof. +""" + +from fractions import Fraction + + +def rank_mod3(rows): + basis = {} + for original in rows: + row = list(original) + for j in range(6): + if not row[j]: + continue + if j in basis: + factor = row[j] + row = [(x - factor*y) % 3 for x, y in zip(row, basis[j])] + else: + factor = row[j] # Both nonzero elements of F3 are self-inverse. + basis[j] = [(factor*x) % 3 for x in row] + break + if len(basis) == 6: + return 6 + return len(basis) + + +def run(model): + g = model.Geometry() + live, frame = list(model.indices(g.live)), list(model.indices(g.frame)) + a, b = frame[:2] + axes = frame[2:] + parts = [g.neighbors[a] & ~g.neighbors[b] & g.live, + g.neighbors[b] & ~g.neighbors[a] & g.live, + sum(1 << s for s in live if g.dots[a][s]*g.dots[b][s] > 0), + sum(1 << s for s in live if g.dots[a][s]*g.dots[b][s] < 0)] + model.need([p.bit_count() for p in parts] == [32, 32, 12, 12], "d2 piece partition") + root = next(s for s in live if not (g.neighbors[a] | g.neighbors[b]) >> s & 1) + active = [f for f in axes if g.dots[root][f]] + model.need(len(active) == 4, "d2 marked root outside plane") + selected = active[0] + epsilon = Fraction(g.dots[root][selected], 4) + pivot = next(s for s in model.indices(parts[0]) if g.dots[a][s] == 4) + pivot_pos = live.index(pivot) + + def word(f): + return [Fraction(g.dots[f][s], 4) for s in live] + + def normal(f, scale=Fraction(1)): + return [scale*Fraction(x, 2) for x in g.roots[f]] + + def support(q): + return [g.labels[s] for s, value in zip(live, q) if value] + + def weight(q): + return model.rank(support(q)) + + def nonparallel(rows): + normalized = [] + for row in rows: + lead = next((x for x in row if x), None) + if lead is None: + return False + normalized.append(tuple(x/lead for x in row)) + return len(normalized) == len(set(normalized)) + + def term_cost(p, q): + def basis(labels): + result = [] + for label in labels: + if model.rank(result + [label]) > len(result): + result.append(label) + return result + left, right = basis(support(p)), basis(support(q)) + return model.rank(sum((((x & 1)*(y & 1)) ^ g.b(x >> 1, y >> 1)) << j + for j, y in enumerate(right)) for x in left) + + code = [word(f) for f in frame] + raw = {s: tuple((g.dots[f][s]//4) % 3 for f in axes) for s in live} + results = [] + for t in (2, 3): + masks = parts.copy() + if t == 3: + masks[0] ^= 1 << pivot + masks.append(1 << pivot) + ids = [list(model.indices(mask)) for mask in masks] + low = [[Fraction(g.dots[b if j == 1 else a][s], 4) if mask >> s & 1 else Fraction(0) + for s in live] for j, mask in enumerate(masks)] + high = [word(f) for f in axes] + if t == 3: + for row in high: + row[pivot_pos] = Fraction(0) + chosen = axes.index(selected) + for j, f in enumerate(axes): + if j != chosen: + scalar = Fraction(g.dots[root][f], 4) / epsilon + high[j] = [x - scalar*y for x, y in zip(high[j], high[chosen])] + columns = low + high + normals = [normal(a, Fraction(1, 2)), normal(b, Fraction(1, 2)), + [(x+y)/2 for x, y in zip(normal(a), normal(b))], + [(x-y)/2 for x, y in zip(normal(a), normal(b))]] + if t == 3: + normals.append(normal(pivot)) + normals += [normal(root, 1/epsilon) if f == selected else normal(f, Fraction(1, 2)) + for f in axes] + model.need(model.rational_rank(low) == t+2 + and model.rational_rank(columns) == 8+t + and model.rational_rank(code+low) == 8+t, "actual d2 ranks/intersection") + model.need(all(any(x for x in row) for row in normals), "actual d2 zero restricted dual") + for f in frame: + coefficients = [sum(x*y for x, y in zip(row, normal(f))) for row in normals] + model.need(all(sum(c*q[i] for c, q in zip(coefficients, columns)) == value + for i, value in enumerate(word(f))), "actual d2 restricted dual expansion") + + # Certify S_(<=7)=T. Every support-rank<=7 word lies in an affine-six + # label flat. Eliminate the disjoint T coordinates outside each flat. + # Full rank six of the remaining C/T evaluation matrix modulo3 gives + # a nonzero integer minor, and thus the same full rank in every char0 field. + used = 0 + for mask in masks: + used |= mask + outside = list(model.indices(g.live ^ used)) + normalized = [{s: tuple((x*(g.dots[b if j == 1 else a][s]//4)) % 3 for x in raw[s]) + for s in part} for j, part in enumerate(ids)] + differences = [{(u, v): tuple((x-y) % 3 for x, y in zip(vectors[u], vectors[v])) + for u in vectors for v in vectors} for vectors in normalized] + flat_count = 0 + for _, _, flat in g.affine_sections(): + def residuals(): + for s in outside: + if not flat >> s & 1: + yield raw[s] + for part, delta in zip(ids, differences): + complement = [s for s in part if not flat >> s & 1] + if complement: + anchor = complement[0] + for s in complement[1:]: + yield delta[s, anchor] + model.need(rank_mod3(residuals()) == 6, "actual d2 low-space minor rank") + flat_count += 1 + model.need(flat_count == 43180, "actual d2 low-space flat coverage") + + weights, corrected = [weight(q) for q in columns], [] + for j, (q, row) in enumerate(zip(columns, normals)): + for f in frame: + fr = normal(f) + first = next(k for k, x in enumerate(fr) if x) + scalar = row[first]/fr[first] + if scalar and row == [scalar*x for x in fr]: + if model.rank(support(q)+[g.labels[f]]) == weights[j]: + corrected.append(j) + model.need(len(corrected) == 3 and weights.count(9) == 3 + and all(weights[j] == 9 for j in corrected), + "actual d2 corrected weight-nine controls") + model.need(normals[len(low)+chosen] == normal(root, 1/epsilon), "actual d2 live-root mark") + + eu = [Fraction(s == pivot) for s in live] + eta = [Fraction(j in (0, 2) or (t == 3 and j == 4)) for j in range(len(columns))] + qp = [sum(c*q[i] for c, q in zip(eta, columns)) for i in range(112)] + dual_words = [[sum(x*y for x, y in zip(row, normal(s))) for s in live] for row in normals] + left = [[x/2-c*eu[i] for i, x in enumerate(row)] for c, row in zip(eta, dual_words)] + all_left, all_right = [eu]+left, [qp]+columns + model.need(model.rational_rank(all_left) == 9 and model.rational_rank(all_right) == 8+t, + "actual d2 consumer ranks") + model.need(nonparallel(all_left) and nonparallel(all_right), "actual d2 parallel factor") + for i, ri in enumerate(live): + for j, rj in enumerate(live): + model.need(sum(p[i]*q[j] for p, q in zip(all_left, all_right)) + == Fraction(g.dots[ri][rj], 8), "actual d2 Gram factorization") + costs = [term_cost(p, q) for p, q in zip(all_left, all_right)] + model.need(sum(costs) >= 64, "actual d2 control consumer floor") + results.append({"t": t, "d": 2, "dimension_T": t+2, "weights": weights, + "n_c": len(corrected), "corrected_weight9": len(corrected), + "invoice": sum(weights)-len(corrected), "low_space_flats": flat_count, + "quotient_minor_rank_mod3": 6, "rank_P": 9, "rank_Q": 8+t, + "nonparallel_factors": True, "exact_Gram_entries": 12544, + "term_costs": costs, "actual_cost": sum(costs)}) + return {"scope": "nonempty-marked-actual-d2-controls-not-sharpness", "cases": results} diff --git a/research/p112-six-seven-supplement/formal/DimensionDeletion.lean b/research/p112-six-seven-supplement/formal/DimensionDeletion.lean new file mode 100644 index 0000000000..690d720057 --- /dev/null +++ b/research/p112-six-seven-supplement/formal/DimensionDeletion.lean @@ -0,0 +1,113 @@ +/- +Copyright (c) 2026 conorholds. All rights reserved. +Released under Apache 2.0 license as described in the repository LICENSE. +Prepared with substantial OpenAI Codex assistance. +-/ +import Mathlib.LinearAlgebra.FiniteDimensional.Lemmas +import Mathlib.LinearAlgebra.Dimension.Constructions +import Mathlib.LinearAlgebra.Pi +import Mathlib.LinearAlgebra.Basis.Basic + +/-! +# Dimension deletion for actual linear combinations + +A finite-dimensional space has a nonzero vector annihilated by any smaller +family of scalar linear constraints. For basis-coordinate constraints this +produces a vector in the span of the undeleted basis vectors, not merely a +support-union relaxation. The last theorem applies to a code subspace inside +the span of an independent family and deletes any `d - 1` of its basis pieces. + +No E8 geometry or P112 capacity premise is used in this file. +-/ + +namespace SixSevenSupplement + +open Module + +variable {K V : Type*} [DivisionRing K] [AddCommGroup V] [Module K V] + +/-- Fewer scalar linear constraints than dimensions have a common nonzero +kernel vector. The constraints need not be independent or nonzero. -/ +theorem exists_nonzero_annihilating + [FiniteDimensional K V] {Constraint : Type*} [Fintype Constraint] + (coeff : Constraint → V →ₗ[K] K) + (hsize : Fintype.card Constraint < finrank K V) : + ∃ v : V, v ≠ 0 ∧ ∀ i, coeff i v = 0 := by + let f : V →ₗ[K] (Constraint → K) := LinearMap.pi coeff + have hdim : finrank K (Constraint → K) < finrank K V := by + simpa only [Module.finrank_pi] using hsize + have hker : LinearMap.ker f ≠ ⊥ := + LinearMap.ker_ne_bot_of_finrank_lt hdim + obtain ⟨v, hvker, hvzero⟩ := (LinearMap.ker f).ne_bot_iff.mp hker + refine ⟨v, hvzero, ?_⟩ + intro i + have hz : f v = 0 := LinearMap.mem_ker.mp hvker + exact congrFun hz i + +/-- The nonzero vector can be required to lie in a given finite-dimensional +subspace even when the ambient space itself is not finite-dimensional. -/ +theorem exists_nonzero_in_submodule_annihilating + (D : Submodule K V) [FiniteDimensional K D] + {Constraint : Type*} [Fintype Constraint] + (coeff : Constraint → V →ₗ[K] K) + (hsize : Fintype.card Constraint < finrank K D) : + ∃ v : V, v ∈ D ∧ v ≠ 0 ∧ ∀ i, coeff i v = 0 := by + obtain ⟨v, hvzero, hcoeff⟩ := exists_nonzero_annihilating + (fun i => (coeff i).comp D.subtype) hsize + refine ⟨v, v.property, ?_, ?_⟩ + · intro hv + exact hvzero (Subtype.ext hv) + · exact hcoeff + +/-- Deleting fewer than `dim D` basis pieces leaves an actual nonzero vector +of D in the span of the remaining pieces. The killed coefficients are also +retained explicitly in the conclusion. -/ +theorem exists_nonzero_after_basis_deletion + {Index : Type*} (b : Basis Index K V) + (D : Submodule K V) [FiniteDimensional K D] + (deleted : Finset Index) (hsize : deleted.card < finrank K D) : + ∃ v : V, v ∈ D ∧ v ≠ 0 ∧ + (∀ i ∈ deleted, b.repr v i = 0) ∧ + v ∈ Submodule.span K (b '' (deleted : Set Index)ᶜ) := by + classical + have hcard : Fintype.card deleted < finrank K D := by + simpa only [Fintype.card_coe] using hsize + obtain ⟨v, hvD, hvzero, hcoord⟩ := + exists_nonzero_in_submodule_annihilating D + (fun i : deleted => b.coord i.val) hcard + have hzero : ∀ i ∈ deleted, b.repr v i = 0 := by + intro i hi + simpa only [Basis.coord_apply] using hcoord ⟨i, hi⟩ + refine ⟨v, hvD, hvzero, hzero, ?_⟩ + apply b.mem_span_image.mpr + intro i hi + show i ∉ deleted + intro hdeleted + exact (Finsupp.mem_support_iff.mp hi) (hzero i hdeleted) + +/-- Literal code-subspace form of the `d - 1` deletion principle. A basis of +the piece span T is supplied; its intersection with the ambient code C has +dimension d. Every choice of d - 1 deleted basis pieces leaves a nonzero +ambient codeword in the span of the undeleted pieces. -/ +theorem exists_codeword_after_dimension_minus_one_deletions + {Index : Type*} (T C : Submodule K V) + (b : Basis Index K T) [FiniteDimensional K (C.submoduleOf T)] + (deleted : Finset Index) + (hpositive : 0 < finrank K (C.submoduleOf T)) + (hdeleted : deleted.card = finrank K (C.submoduleOf T) - 1) : + ∃ v : T, (v : V) ∈ C ∧ (v : V) ≠ 0 ∧ + (∀ i ∈ deleted, b.repr v i = 0) ∧ + v ∈ Submodule.span K (b '' (deleted : Set Index)ᶜ) := by + have hsize : deleted.card < finrank K (C.submoduleOf T) := by omega + obtain ⟨v, hvC, hvzero, hcoord, hspan⟩ := + exists_nonzero_after_basis_deletion b (C.submoduleOf T) deleted hsize + refine ⟨v, hvC, ?_, hcoord, hspan⟩ + intro hv + exact hvzero (Subtype.ext hv) + +#print axioms exists_nonzero_annihilating +#print axioms exists_nonzero_in_submodule_annihilating +#print axioms exists_nonzero_after_basis_deletion +#print axioms exists_codeword_after_dimension_minus_one_deletions + +end SixSevenSupplement diff --git a/research/p112-six-seven-supplement/formal/QuarterCore.lean b/research/p112-six-seven-supplement/formal/QuarterCore.lean new file mode 100644 index 0000000000..f09afa95da --- /dev/null +++ b/research/p112-six-seven-supplement/formal/QuarterCore.lean @@ -0,0 +1,229 @@ +/- +Copyright (c) 2026 conorholds. All rights reserved. +Released under Apache 2.0 license as described in the repository LICENSE. +Prepared with substantial OpenAI Codex assistance. +-/ +import Mathlib.Data.Fintype.Prod +import Mathlib.Data.Finset.Card +import Lean.Elab.Tactic.Omega + +/-! +# The 24-point deleted-quarter normal form and the sparse-cover obstruction + +The finite model is the six one-points of the hyperbolic quadratic form +`x₀x₁ + x₂x₃`, with a two-dimensional radical. Every nonconstant affine +linear cut has at most 16 of its 24 points. The finite-model theorems use +kernel reduction (`decide`), not `native_decide` or an external certificate. + +The last two theorems prove the covering argument for arbitrary finite sets. +The E8 root/label identification, reduction to this normal form, completion +rigidity, and rank-dependent intersection premises are not asserted here. +-/ + +namespace SixSevenSupplement + +abbrev Bits2 := Bool × Bool +abbrev Bits4 := Bits2 × Bits2 +abbrev Bits6 := Bits4 × Bits2 + +def zero2 : Bits2 := (false, false) +def zero4 : Bits4 := (zero2, zero2) + +/-- Coordinatewise addition in the explicit two-coordinate binary model. -/ +def xor2 (x y : Bits2) : Bits2 := + (Bool.xor x.1 y.1, Bool.xor x.2 y.2) + +/-- Coordinatewise addition in the explicit four-coordinate binary model. -/ +def xor4 (x y : Bits4) : Bits4 := + (xor2 x.1 y.1, xor2 x.2 y.2) + +/-- The standard binary dot product in two coordinates. -/ +def dot2 (a x : Bits2) : Bool := + Bool.xor (a.1 && x.1) (a.2 && x.2) + +/-- Every linear functional on the four explicit binary coordinates. -/ +def dot4 (a x : Bits4) : Bool := + Bool.xor (dot2 a.1 x.1) (dot2 a.2 x.2) + +/-- The split, nondegenerate four-dimensional binary quadratic form. -/ +def hyperbolic4 (x : Bits4) : Bool := + Bool.xor (x.1.1 && x.1.2) (x.2.1 && x.2.2) + +def quadric4 : Finset Bits4 := + Finset.univ.filter fun x => hyperbolic4 x = true + +def quadricSection (a : Bits4) (theta : Bool) : Finset Bits4 := + quadric4.filter fun x => dot4 a x = theta + +theorem quadric4_card : quadric4.card = 6 := by decide + +/-- All nonconstant affine hyperplanes meet the split quadric in at most four +points; both affine offsets and every nonzero normal are quantified. -/ +theorem quadric_hyperplane_cap : + ∀ a : Bits4, a ≠ zero4 → ∀ theta : Bool, + (quadricSection a theta).card ≤ 4 := by decide + +/-- The six one-points contain no affine binary plane: four distinct +one-points never have coordinatewise sum zero. -/ +theorem quadric_no_affine_plane : + ∀ x ∈ quadric4, ∀ y ∈ quadric4, ∀ z ∈ quadric4, ∀ w ∈ quadric4, + x ≠ y → x ≠ z → x ≠ w → y ≠ z → y ≠ w → z ≠ w → + xor4 (xor4 x y) (xor4 z w) ≠ zero4 := by decide + +/-- Every pair of distinct one-points is avoided by a nonconstant affine +hyperplane section containing exactly four of the six one-points. -/ +theorem quadric_pair_avoiding_section : + ∀ x ∈ quadric4, ∀ y ∈ quadric4, x ≠ y → + ∃ a : Bits4, ∃ theta : Bool, a ≠ zero4 ∧ + (quadricSection a theta).card = 4 ∧ + x ∉ quadricSection a theta ∧ y ∉ quadricSection a theta := by decide + +/-- The two last coordinates are the radical coordinates. -/ +def quarter : Finset Bits6 := + Finset.univ.filter fun x => hyperbolic4 x.1 = true + +def quarterSection (a : Bits4) (b : Bits2) (theta : Bool) : Finset Bits6 := + quarter.filter fun x => Bool.xor (dot4 a x.1) (dot2 b x.2) = theta + +theorem quarter_card : quarter.card = 24 := by decide + +/-- A cut nonconstant on the radical takes exactly half the points. -/ +theorem quarter_radical_cut_card : + ∀ a : Bits4, ∀ b : Bits2, b ≠ zero2 → ∀ theta : Bool, + (quarterSection a b theta).card = 12 := by decide + +/-- A radical-constant nonconstant cut has four radical lifts per quadric +point. This statement includes every such normal and both affine offsets. -/ +theorem quarter_constant_radical_card : + ∀ a : Bits4, ∀ theta : Bool, + (quarterSection a zero2 theta).card = + 4 * (quadricSection a theta).card := by decide + +/-- The new capacity-16 bound in the explicit deleted-quarter normal form. -/ +theorem quarter_hyperplane_cap (a : Bits4) (b : Bits2) (theta : Bool) + (hnonzero : a ≠ zero4 ∨ b ≠ zero2) : + (quarterSection a b theta).card ≤ 16 := by + by_cases hb : b = zero2 + · subst b + have ha : a ≠ zero4 := hnonzero.resolve_right (by simp) + rw [quarter_constant_radical_card] + have hcap := quadric_hyperplane_cap a ha theta + omega + · rw [quarter_radical_cut_card a b hb theta] + decide + +/-- The bound is attained, so replacing 16 by 15 would be false. -/ +theorem quarter_capacity_sharp : + (quarterSection ((true, false), (false, false)) zero2 true).card = 16 := by + decide + +section Covering + +variable {Site : Type*} [DecidableEq Site] + +/-- If a high flat avoids the core, a three-part cover of the live core +reduces to a cover by the low flat and the exceptional sites. -/ +private theorem live_cover (C F L H E : Finset Site) + (havoid : ∀ x ∈ C, x ∉ H) + (hcover : C \ F ⊆ L ∪ H ∪ E) : + C \ F ⊆ (C ∩ L) ∪ E := by + intro x hx + have hxC := (Finset.mem_sdiff.mp hx).1 + rcases Finset.mem_union.mp (hcover hx) with hLH | hE + · rcases Finset.mem_union.mp hLH with hL | hH + · exact Finset.mem_union.mpr (Or.inl (Finset.mem_inter.mpr ⟨hxC, hL⟩)) + · exact False.elim (havoid x hxC hH) + · exact Finset.mem_union.mpr (Or.inr hE) + +/-- A symbolic capacity bound for any finite core. If the high part avoids +the core, all remaining core points are charged to the exceptional set. +No restriction is imposed on overlaps between the cover parts. -/ +theorem core_cover_card_le (C L H E : Finset Site) + (havoid : ∀ x ∈ C, x ∉ H) + (hcover : C ⊆ L ∪ H ∪ E) : + C.card ≤ (C ∩ L).card + E.card := by + have hcover' : C \ ∅ ⊆ L ∪ H ∪ E := by simpa using hcover + have hsub := live_cover C ∅ L H E havoid hcover' + have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _) + simpa using hcard + +/-- For an unpunctured 24-point quarter, capacity 16 forces at least eight +exceptional sites. This is the frame-normal floor used by the root proof. -/ +theorem unpunctured_quarter_exceptional_floor + (C L H E : Finset Site) + (hC : C.card = 24) (hL : (C ∩ L).card ≤ 16) + (havoid : ∀ x ∈ C, x ∉ H) + (hcover : C ⊆ L ∪ H ∪ E) : 8 ≤ E.card := by + have hcard := core_cover_card_le C L H E havoid hcover + omega + +/-- This includes a frame normal, whose full quarter has no deleted sites, +as well as a nonframe normal with at most three deleted quarter sites. -/ +theorem no_sparse_cover_of_at_most_three_deleted + (C F L H E : Finset Site) + (hC : C.card = 24) (hF : (C ∩ F).card ≤ 3) + (hL : (C ∩ L).card ≤ 16) (hE : E.card ≤ 4) + (havoid : ∀ x ∈ C, x ∉ H) + (hcover : C \ F ⊆ L ∪ H ∪ E) : False := by + have hsub := live_cover C F L H E havoid hcover + have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _) + have hpartition := Finset.card_sdiff_add_card_inter C F + omega + +/-- The all-four-frame-deletions case retains the self site. If the low +flat carries self, its core intersection has capacity 12. Otherwise the +exceptional set must spend a site on self. These are the genuine geometric +premises used by the handwritten proof, rather than a presumed conclusion. -/ +theorem no_sparse_cover_with_self + (C F L H E : Finset Site) (self : Site) + (hC : C.card = 24) (hF : (C ∩ F).card ≤ 4) + (hL : (C ∩ L).card ≤ 16) (hE : E.card ≤ 4) + (hselfC : self ∉ C) (hselfH : self ∉ H) + (hselfL : self ∈ L → (C ∩ L).card ≤ 12) + (havoid : ∀ x ∈ C, x ∉ H) + (hcover : insert self (C \ F) ⊆ L ∪ H ∪ E) : False := by + have hcorecover : C \ F ⊆ L ∪ H ∪ E := by + intro x hx + exact hcover (Finset.mem_insert_of_mem hx) + have hsub := live_cover C F L H E havoid hcorecover + have hpartition := Finset.card_sdiff_add_card_inter C F + by_cases hsL : self ∈ L + · have hsmall := hselfL hsL + have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _) + omega + · have hsE : self ∈ E := by + have hscover := hcover (Finset.mem_insert_self self (C \ F)) + rcases Finset.mem_union.mp hscover with hsLH | hsE + · rcases Finset.mem_union.mp hsLH with hsL' | hsH + · exact False.elim (hsL hsL') + · exact False.elim (hselfH hsH) + · exact hsE + have hsuberase : C \ F ⊆ (C ∩ L) ∪ E.erase self := by + intro x hx + rcases Finset.mem_union.mp (hsub hx) with hxL | hxE + · exact Finset.mem_union.mpr (Or.inl hxL) + · have hxself : x ≠ self := by + intro heq + exact hselfC (heq ▸ (Finset.mem_sdiff.mp hx).1) + exact Finset.mem_union.mpr (Or.inr (Finset.mem_erase.mpr ⟨hxself, hxE⟩)) + have herase := Finset.card_erase_add_one hsE + have hcard := (Finset.card_le_card hsuberase).trans (Finset.card_union_le _ _) + omega + +end Covering + +#print axioms quadric4_card +#print axioms quadric_hyperplane_cap +#print axioms quadric_no_affine_plane +#print axioms quadric_pair_avoiding_section +#print axioms quarter_card +#print axioms quarter_radical_cut_card +#print axioms quarter_constant_radical_card +#print axioms quarter_hyperplane_cap +#print axioms quarter_capacity_sharp +#print axioms core_cover_card_le +#print axioms unpunctured_quarter_exceptional_floor +#print axioms no_sparse_cover_of_at_most_three_deleted +#print axioms no_sparse_cover_with_self + +end SixSevenSupplement diff --git a/research/p112-six-seven-supplement/formal/SharedPiece.lean b/research/p112-six-seven-supplement/formal/SharedPiece.lean new file mode 100644 index 0000000000..cc983fc240 --- /dev/null +++ b/research/p112-six-seven-supplement/formal/SharedPiece.lean @@ -0,0 +1,69 @@ +/- +Copyright (c) 2026 conorholds. All rights reserved. +Released under Apache 2.0 license as described in the repository LICENSE. +Prepared with substantial OpenAI Codex assistance. +-/ +import Init + +/-! +# Actual shared-piece algebra, with explicit operation premises + +This deliberately small file imports only Lean Init. Associativity, +commutativity and the numerical embedding laws are ordinary theorem +parameters. Instantiation by a characteristic-zero ring, the E8 geometry +and the passage from actual coefficient expansions remain outside Lean. +-/ + +namespace SixSevenSupplement + +theorem shared_piece_cross_product + {R : Type} (mul : R → R → R) + (assoc : ∀ a b c, mul (mul a b) c = mul a (mul b c)) + (comm : ∀ a b, mul a b = mul b a) + (alpha beta ma mb A B C D : R) + (hA : mul alpha ma = A) (hB : mul alpha mb = B) + (hC : mul beta ma = C) (hD : mul beta mb = D) : + mul A D = mul B C := by + have interchange (a b c d : R) : + mul (mul a b) (mul c d) = mul (mul a c) (mul b d) := by + rw [assoc a b (mul c d), ← assoc b c d, comm b c, + assoc c b d, ← assoc a c (mul b d)] + calc + mul A D = mul (mul alpha ma) (mul beta mb) := by rw [hA, hD] + _ = mul (mul alpha beta) (mul ma mb) := interchange alpha ma beta mb + _ = mul (mul alpha beta) (mul mb ma) := by rw [comm ma mb] + _ = mul (mul alpha mb) (mul beta ma) := (interchange alpha mb beta ma).symm + _ = mul B C := by rw [hB, hC] + +theorem no_shared_piece_at_two_root_self_sites + {R : Type} (mul : R → R → R) + (assoc : ∀ a b c, mul (mul a b) c = mul a (mul b c)) + (comm : ∀ a b, mul a b = mul b a) + (embed : Nat → R) (inject : ∀ {a b}, embed a = embed b → a = b) + (minusOne : R) + (squareZero : mul (embed 0) (embed 0) = embed 0) + (squareOne : mul (embed 1) (embed 1) = embed 1) + (squareMinusOne : mul minusOne minusOne = embed 1) + (squareTwo : mul (embed 2) (embed 2) = embed 4) + (alpha beta ma mb e : R) + (he : e = embed 0 ∨ e = embed 1 ∨ e = minusOne) + (haa : mul alpha ma = embed 2) (hab : mul alpha mb = e) + (hba : mul beta ma = e) (hbb : mul beta mb = embed 2) : False := by + have hdet := shared_piece_cross_product mul assoc comm alpha beta ma mb + (embed 2) e e (embed 2) haa hab hba hbb + rw [squareTwo] at hdet + rcases he with he | he | he + · rw [he, squareZero] at hdet + have bad : (4 : Nat) = 0 := inject hdet + cases bad + · rw [he, squareOne] at hdet + have bad : (4 : Nat) = 1 := inject hdet + cases bad + · rw [he, squareMinusOne] at hdet + have bad : (4 : Nat) = 1 := inject hdet + cases bad + +#print axioms shared_piece_cross_product +#print axioms no_shared_piece_at_two_root_self_sites + +end SixSevenSupplement diff --git a/research/p112-six-seven-supplement/independent.py b/research/p112-six-seven-supplement/independent.py new file mode 100644 index 0000000000..1d98e92a76 --- /dev/null +++ b/research/p112-six-seven-supplement/independent.py @@ -0,0 +1,813 @@ +"""Independent exact reconstruction for the P112 six/seven supplement. + +Contributed by conorholds. Retains the E8/P112 geometry and label lineage of +PR3161/3162, joaqcoo, and the DreamingOfClouds decoder data. The signed +quadratic-capacity predecessors are PR3269/3300. Apache-2.0. + +This engine does not import the primary verifier or execute source helpers. +It reconstructs roots directly, uses a polar-pairing coordinate system of its +own, and enumerates affine sections by ordinary-dot RREF annihilators. +""" + +from __future__ import annotations + +import ast +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations, product +import json +from pathlib import Path +import re + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parent.parent + + +def insist(condition, message): + if not condition: + raise ValueError(message) + + +def scalar(a, b): + insist(len(a) == len(b), "dot-product dimension") + return sum(x * y for x, y in zip(a, b)) + + +def positive_line(vector): + vector = tuple(vector) + first = next((x for x in vector if x), None) + insist(first is not None, "zero root") + return vector if first > 0 else tuple(-x for x in vector) + + +def reconstruct_roots(): + roots = [] + for i in range(8): + for j in range(i + 1, 8): + for sign in (-1, 1): + vector = [0] * 8 + vector[i], vector[j] = 2, 2 * sign + roots.append(tuple(vector)) + # Fix the first sign, rather than generating and deduplicating both lines. + for code in range(128): + if code.bit_count() % 2 == 0: + roots.append((1,) + tuple(-1 if code >> i & 1 else 1 for i in range(7))) + roots = tuple(sorted(roots)) + frame = set() + for i in range(0, 8, 2): + for sign in (-1, 1): + vector = [0] * 8 + vector[i], vector[i + 1] = 2, 2 * sign + frame.add(tuple(vector)) + insist(len(roots) == len(set(roots)) == 120, "independent root inventory") + insist(len(frame) == 8 and frame <= set(roots), "independent paired frame") + insist(all(scalar(r, r) == 8 for r in roots), "root normalization") + insist(all(scalar(a, b) == 0 for a, b in combinations(frame, 2)), "frame orthogonality") + return roots, frame + + +def binary_rank(vectors): + pivots = {} + for original in vectors: + value = original + while value: + column = (value & -value).bit_length() - 1 + if column in pivots: + value ^= pivots[column] + else: + pivots[column] = value + break + return len(pivots) + + +def coordinates_in_span(vectors): + basis = [] + for value in vectors: + if binary_rank(basis + [value]) > len(basis): + basis.append(value) + coordinates = {0: 0} + for i, value in enumerate(basis): + coordinates.update({x ^ value: c | (1 << i) for x, c in tuple(coordinates.items())}) + insist(all(value in coordinates for value in vectors), "span coordinates") + return basis, coordinates + + +def rational_rank(rows): + if not rows: + return 0 + width = len(rows[0]) + insist(all(len(row) == width for row in rows), "rational matrix shape") + matrix = [list(map(Fraction, row)) for row in rows] + rank = 0 + for col in range(width): + pivot = next((i for i in range(rank, len(matrix)) if matrix[i][col]), None) + if pivot is None: + continue + matrix[rank], matrix[pivot] = matrix[pivot], matrix[rank] + scale = matrix[rank][col] + matrix[rank] = [x / scale for x in matrix[rank]] + for i in range(rank + 1, len(matrix)): + factor = matrix[i][col] + if factor: + matrix[i] = [x - factor * y for x, y in zip(matrix[i], matrix[rank])] + rank += 1 + if rank == len(matrix): + break + return rank + + +def inverse(matrix): + size = len(matrix) + insist(size and all(len(row) == size for row in matrix), "square inverse shape") + rows = [list(map(Fraction, row)) + [Fraction(i == j) for j in range(size)] + for i, row in enumerate(matrix)] + for col in range(size): + pivot = next((i for i in range(col, size) if rows[i][col]), None) + insist(pivot is not None, "singular source simple system") + rows[col], rows[pivot] = rows[pivot], rows[col] + scale = rows[col][col] + rows[col] = [x / scale for x in rows[col]] + for i in range(size): + if i != col and rows[i][col]: + factor = rows[i][col] + rows[i] = [x - factor * y for x, y in zip(rows[i], rows[col])] + return [row[size:] for row in rows] + + +def load_simple_labels(path, roots): + # Read one frozen numerical declaration; never import or execute geometry.py. + tree = ast.parse(path.read_text()) + assignments = [node for node in tree.body if isinstance(node, ast.Assign) + and any(isinstance(target, ast.Name) and target.id == "SIMPLE" + for target in node.targets)] + insist(len(assignments) == 1, "unique source SIMPLE declaration") + simple = ast.literal_eval(assignments[0].value) + insist(len(simple) == 8 and all(len(row) == 8 for row in simple), "SIMPLE shape") + transform = inverse(tuple(zip(*simple))) + labels = [] + for root in roots: + coefficients = [scalar(row, root) for row in transform] + insist(all(c.denominator == 1 for c in coefficients), "integral root coordinates") + labels.append(1 | sum((int(c) & 1) << (i + 1) for i, c in enumerate(coefficients))) + return labels + + +def linear_transfer(old, new): + insist(len(old) == len(new), "label transfer length") + equations = {} + for left, right in zip(old, new): + while left: + pivot = left.bit_length() - 1 + if pivot not in equations: + equations[pivot] = (left, right) + break + a, b = equations[pivot] + left, right = left ^ a, right ^ b + else: + insist(right == 0, "source label relations do not transfer") + insist(len(equations) == binary_rank(new) == 9, "invertible nine-bit transfer") + images = [] + for column in range(9): + left, right = 1 << column, 0 + while left: + a, b = equations[left.bit_length() - 1] + left, right = left ^ a, right ^ b + images.append(right) + insist(binary_rank(images) == 9, "singular label transfer") + insist([value & 1 for value in images] == [1] + [0] * 8, + "label transfer preserves the declared leading coordinate") + for left, right in zip(old, new): + image = 0 + for column in range(9): + if left >> column & 1: + image ^= images[column] + insist(image == right, "literal label transfer") + return images + + +def independent_model(): + roots, frame = reconstruct_roots() + ordinary = [[scalar(a, b) for b in roots] for a in roots] + insist(all(value % 4 == 0 for row in ordinary for value in row), "integral polar pairing") + pairing_rows = [sum(((value // 4) & 1) << j for j, value in enumerate(row)) + for row in ordinary] + basis_ids, selected = [], [] + for i, row in enumerate(pairing_rows): + if binary_rank(selected + [row]) > len(selected): + selected.append(row) + basis_ids.append(i) + insist(len(basis_ids) == 8, "independent polar rank") + residues = [sum(((ordinary[i][j] // 4) & 1) << k for k, j in enumerate(basis_ids)) + for i in range(120)] + insist(len(set(residues)) == 120, "injective independent residues") + basis_roots = [roots[i] for i in basis_ids] + q = {} + for code in range(256): + lift = tuple(sum(root[j] for i, root in enumerate(basis_roots) if code >> i & 1) + for j in range(8)) + residue = 0 + for i, root_id in enumerate(basis_ids): + if code >> i & 1: + residue ^= residues[root_id] + norm = scalar(lift, lift) + insist(norm % 8 == 0 and residue not in q, "independent lattice lift") + q[residue] = (norm // 8) & 1 + insist(len(q) == 256 and {x for x, value in q.items() if value} == set(residues), + "roots are exactly the quadratic ones") + insist(sum(1 - 2 * q[x] for x in range(256)) == 16, "positive ambient Gauss sign") + bilinear = [[q[x ^ y] ^ q[x] ^ q[y] for y in range(256)] for x in range(256)] + for x in range(256): + row = sum(bilinear[x][1 << j] << j for j in range(8)) + insist(all(bilinear[x][y] == ((row & y).bit_count() & 1) for y in range(256)), + "quadratic polarization is bilinear") + for i in range(120): + for j in range(120): + insist(bilinear[residues[i]][residues[j]] == ((ordinary[i][j] // 4) & 1), + "root/polar binding") + labels = [1 | residue << 1 for residue in residues] + source_geometry = ROOT / "research/p112-root-simplex-exclusion/geometry.py" + source_labels = load_simple_labels(source_geometry, roots) + simple_transfer = linear_transfer(source_labels, labels) + old_path = ROOT / "research/one-sided-decoders-all-m/data/data.json" + old = json.loads(old_path.read_text(), parse_float=Fraction) + insist(len(old["LAB"]) == 112 and all(type(x) is int and 0 < x < 512 and x & 1 + for x in old["LAB"]), "old declared labels") + old_roots = [positive_line(tuple(2 * Fraction(x) for x in row)) for row in old["L"]] + insist(len(old_roots) == len(set(old_roots)) == 112, "old live-root inventory") + insist(set(old_roots) == set(roots) - frame, "old live roots match paired-frame model") + old_frame = {positive_line(tuple(2 * Fraction(x) for x in row)) for row in old["F0"]} + insist(old_frame == frame, "old frame binding") + old_full = [positive_line(tuple(2 * Fraction(x) for x in row)) for row in old["E8"]] + insist(len(old_full) == len(set(old_full)) == 120 and set(old_full) == set(roots), + "old full-root binding") + root_id = {root: i for i, root in enumerate(roots)} + old_ids = [root_id[root] for root in old_roots] + old_transfer = linear_transfer(old["LAB"], [labels[i] for i in old_ids]) + insist(len(old["FC"]) == 112 and all(len(row) == 8 for row in old["FC"]), "FC shape") + code_rows = [tuple(row[j] for row in old["FC"]) for j in range(8)] + root_rows = [tuple(roots[i][j] for i in old_ids) for j in range(8)] + insist(rational_rank(code_rows) == rational_rank(root_rows) == 8, "source code ranks") + insist(rational_rank(code_rows + root_rows) == 8, "source FC/root-code equality") + return {"roots": roots, "frame": frame, "ordinary": ordinary, "residues": residues, + "labels": labels, "q": q, "bilinear": bilinear, "old_ids": old_ids, + "code_rows": code_rows, "simple_transfer": simple_transfer, + "old_transfer": old_transfer, + "source_hashes": {"geometry": sha256(source_geometry.read_bytes()).hexdigest(), + "data": sha256(old_path.read_bytes()).hexdigest()}} + + +def annihilators(): + """All ordinary-dot two-row RREF spaces, using leftmost pivots.""" + for p, q in combinations(range(8), 2): + free_a = [j for j in range(p + 1, 8) if j != q] + free_b = list(range(q + 1, 8)) + for code_a in range(1 << len(free_a)): + a = 1 << p + for i, column in enumerate(free_a): + a |= ((code_a >> i) & 1) << column + for code_b in range(1 << len(free_b)): + b = 1 << q + for i, column in enumerate(free_b): + b |= ((code_b >> i) & 1) << column + yield a, b + + +def section_census(model): + residues, ordinary = model["residues"], model["ordinary"] + bilinear, q = model["bilinear"], model["q"] + all_roots = (1 << 120) - 1 + live = sum(1 << i for i, root in enumerate(model["roots"]) if root not in model["frame"]) + off = [sum(1 << j for j, value in enumerate(row) if value) for row in ordinary] + masks = [(sum(1 << i for i, x in enumerate(residues) if not ((a & x).bit_count() & 1))) + for a in range(256)] + polar_to_normal = {sum(bilinear[x][1 << j] << j for j in range(8)): x for x in range(256)} + insist(len(polar_to_normal) == 256, "nonsingular independent polarity") + root_by_residue = {x: i for i, x in enumerate(residues)} + histogram, completions, qualifying = Counter(), {}, [] + directions = 0 + for a, b in annihilators(): + directions += 1 + perpendicular = (0, polar_to_normal[a], polar_to_normal[b], + polar_to_normal[a] ^ polar_to_normal[b]) + radical = tuple(x for x in perpendicular if not ((a & x).bit_count() & 1) + and not ((b & x).bit_count() & 1)) + for ca in range(2): + for cb in range(2): + section = (masks[a] if ca == 0 else all_roots ^ masks[a]) + section &= masks[b] if cb == 0 else all_roots ^ masks[b] + histogram[section.bit_count()] += 1 + insist(section.bit_count() <= 36, "independent rank-seven capacity") + for v in range(120): + count = (section & off[v]).bit_count() + insist(count <= 32, "root32 capacity") + if count < 29: + continue + insist(count == section.bit_count() == 32, "completion32 rigidity") + rv = residues[v] + insist(len(radical) == 4 and rv in radical, "completion radical") + isotropic = [x for x in radical if x and not q[x]] + insist(len(isotropic) == 1, "completion isotropic partner") + u = isotropic[0] + w = root_by_residue[rv ^ u] + insist(ordinary[v][w] == 0, "completion mate orthogonality") + for x in range(256): + in_section = ((a & x).bit_count() & 1) == ca + in_section &= ((b & x).bit_count() & 1) == cb + insist(in_section == (bilinear[rv][x] == bilinear[u][x] == 1), + "completion affine equations") + defect = off[v] & ~section + core = off[v] & off[w] + insist(defect == (core | (1 << v)) and core.bit_count() == 24, + "closed own-root defect") + insist((v, w) not in completions, "duplicate classified completion") + completions[v, w] = (a, b, ca, cb) + if (section & off[v] & live).bit_count() >= 29: + qualifying.append((v, w)) + expected = {(v, w) for v in range(120) for w in range(120) if ordinary[v][w] == 0} + insist(set(completions) == expected, "all orthogonal-mate completions classified") + insist(directions == 10795 and sum(histogram.values()) == 43180, + "complete ordinary-annihilator census") + return {"count": sum(histogram.values()), + "cardinality_histogram": {str(k): v for k, v in sorted(histogram.items())}, + "qualifying29": len(qualifying), + "completion_digest": sha256(json.dumps(sorted(qualifying), separators=(",", ":")).encode()).hexdigest()}, \ + {"annihilator_directions": directions, "full_completions": len(completions)} + + +def core_census(model): + ordinary, labels = model["ordinary"], model["labels"] + root_by_label = {label: i for i, label in enumerate(labels)} + histogram = Counter() + live = set(model["old_ids"]) + frame = set(range(120)) - live + optimal, per_word = [], Counter() + pair_count, small_flat_count = 0, 0 + for v, w in combinations(range(120), 2): + if ordinary[v][w] != 0: + continue + pair_count += 1 + core = [i for i in range(120) if ordinary[v][i] and ordinary[w][i]] + insist(len(core) == 24, "ordinary common-off core24") + basis, coordinates = coordinates_in_span([labels[i] for i in core]) + insist(len(basis) == 7, "core span has rank seven") + for functional in range(1, 1 << len(basis)): + low = {i for i in core if not ((coordinates[labels[i]] & functional).bit_count() & 1)} + size = len(low) + insist(size <= 16, "core six-space cap16") + histogram[size] += 1 + if size != 16 or low & frame: + continue + for normal, mate in ((v, w), (w, v)): + high = {i for i in live if i != normal and ordinary[normal][i] + and not ordinary[mate][i]} + target = {i for i in live if ordinary[normal][i]} + sparse = target - high - low + floor = 5 if normal in live else 8 + if len(sparse) != floor: + continue + insist(len(high) == 32 and high.isdisjoint(low), "uniform disjoint cover") + insist([binary_rank(labels[i] for i in part) for part in (high, low, sparse)] + == [7, 6, 4], "uniform sharp cover ranks") + if floor == 5: + insist(normal in sparse + and binary_rank(labels[i] for i in sparse - {normal}) == 3, + "uniform split-four rank") + four = sparse - {normal} + anchor = min(four) + closure_labels = {labels[i] for i in four} | { + labels[normal] ^ labels[anchor] ^ labels[i] for i in four} + insist(len(closure_labels) == 8 + and all(label & 1 and label in root_by_label + for label in closure_labels), + "independent small-flat closure has eight root labels") + closure = {root_by_label[label] for label in closure_labels} + insist(closure <= live, "independent small-flat roots are live") + insist({i for i in closure if ordinary[normal][i]} == sparse, + "independent small-flat nonzero evaluations are exactly sparse5") + extra_orthogonal = closure - sparse + insist(len(extra_orthogonal) == 3 + and all(ordinary[normal][i] == 0 for i in extra_orthogonal), + "independent small-flat three extra roots are orthogonal") + small_flat_count += 1 + if per_word[normal] == 0: + for i in live: + actual = sum(ordinary[normal][i] if i in part else 0 + for part in (high, low, sparse)) + insist(actual == ordinary[normal][i], "uniform actual coefficient identity") + optimal.append((normal, mate, sum(1 << i for i in low))) + per_word[normal] += 1 + insist(pair_count == 3780 and sum(histogram.values()) == pair_count * 127, + "complete core hyperplane census") + insist(all(per_word[i] == (3 if i in live else 945) for i in range(120)), + "all root normals have the classified optimum multiplicity") + insist(small_flat_count == 336, "independent nonframe small-flat inventory") + return {"pairs": pair_count, "forms_per_pair": 127, + "aggregate_histogram": {str(k): v for k, v in sorted(histogram.items())}, + "uniform_sharpness": {"nonframe_words": 112, "frame_words": 8, + "five_site_covers": sum(per_word[i] for i in live), + "eight_site_covers": sum(per_word[i] for i in frame), + "covers_per_nonframe_word": 3, "covers_per_frame_word": 945, + "partition_ranks": [7, 6, 4], + "nonframe_small_flats": small_flat_count, + "nonframe_small_flat_roots": 8, + "extra_orthogonal_roots": 3, + "cover_digest": sha256(json.dumps(sorted(optimal), + sort_keys=True, separators=(",", ":")).encode()).hexdigest()}} + + +def sharp_witness(model): + roots, labels, ordinary = model["roots"], model["labels"], model["ordinary"] + by_root = {root: i for i, root in enumerate(roots)} + v = by_root[(2, 0, 2, 0, 0, 0, 0, 0)] + w = by_root[(2, 0, -2, 0, 0, 0, 0, 0)] + live = set(model["old_ids"]) + x = {i for i in live if i != v and ordinary[v][i] and not ordinary[w][i]} + y = set() + for i in (0, 2): + for j in range(4, 8): + for sign in (-1, 1): + row = [0] * 8 + row[i], row[j] = 2, 2 * sign + y.add(by_root[positive_line(row)]) + small = set() + for i, j in ((1, 2), (0, 3)): + for sign in (-1, 1): + row = [0] * 8 + row[i], row[j] = 2, 2 * sign + small.add(by_root[positive_line(row)]) + sparse = small | {v} + target = {i for i in live if ordinary[v][i]} + insist(not (x & y or x & sparse or y & sparse), "witness supports overlap") + insist(x | y | sparse == target, "witness exact support partition") + sizes = [len(sparse), len(y), len(x)] + ranks = [binary_rank(labels[i] for i in part) for part in (sparse, y, x)] + insist(sizes == [5, 16, 32] and ranks == [4, 6, 7], "sharp witness boundary") + four = (x, y, small, {v}) + split_sizes = [len(part) for part in four] + split_ranks = [binary_rank(labels[i] for i in part) for part in four] + insist(split_sizes == [32, 16, 4, 1] and split_ranks == [7, 6, 3, 1], "slack9 ranks") + pieces = [tuple(ordinary[v][i] if i in part else 0 for i in model["old_ids"]) for part in four] + for column, i in enumerate(model["old_ids"]): + insist(sum(piece[column] for piece in pieces) == ordinary[v][i], "scalar codeword identity") + code_rank = rational_rank(model["code_rows"]) + pieces_rank = rational_rank(pieces) + joint_rank = rational_rank(model["code_rows"] + pieces) + insist((code_rank, pieces_rank, joint_rank) == (8, 4, 11), "slack9 exact code intersection") + # For disjoint supports, a determinant matching between any new basis and + # these four pieces makes each new rank dominate a distinct old rank. + # Thus their rank sum is the actual minimum basis cost, without a search. + old_index = {root_id: i for i, root_id in enumerate(model["old_ids"])} + return {"sizes": sizes, "ranks": ranks, + "sparse_indices": sorted(old_index[i] for i in sparse), + "slack9": {"sizes": split_sizes, "ranks": split_ranks, + "code_rank": code_rank, "pieces_rank": pieces_rank, + "joint_rank": joint_rank, "cost": sum(split_ranks)}} + + +def source_callers(): + callers = [] + pattern = re.compile(r"^d (\d+) slack (\d+) .*?(\[\[.*\]\])$", re.MULTILINE) + for t in (2, 3): + path = PACKAGE / f"inputs/pr3154/land_e{t}_k8.out" + matches = list(pattern.finditer(path.read_text())) + insist(matches, "empty CONJG2 source list") + for match in matches: + d, slack = map(int, match.group(1, 2)) + for weights in ast.literal_eval(match.group(3)): + insist(all(type(w) is int and 1 <= w <= 7 for w in weights), + "source caller weights") + insist(len(weights) == d + t and sum(weights) - 8 * d == slack, + "source caller dimension/slack") + remaining = sorted(weights, reverse=True) + for _ in range(d - 1): + if 7 not in remaining: + break + remaining.remove(7) + else: + capacities = {1: 1, 2: 2, 3: 4} + if remaining[:2] == [7, 6] and all(w in capacities for w in remaining[2:]): + if sum(capacities[w] for w in remaining[2:]) <= 4: + callers.append({"t": t, "d": d, "slack": slack, + "weights": sorted(weights, reverse=True)}) + callers.sort(key=lambda row: (row["t"], row["d"], row["slack"], row["weights"])) + expected = {(2, 1, (7, 6, 2)), (2, 1, (7, 6, 3)), + (2, 2, (7, 7, 6, 2)), (2, 2, (7, 7, 6, 3)), + (3, 1, (7, 6, 1, 1)), (3, 1, (7, 6, 2, 1)), + (3, 2, (7, 7, 6, 1, 1)), (3, 2, (7, 7, 6, 2, 1)), + (3, 2, (7, 7, 6, 2, 2))} + insist(len(callers) == len(expected) + and {(row["t"], row["d"], tuple(row["weights"])) for row in callers} == expected, + "exact nine source caller implications") + return callers + + +def no_coloops(rows): + """Rank and coverage by fundamental dependencies, without a dual census.""" + pivots, dependent = {}, 0 + for position, original in enumerate(rows): + value, support = original, 1 << position + while value: + column = (value & -value).bit_length() - 1 + if column not in pivots: + pivots[column] = value, support + break + row, witness = pivots[column] + value ^= row + support ^= witness + else: + dependent |= support + return len(pivots), dependent == (1 << len(rows)) - 1 + + +def frame_plane_census(model): + labels, ordinary = model["labels"], model["ordinary"] + live = set(model["old_ids"]) + frame = sorted(set(range(120)) - live) + phases = [(normal, {i for i in live if (normal & labels[i]).bit_count() & 1}) + for normal in range(1, 512)] + records, minimum = [], 112 + for i in frame: + matched = [outside for normal, outside in phases + if not ((normal & labels[i]).bit_count() & 1)] + insist(len(matched) == 255, "all matched independent hyperplanes") + for j in frame: + if i == j: + continue + for coefficient in (1, -1, 2): + off = {k for k in live if ordinary[i][k] + coefficient * ordinary[j][k]} + for outside in matched: + deleted = sorted(off & outside) + insist(no_coloops([labels[k] for k in deleted]) == (8, True), + "independent frame-plane rank/no-coloop criterion") + minimum = min(minimum, len(deleted)) + records.append((i, j, coefficient, sum(1 << k for k in deleted))) + insist(len(records) == 42840, "independent frame-plane census inventory") + return {"cases": len(records), "minimum_deleted": minimum, + "rank": 8, "all_one_point_deletions_preserve_rank": True, + "case_digest": sha256(json.dumps(sorted(records), sort_keys=True, + separators=(",", ":")).encode()).hexdigest()} + + +def invoice_profiles(): + sizes = (0, 1, 2, 4, 8, 12, 20, 36) + answer = {} + for count, total in ((3, 16), (4, 16), (4, 17)): + rows = [row for row in product(range(1, 8), repeat=count) + if all(row[i] >= row[i + 1] for i in range(count - 1)) and sum(row) <= total] + survivors = [] + for row in rows: + crude = sum(sizes[w] for w in row) + if crude < 53: + continue + if crude < 70 and sum(min(sizes[w], 32) for w in row) < 53: + continue + eliminated = False + for i, wi in enumerate(row): + for j, wj in enumerate(row): + other = [w for k, w in enumerate(row) if k not in (i, j)] + if i != j and wi == 7 and wj == 6 and all(w <= 3 for w in other): + eliminated |= sum(sizes[w] for w in other) <= 4 + if not eliminated: + survivors.append(list(row)) + answer[str(count) + ":" + str(total)] = {"examined": len(rows), "survivors": sorted(survivors)} + return answer + + +def root_plane_inventory(model): + roots = model["roots"] + planes = set() + for i, j in combinations(range(120), 2): + a, b = roots[i], roots[j] + ab = scalar(a, b) + denominator = 64 - ab * ab + members = [] + for k, c in enumerate(roots): + ac, bc = scalar(a, c), scalar(b, c) + left, right = 8 * ac - ab * bc, 8 * bc - ab * ac + if all(denominator * z == left * x + right * y for x, y, z in zip(a, b, c)): + members.append(k) + insist(2 <= len(members) <= 3, "independent rational root-plane cap") + planes.add(sum(1 << k for k in members)) + counts = Counter(mask.bit_count() for mask in planes) + frame = sorted(set(range(120)) - set(model["old_ids"])) + active_counts = Counter() + for plane in planes: + if plane.bit_count() != 3: + continue + members = [roots[k] for k in range(120) if plane >> k & 1] + active = sum(any(scalar(a, roots[f]) for a in members) for f in frame) + contained_frame = sum((plane >> f) & 1 for f in frame) + insist((active, contained_frame) in ((4, 1), (6, 0)), "independent A2 active axes") + active_counts[active] += 1 + insist(active_counts == {4: 224, 6: 896}, "independent A2 frame-support inventory") + return {"root_pairs": 7140, "distinct_planes": len(planes), + "root_line_histogram": {str(k): v for k, v in sorted(counts.items())}, + "a2_active_axes": {str(k): v for k, v in sorted(active_counts.items())}, + "plane_digest": sha256(json.dumps(sorted(planes), separators=(",", ":")).encode()).hexdigest()} + + +def four_axis_inventory(model): + frame = sorted(set(range(120)) - set(model["old_ids"])) + counts = Counter() + for axes in combinations(frame, 4): + forms = Counter() + for site in model["old_ids"]: + row = tuple(scalar(model["roots"][site], model["roots"][a]) // 4 for a in axes) + lead = next((x for x in row if x), 1) + forms[tuple(lead * x for x in row)] += 1 + inventory = Counter((sum(x != 0 for x in row), multiplicity) + for row, multiplicity in forms.items()) + if inventory == {(0, 8): 1, (2, 8): 12, (4, 1): 8}: + counts['block'] += 1 + else: + insist(inventory == {(1, 8): 4, (2, 4): 12, (3, 2): 16}, + "independent nonblock restricted forms") + counts['nonblock'] += 1 + insist(counts == {'block': 14, 'nonblock': 56}, "independent four-axis set count") + return {'sets': 70, 'block_sets': counts['block'], 'nonblock_sets': counts['nonblock'], + 'block_multiplicities': {'zero': 8, 'pair': 8, 'four': 1}, + 'nonblock_multiplicities': {'singleton': 8, 'pair': 4, 'triple': 2}} + + +def pencil_applications(): + sizes = (0, 1, 2, 4, 8, 12, 20, 36) + rows, shared = [], [] + pattern = re.compile(r"^d (\d+) slack (\d+) .*?(\[\[.*\]\])$", re.MULTILINE) + for t in (2, 3): + text = (PACKAGE / f"inputs/pr3154/land_e{t}_k8.out").read_text() + for match in pattern.finditer(text): + d, slack = map(int, match.group(1, 2)) + if d < 2: + continue + for weights in ast.literal_eval(match.group(3)): + if t == 2 and any(all(w <= cap for w, cap in zip(sorted( + [w for i, w in enumerate(weights) if i not in killed], reverse=True), + (7, 7, 5, 5))) for killed in combinations(range(len(weights)), d - 2)): + shared.append((t, d, slack, weights)) + found = False + for killed in combinations(range(len(weights)), d - 2): + remaining = [w for i, w in enumerate(weights) if i not in killed] + for main in combinations(range(len(remaining)), 4): + if all(remaining[i] <= 6 for i in main) and sum( + sizes[w] for i, w in enumerate(remaining) if i not in main) <= 9: + found = True + break + if found: + break + if found: + rows.append((t, d, slack, weights)) + counts = Counter(row[0] for row in rows) + return {"t2": counts[2], "t3": counts[3], "total": len(rows), + "application_digest": sha256(json.dumps(sorted(rows), sort_keys=True, + separators=(",", ":")).encode()).hexdigest(), + "shared_frame_7755": shared} + + +def frame_sign_inventory(model): + labels, dots, residues = model["labels"], model["ordinary"], model["residues"] + frame = sorted(set(range(120)) - set(model["old_ids"])) + records = [] + for a, b in combinations(frame, 2): + common = [i for i in range(120) if i not in (a, b) and dots[a][i] and dots[b][i]] + same = {i for i in common if (dots[a][i] > 0) == (dots[b][i] > 0)} + opposite = set(common) - same + insist(len(common) == 24 and len(same) == len(opposite) == 12, + "independent frame sign-half cardinalities") + insist(binary_rank(labels[i] for i in same) == binary_rank(labels[i] for i in opposite) == 7, + "independent sign-half binary rank") + classes = {} + for i in common: + key = min(residues[i], residues[i] ^ residues[a], residues[i] ^ residues[b], + residues[i] ^ residues[a] ^ residues[b]) + classes.setdefault(key, []).append(i) + insist(len(classes) == 6 and all(len(v) == 4 and len(set(v) & same) == 2 + for v in classes.values()), + "independent sign-half quotient-fiber multiplicities") + records.append((a, b, sum(1 << i for i in same), sum(1 << i for i in opposite))) + return {"frame_pairs": 28, "sign_halves": 56, "half_size": 12, + "binary_rank": 7, "radical_fibers_per_pair": 6, "half_points_per_fiber": 2, + "case_digest": sha256(json.dumps(records, sort_keys=True, + separators=(",", ":")).encode()).hexdigest()} + + +def root764_inventory(model): + labels, residues = model["labels"], model["residues"] + bilinear = model["bilinear"] + all_roots = (1 << len(labels)) - 1 + polar_one = [sum(1 << i for i, residue in enumerate(residues) + if bilinear[normal][residue]) for normal in range(256)] + sections, root_high_pairs = set(), 0 + for root in residues: + root_sections, generated = set(), 0 + for second in range(256): + if not bilinear[root][second]: + continue + for offset in range(2): + second_slice = polar_one[second] if offset else all_roots ^ polar_one[second] + section = polar_one[root] & second_slice + insist(section.bit_count() == 28, "independent root764 complementary section28") + root_sections.add(section) + generated += 1 + insist(generated == 256 and len(root_sections) == 128, + "independent root764 second-form duplicate multiplicity") + root_high_pairs += len(root_sections) + sections.update(root_sections) + insist(root_high_pairs == 15360, "independent root764 root/high inventory") + expected_histogram = Counter({0: 1, 12: 63, 16: 63}) + for section in sorted(sections): + section_labels = [labels[i] for i in range(len(labels)) if section >> i & 1] + basis, coordinates = coordinates_in_span(section_labels) + insist(len(basis) == 7, "independent root764 complementary label rank7") + points = [coordinates[label] for label in section_labels] + histogram = Counter(sum(not ((point & functional).bit_count() & 1) + for point in points) + for functional in range(1, 1 << len(basis))) + insist(histogram == expected_histogram, + "independent root764 complementary hyperplane histogram") + return {"root_high_pairs": root_high_pairs, "c28_sections": len(sections), + "c28_section_histogram": {str(k): v for k, v in sorted(expected_histogram.items())}, + "c28_digest": sha256(json.dumps(sorted(sections), + separators=(",", ":")).encode()).hexdigest()} + + +def quotient6_inventory(): + # Deduplicate actual point sets, rather than selecting annihilator bases. + roots = {x for x in range(64) if ((x & (x >> 1) & 21).bit_count() & 1)} + hyperplanes = [frozenset(x for x in range(64) if (x & a).bit_count() % 2 == offset) + for a in range(1, 64) for offset in range(2)] + four = {left & right for left, right in combinations(hyperplanes, 2) + if len(left & right) == 16} + insist(len(roots) == 28 and len(hyperplanes) == 126 and len(four) == 2604, + "independent six-quadric affine inventory") + histograms = {4: Counter(len(flat & roots) for flat in four), + 5: Counter(len(flat & roots) for flat in hyperplanes)} + insist(max(histograms[4]) == 10 and max(histograms[5]) == 16, + "independent six-quadric affine capacities") + return {str(d): {str(k): v for k, v in sorted(counts.items())} + for d, counts in histograms.items()} + + +def d2_profile_inventory(): + capacities = {1: 1, 2: 2, 3: 4, 4: 8, 5: 12, 6: 20, 7: 36} + answer = {} + for length, budget in ((4, 24), (5, 25)): + # Build ordered positive partitions recursively, not combinations-with-replacement. + def partitions(size, ceiling, remaining): + if size == 0: + yield [] + return + for first in range(1, min(ceiling, remaining - size + 1) + 1): + for tail in partitions(size - 1, first, remaining - first): + yield [first] + tail + rows = list(partitions(length, 7, budget)) + kept = [] + for row in rows: + if max(row) < 7: + continue # The written four-six lemma, or 55555 and distance53. + others = row[1:] + capacity = sum(capacities[x] for x in others) + root_capacity = sum(min(32, capacities[x]) for x in others) + if capacity < 53 or (capacity < 70 and root_capacity < 53): + continue + tails = others.copy() + if 6 in tails and 7 in tails: + tails.remove(6) + tails.remove(7) + if sum(capacities[x] for x in tails) < 5: + continue + kept.append(row) + forbidden = [[7, 7, 5, 5], [7, 7, 6, 4]] if length == 4 else [[7, 6, 6, 5, 1]] + insist(all(row in kept for row in forbidden), "independent intrinsic d2 profiles") + answer[str(length) + ':' + str(budget)] = { + 'examined': len(rows), 'intrinsic_exclusions': forbidden, + 'actual_profiles': sorted(row for row in kept if row not in forbidden)} + return answer + + +def run(): + model = independent_model() + affine, extra = section_census(model) + extra.update({"coordinate_method": "independent root polar-pairing basis", + "section_method": "ordinary-dot left-pivot RREF annihilators", + "source_hashes": model["source_hashes"], + "simple_label_transfer": model["simple_transfer"], + "old_label_transfer": model["old_transfer"]}) + return {"root_inventory": {"full": len(model["roots"]), "live": len(model["old_ids"]), + "frame": len(model["frame"])}, + "affine6_sections": affine, "core_sections": core_census(model), + "witness": sharp_witness(model), "callers": source_callers(), + "frame_plane": frame_plane_census(model), + "invoice_profiles": invoice_profiles(), + "root_planes": root_plane_inventory(model), "pencil_callers": pencil_applications(), + "frame_sign_halves": frame_sign_inventory(model), + "root764": root764_inventory(model), + "quotient6": quotient6_inventory(), + "d2_profiles": d2_profile_inventory(), + "four_axes": four_axis_inventory(model), + "independent_engine": extra} + + +if __name__ == "__main__": + print(json.dumps(run(), indent=2, sort_keys=True)) diff --git a/research/p112-six-seven-supplement/independent_d2.py b/research/p112-six-seven-supplement/independent_d2.py new file mode 100644 index 0000000000..9198e677df --- /dev/null +++ b/research/p112-six-seven-supplement/independent_d2.py @@ -0,0 +1,213 @@ +"""Independent characteristic-zero low-space certificates for the d2 controls. + +conorholds, substantial OpenAI Codex assistance. Apache-2.0. +Retains independent.py's PR3161/3162, joaqcoo and DreamingOfClouds E8/P112 +geometry and label lineage; predecessor credits remain in SOURCES.json. +Only its independent reconstruction, RREF annihilators and rank helpers are +loaded. Full evaluation matrices over F5 replace the primary F3 differences. +On each flat complement, disjoint sign payloads give T-evaluation rank r +in both F5 and characteristic zero. Rank r+6 modulo five supplies a nonzero +integer minor, so the six quotient columns remain independent modulo T in +characteristic zero. Thus every kernel vector lies entirely in T. +""" + +from hashlib import sha256 +import json +from pathlib import Path +import sys +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parent.parent +INPUTS = {"research/p112-root-simplex-exclusion/geometry.py", + "research/one-sided-decoders-all-m/data/data.json"} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def regular_bytes(root, name): + relative = Path(name) + need(not relative.is_absolute() and relative.parts + and all(part not in (".", "..") for part in relative.parts), + "noncanonical input path") + need(all(not path.is_symlink() for path in (root, *root.parents)), + "linked input ancestor") + path = root + for part in relative.parts: + path /= part + need(not path.is_symlink(), "linked input") + need(path.is_file(), "missing regular input") + return path.read_bytes() + + +def authenticate(): + def pairs(items): + result = {} + for key, value in items: + need(key not in result, "duplicate source JSON key") + result[key] = value + return result + + def constant(value): + raise ValueError("nonfinite source JSON value: " + value) + + sources = json.loads(regular_bytes(PACKAGE, "SOURCES.json"), + object_pairs_hook=pairs, parse_constant=constant) + need(type(sources["schema_version"]) is int and sources["schema_version"] == 1, + "source schema") + rows = [row for row in sources["files"] if row["usage"] == "input"] + need(len(rows) == 2 and {row["path"] for row in rows} == INPUTS, + "exact live-input inventory") + hashes = {} + for row in rows: + actual = sha256(regular_bytes(ROOT, row["path"])).hexdigest() + need(actual == row["sha256"], "live-input SHA256 differs: " + row["path"]) + hashes[row["path"]] = actual + return hashes + + +def independent_helpers(): + module = ModuleType("independent_d2_geometry") + path = PACKAGE / "independent.py" + module.__file__ = str(path) + exec(compile(regular_bytes(PACKAGE, "independent.py"), str(path), "exec"), + module.__dict__) + return (module.independent_model, module.annihilators, + module.binary_rank, module.rational_rank) + + +def rank_mod5(rows, width, target): + """Gaussian elimination on every column of the full evaluation matrix.""" + pivots = [None] * width + rank = 0 + for original in rows: + need(len(original) == width, "mod-five matrix width") + row = [value % 5 for value in original] + for column in range(width): + if not row[column]: + continue + pivot = pivots[column] + if pivot is not None: + factor = row[column] + for k in range(column, width): + row[k] = (row[k] - factor * pivot[k]) % 5 + else: + inverse = pow(row[column], -1, 5) + pivots[column] = tuple((inverse * value) % 5 for value in row) + rank += 1 + if rank == target: + return rank + break + return rank + + +def run(): + hashes = authenticate() + build, annihilators, binary_rank, rational_rank = independent_helpers() + model = build() + roots, dots = model["roots"], model["ordinary"] + live = [i for i, root in enumerate(roots) if root not in model["frame"]] + frame = [i for i, root in enumerate(roots) if root in model["frame"]] + need(len(live) == 112 and len(frame) == 8, "live/frame inventories") + a, b = frame[:2] + ca = {s: dots[a][s] // 4 for s in live} + cb = {s: dots[b][s] // 4 for s in live} + parts = [[s for s in live if ca[s] and not cb[s]], + [s for s in live if cb[s] and not ca[s]], + [s for s in live if ca[s] * cb[s] > 0], + [s for s in live if ca[s] * cb[s] < 0]] + need([len(part) for part in parts] == [32, 32, 12, 12], "piece sizes") + pivot = next((s for s in parts[0] if ca[s] == 1), None) + need(pivot is not None, "positive exclusive-A unit site") + code = [[dots[f][s] // 4 for s in live] for f in frame] + need(rational_rank(code) == 8, "frame-code dimension") + quotient = [tuple(dots[f][s] // 4 for f in frame[2:]) for s in live] + residues, labels = model["residues"], model["labels"] + cases, failed_control = [], None + + for t in (2, 3): + pieces = [part.copy() for part in parts] + if t == 3: + pieces[0].remove(pivot) + pieces.append([pivot]) + group = {s: j for j, part in enumerate(pieces) for s in part} + need(len(group) == sum(map(len, pieces)), "overlapping low pieces") + payload = {s: (cb[s] if j == 1 else ca[s]) for s, j in group.items()} + need(all(abs(value) == 1 for value in payload.values()), "low payload is not a sign") + low = [[payload[s] if group.get(s) == j else 0 for s in live] + for j in range(len(pieces))] + weights = [binary_rank(labels[s] for s in part) for part in pieces] + need(weights == [7, 7, 7, 7] + ([1] if t == 3 else []), "binary piece weights") + dimension = 8 + t + need(rational_rank(low) == t + 2, "low-piece independence") + need(rational_rank(low + code[2:]) == dimension + and rational_rank(code + low) == dimension, "code-plus-low dimensions") + # These are integer evaluations in basis order (T pieces, six frame words). + evaluations = [] + for position, s in enumerate(live): + head = [0] * len(pieces) + if s in group: + head[group[s]] = payload[s] + evaluations.append(tuple(head) + quotient[position]) + + directions = flats = 0 + t_rank_counts = {} + for u, v in annihilators(): + directions += 1 + sections = [[], [], [], []] + for position, s in enumerate(live): + offset = (((u & residues[s]).bit_count() & 1) << 1 + | ((v & residues[s]).bit_count() & 1)) + sections[offset].append(position) + for offset in range(4): + complement = [position for other in range(4) if other != offset + for position in sections[other]] + meeting = {group[live[position]] for position in complement + if live[position] in group} + # Disjoint nonzero sign payloads give rank(T_eval)=len(meeting). + t_rank = len(meeting) + expected = t_rank + 6 + actual = rank_mod5((evaluations[i] for i in complement), dimension, expected) + need(actual == expected, "affine-six complement has a quotient kernel") + if failed_control is None: + column = len(pieces) + mutant = (row[:column] + (0,) + row[column + 1:] + for row in (evaluations[i] for i in complement)) + damaged = rank_mod5(mutant, dimension, expected) + need(damaged == expected - 1, "zeroed quotient-column control did not fail") + failed_control = {"t": t, "annihilators": [u, v], + "offset": [offset >> 1, offset & 1], + "zeroed_quotient_column": 0, + "rank_before": actual, "rank_after": damaged} + t_rank_counts[t_rank] = t_rank_counts.get(t_rank, 0) + 1 + flats += 1 + need(directions == 10795 and flats == 43180, "complete ordinary-dot affine-six coverage") + cases.append({"t": t, "d": 2, "dimension_T": t + 2, "dimension_S": dimension, + "piece_sizes": list(map(len, pieces)), "piece_weights": weights, + "quotient_dimension": 6, "annihilator_directions": directions, + "affine6_flats": flats, + "complement_T_rank_counts": {str(k): v for k, v in sorted(t_rank_counts.items())}}) + + return {"scope": "independent-d2-low-space-certificates", "field": 5, + "source_sha256": hashes, "frame_pair": [roots[a], roots[b]], + "unit_site": roots[pivot], "cases": cases, "failed_control": failed_control} + + +def main(): + try: + result = run() + except (OSError, ValueError, KeyError, TypeError, RuntimeError) as error: + print("FAIL_P112_INDEPENDENT_D2: " + str(error), file=sys.stderr) + return 1 + print(json.dumps(result, sort_keys=True, separators=(",", ":"), allow_nan=False)) + print("PASS_P112_INDEPENDENT_D2 field=5 cases=2 affine6_per_case=43180 " + "scope=independent-low-space-certificates") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/research/p112-six-seven-supplement/inputs/pr3154/NOTICE.md b/research/p112-six-seven-supplement/inputs/pr3154/NOTICE.md new file mode 100644 index 0000000000..2d91874097 --- /dev/null +++ b/research/p112-six-seven-supplement/inputs/pr3154/NOTICE.md @@ -0,0 +1 @@ +Verbatim output excerpts from PR3154 by DreamingOfClouds, prepared with Anthropic Claude assistance, under Apache-2.0. Source commit and original paths are recorded in SOURCES.json. These retained lists identify nine applications; their global completeness and normalization assumptions are not imported. diff --git a/research/p112-six-seven-supplement/inputs/pr3154/land_e2_k8.out b/research/p112-six-seven-supplement/inputs/pr3154/land_e2_k8.out new file mode 100644 index 0000000000..c1457a474a --- /dev/null +++ b/research/p112-six-seven-supplement/inputs/pr3154/land_e2_k8.out @@ -0,0 +1,24 @@ +d 1 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 6, 2], [7, 7, 1]] +d 1 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 6, 3], [7, 7, 2]] +d 2 slack 6 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 7, 6, 2], [7, 7, 7, 1]] +d 2 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 7, 6, 3], [7, 7, 7, 2]] +d 2 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 4} [[6, 6, 6, 6], [7, 7, 5, 5], [7, 7, 6, 4], [7, 7, 7, 3]] +d 3 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 3} [[7, 6, 6, 6, 6], [7, 7, 7, 5, 5], [7, 7, 7, 6, 4]] +d 3 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 3} [[7, 7, 6, 6, 6], [7, 7, 7, 6, 5], [7, 7, 7, 7, 4]] +d 4 slack 7 {'LP': 0, 'BASIS': 2, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 4]] +d 4 slack 8 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 5]] +d 5 slack 6 {'LP': 0, 'BASIS': 2, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 4]] +d 5 slack 7 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 5]] +d 5 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 6]] +d 6 slack 5 {'LP': 0, 'BASIS': 2, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 4]] +d 6 slack 6 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 5]] +d 6 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 6]] +d 6 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7]] +d 7 slack 4 {'LP': 0, 'BASIS': 2, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 4]] +d 7 slack 5 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 5]] +d 7 slack 6 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 6]] +d 7 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 7]] +d 8 slack 3 {'LP': 0, 'BASIS': 2, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 7, 4]] +d 8 slack 4 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 7, 5]] +d 8 slack 5 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 7, 6]] +d 8 slack 6 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7]] diff --git a/research/p112-six-seven-supplement/inputs/pr3154/land_e3_k8.out b/research/p112-six-seven-supplement/inputs/pr3154/land_e3_k8.out new file mode 100644 index 0000000000..5d843f97b1 --- /dev/null +++ b/research/p112-six-seven-supplement/inputs/pr3154/land_e3_k8.out @@ -0,0 +1,31 @@ +d 1 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 6, 1, 1]] +d 1 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 6, 2, 1], [7, 7, 1, 1]] +d 2 slack 6 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 6, 1, 1]] +d 2 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 2} [[7, 7, 6, 2, 1], [7, 7, 7, 1, 1]] +d 2 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 4} [[7, 7, 5, 4, 1], [7, 7, 6, 2, 2], [7, 7, 6, 3, 1], [7, 7, 7, 2, 1]] +d 3 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 2, 'E2TRIPLE': 0, 'SURV': 3} [[6, 6, 6, 6, 6, 1], [7, 7, 7, 5, 4, 1], [7, 7, 7, 6, 3, 1]] +d 3 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 10} [[6, 6, 6, 6, 4, 4], [6, 6, 6, 6, 5, 3], [6, 6, 6, 6, 6, 2], [7, 6, 6, 6, 6, 1], [7, 7, 6, 6, 5, 1], [7, 7, 7, 5, 4, 2], [7, 7, 7, 5, 5, 1], [7, 7, 7, 6, 3, 2], [7, 7, 7, 6, 4, 1], [7, 7, 7, 7, 3, 1]] +d 4 slack 6 {'LP': 0, 'BASIS': 4, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 3} [[6, 6, 6, 6, 6, 4, 4], [6, 6, 6, 6, 6, 5, 3], [6, 6, 6, 6, 6, 6, 2]] +d 4 slack 7 {'LP': 0, 'BASIS': 6, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 7} [[6, 6, 6, 6, 5, 5, 5], [6, 6, 6, 6, 6, 5, 4], [6, 6, 6, 6, 6, 6, 3], [7, 6, 6, 6, 6, 4, 4], [7, 6, 6, 6, 6, 5, 3], [7, 6, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 3, 1]] +d 4 slack 8 {'LP': 0, 'BASIS': 4, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 14} [[6, 6, 6, 6, 6, 5, 5], [6, 6, 6, 6, 6, 6, 4], [7, 6, 6, 6, 5, 5, 5], [7, 6, 6, 6, 6, 5, 4], [7, 6, 6, 6, 6, 6, 3], [7, 7, 6, 6, 6, 4, 4], [7, 7, 6, 6, 6, 5, 3], [7, 7, 6, 6, 6, 6, 2], [7, 7, 7, 6, 6, 5, 2], [7, 7, 7, 7, 4, 4, 4], [7, 7, 7, 7, 5, 4, 3], [7, 7, 7, 7, 5, 5, 2], [7, 7, 7, 7, 7, 3, 2], [7, 7, 7, 7, 7, 4, 1]] +d 5 slack 5 {'LP': 2, 'BASIS': 4, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 4} [[6, 6, 6, 6, 6, 6, 5, 4], [7, 6, 6, 6, 6, 6, 4, 4], [7, 6, 6, 6, 6, 6, 5, 3], [7, 6, 6, 6, 6, 6, 6, 2]] +d 5 slack 6 {'LP': 0, 'BASIS': 6, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 9} [[6, 6, 6, 6, 6, 6, 5, 5], [6, 6, 6, 6, 6, 6, 6, 4], [7, 6, 6, 6, 6, 5, 5, 5], [7, 6, 6, 6, 6, 6, 5, 4], [7, 6, 6, 6, 6, 6, 6, 3], [7, 7, 6, 6, 6, 6, 4, 4], [7, 7, 6, 6, 6, 6, 5, 3], [7, 7, 6, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 3, 1]] +d 5 slack 7 {'LP': 0, 'BASIS': 4, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 15} [[6, 6, 6, 6, 6, 6, 6, 5], [7, 6, 6, 6, 6, 6, 5, 5], [7, 6, 6, 6, 6, 6, 6, 4], [7, 7, 6, 6, 6, 5, 5, 5], [7, 7, 6, 6, 6, 6, 5, 4], [7, 7, 6, 6, 6, 6, 6, 3], [7, 7, 7, 6, 6, 6, 4, 4], [7, 7, 7, 6, 6, 6, 5, 3], [7, 7, 7, 6, 6, 6, 6, 2], [7, 7, 7, 7, 6, 6, 5, 2], [7, 7, 7, 7, 7, 4, 4, 4], [7, 7, 7, 7, 7, 5, 4, 3], [7, 7, 7, 7, 7, 5, 5, 2], [7, 7, 7, 7, 7, 7, 3, 2], [7, 7, 7, 7, 7, 7, 4, 1]] +d 5 slack 8 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 17} [[6, 6, 6, 6, 6, 6, 6, 6], [7, 6, 6, 6, 6, 6, 6, 5], [7, 7, 6, 6, 6, 6, 5, 5], [7, 7, 6, 6, 6, 6, 6, 4], [7, 7, 7, 6, 6, 5, 5, 5], [7, 7, 7, 6, 6, 6, 5, 4], [7, 7, 7, 6, 6, 6, 6, 3], [7, 7, 7, 7, 6, 6, 4, 4], [7, 7, 7, 7, 6, 6, 5, 3], [7, 7, 7, 7, 6, 6, 6, 2], [7, 7, 7, 7, 7, 5, 4, 4], [7, 7, 7, 7, 7, 5, 5, 3], [7, 7, 7, 7, 7, 6, 4, 3], [7, 7, 7, 7, 7, 6, 5, 2], [7, 7, 7, 7, 7, 7, 3, 3], [7, 7, 7, 7, 7, 7, 4, 2], [7, 7, 7, 7, 7, 7, 5, 1]] +d 6 slack 4 {'LP': 7, 'BASIS': 4, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 6, 6, 6, 6, 6, 6, 2]] +d 6 slack 5 {'LP': 2, 'BASIS': 6, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 8} [[7, 6, 6, 6, 6, 6, 6, 6, 4], [7, 7, 6, 6, 6, 6, 5, 5, 5], [7, 7, 6, 6, 6, 6, 6, 5, 4], [7, 7, 6, 6, 6, 6, 6, 6, 3], [7, 7, 7, 6, 6, 6, 6, 4, 4], [7, 7, 7, 6, 6, 6, 6, 5, 3], [7, 7, 7, 6, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 3, 1]] +d 6 slack 6 {'LP': 0, 'BASIS': 4, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 16} [[6, 6, 6, 6, 6, 6, 6, 6, 6], [7, 6, 6, 6, 6, 6, 6, 6, 5], [7, 7, 6, 6, 6, 6, 6, 5, 5], [7, 7, 6, 6, 6, 6, 6, 6, 4], [7, 7, 7, 6, 6, 6, 5, 5, 5], [7, 7, 7, 6, 6, 6, 6, 5, 4], [7, 7, 7, 6, 6, 6, 6, 6, 3], [7, 7, 7, 7, 6, 6, 6, 4, 4], [7, 7, 7, 7, 6, 6, 6, 5, 3], [7, 7, 7, 7, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 6, 6, 5, 2], [7, 7, 7, 7, 7, 7, 4, 4, 4], [7, 7, 7, 7, 7, 7, 5, 4, 3], [7, 7, 7, 7, 7, 7, 5, 5, 2], [7, 7, 7, 7, 7, 7, 7, 3, 2], [7, 7, 7, 7, 7, 7, 7, 4, 1]] +d 6 slack 7 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 17} [[7, 6, 6, 6, 6, 6, 6, 6, 6], [7, 7, 6, 6, 6, 6, 6, 6, 5], [7, 7, 7, 6, 6, 6, 6, 5, 5], [7, 7, 7, 6, 6, 6, 6, 6, 4], [7, 7, 7, 7, 6, 6, 5, 5, 5], [7, 7, 7, 7, 6, 6, 6, 5, 4], [7, 7, 7, 7, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 6, 6, 4, 4], [7, 7, 7, 7, 7, 6, 6, 5, 3], [7, 7, 7, 7, 7, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 5, 4, 4], [7, 7, 7, 7, 7, 7, 5, 5, 3], [7, 7, 7, 7, 7, 7, 6, 4, 3], [7, 7, 7, 7, 7, 7, 6, 5, 2], [7, 7, 7, 7, 7, 7, 7, 3, 3], [7, 7, 7, 7, 7, 7, 7, 4, 2], [7, 7, 7, 7, 7, 7, 7, 5, 1]] +d 6 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 14} [[7, 7, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 6, 6, 6, 5, 5], [7, 7, 7, 7, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 6, 5, 5, 5], [7, 7, 7, 7, 7, 6, 6, 5, 4], [7, 7, 7, 7, 7, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 5, 5, 4], [7, 7, 7, 7, 7, 7, 6, 4, 4], [7, 7, 7, 7, 7, 7, 6, 5, 3], [7, 7, 7, 7, 7, 7, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 4, 3], [7, 7, 7, 7, 7, 7, 7, 5, 2], [7, 7, 7, 7, 7, 7, 7, 6, 1]] +d 7 slack 3 {'LP': 8, 'BASIS': 4, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 1} [[7, 7, 7, 6, 6, 6, 6, 6, 6, 2]] +d 7 slack 4 {'LP': 5, 'BASIS': 6, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 6} [[7, 7, 7, 6, 6, 6, 6, 6, 5, 4], [7, 7, 7, 6, 6, 6, 6, 6, 6, 3], [7, 7, 7, 7, 6, 6, 6, 6, 4, 4], [7, 7, 7, 7, 6, 6, 6, 6, 5, 3], [7, 7, 7, 7, 6, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 3, 1]] +d 7 slack 5 {'LP': 0, 'BASIS': 4, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 16} [[7, 6, 6, 6, 6, 6, 6, 6, 6, 6], [7, 7, 6, 6, 6, 6, 6, 6, 6, 5], [7, 7, 7, 6, 6, 6, 6, 6, 5, 5], [7, 7, 7, 6, 6, 6, 6, 6, 6, 4], [7, 7, 7, 7, 6, 6, 6, 5, 5, 5], [7, 7, 7, 7, 6, 6, 6, 6, 5, 4], [7, 7, 7, 7, 6, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 6, 6, 6, 4, 4], [7, 7, 7, 7, 7, 6, 6, 6, 5, 3], [7, 7, 7, 7, 7, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 6, 6, 5, 2], [7, 7, 7, 7, 7, 7, 7, 4, 4, 4], [7, 7, 7, 7, 7, 7, 7, 5, 4, 3], [7, 7, 7, 7, 7, 7, 7, 5, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 3, 2], [7, 7, 7, 7, 7, 7, 7, 7, 4, 1]] +d 7 slack 6 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 17} [[7, 7, 6, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 6, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 6, 6, 6, 6, 5, 5], [7, 7, 7, 7, 6, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 6, 6, 5, 5, 5], [7, 7, 7, 7, 7, 6, 6, 6, 5, 4], [7, 7, 7, 7, 7, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 6, 6, 4, 4], [7, 7, 7, 7, 7, 7, 6, 6, 5, 3], [7, 7, 7, 7, 7, 7, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 5, 4, 4], [7, 7, 7, 7, 7, 7, 7, 5, 5, 3], [7, 7, 7, 7, 7, 7, 7, 6, 4, 3], [7, 7, 7, 7, 7, 7, 7, 6, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 3, 3], [7, 7, 7, 7, 7, 7, 7, 7, 4, 2], [7, 7, 7, 7, 7, 7, 7, 7, 5, 1]] +d 7 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 14} [[7, 7, 7, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 7, 6, 6, 6, 5, 5], [7, 7, 7, 7, 7, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 7, 6, 5, 5, 5], [7, 7, 7, 7, 7, 7, 6, 6, 5, 4], [7, 7, 7, 7, 7, 7, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 7, 5, 5, 4], [7, 7, 7, 7, 7, 7, 7, 6, 4, 4], [7, 7, 7, 7, 7, 7, 7, 6, 5, 3], [7, 7, 7, 7, 7, 7, 7, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 4, 3], [7, 7, 7, 7, 7, 7, 7, 7, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 6, 1]] +d 7 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 11} [[7, 7, 7, 7, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 7, 6, 6, 6, 6, 5], [7, 7, 7, 7, 7, 7, 6, 6, 5, 5], [7, 7, 7, 7, 7, 7, 6, 6, 6, 4], [7, 7, 7, 7, 7, 7, 7, 5, 5, 5], [7, 7, 7, 7, 7, 7, 7, 6, 5, 4], [7, 7, 7, 7, 7, 7, 7, 6, 6, 3], [7, 7, 7, 7, 7, 7, 7, 7, 4, 4], [7, 7, 7, 7, 7, 7, 7, 7, 5, 3], [7, 7, 7, 7, 7, 7, 7, 7, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 1]] +d 8 slack 3 {'LP': 8, 'BASIS': 6, 'PENCIL': 1, 'E2TRIPLE': 0, 'SURV': 3} [[7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 1]] +d 8 slack 4 {'LP': 1, 'BASIS': 4, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 15} [[7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 6, 6, 6, 6, 6, 5, 5], [7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 6, 6, 6, 5, 5, 5], [7, 7, 7, 7, 7, 6, 6, 6, 6, 5, 4], [7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 6, 6, 6, 4, 4], [7, 7, 7, 7, 7, 7, 6, 6, 6, 5, 3], [7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4], [7, 7, 7, 7, 7, 7, 7, 7, 5, 4, 3], [7, 7, 7, 7, 7, 7, 7, 7, 5, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 1]] +d 8 slack 5 {'LP': 0, 'BASIS': 1, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 17} [[7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 7, 6, 6, 6, 6, 5, 5], [7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 7, 6, 6, 5, 5, 5], [7, 7, 7, 7, 7, 7, 6, 6, 6, 5, 4], [7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 7, 6, 6, 4, 4], [7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 3], [7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 5, 4, 4], [7, 7, 7, 7, 7, 7, 7, 7, 5, 5, 3], [7, 7, 7, 7, 7, 7, 7, 7, 6, 4, 3], [7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 1]] +d 8 slack 6 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 14} [[7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 5], [7, 7, 7, 7, 7, 7, 6, 6, 6, 5, 5], [7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 4], [7, 7, 7, 7, 7, 7, 7, 6, 5, 5, 5], [7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 4], [7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 3], [7, 7, 7, 7, 7, 7, 7, 7, 5, 5, 4], [7, 7, 7, 7, 7, 7, 7, 7, 6, 4, 4], [7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 3], [7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 3], [7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 1]] +d 8 slack 7 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 11} [[7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6], [7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 5], [7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 5], [7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 4], [7, 7, 7, 7, 7, 7, 7, 7, 5, 5, 5], [7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 4], [7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 3], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 4], [7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 3], [7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 1]] +d 8 slack 8 {'LP': 0, 'BASIS': 0, 'PENCIL': 0, 'E2TRIPLE': 0, 'SURV': 7} [[7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6], [7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 5], [7, 7, 7, 7, 7, 7, 7, 7, 6, 5, 5], [7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 4], [7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 4], [7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 3], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2]] diff --git a/research/p112-six-seven-supplement/model.py b/research/p112-six-seven-supplement/model.py new file mode 100644 index 0000000000..49dcf65387 --- /dev/null +++ b/research/p112-six-seven-supplement/model.py @@ -0,0 +1,660 @@ +"""Exact finite inputs for the sharp P112 six/seven-flat theorem. + +conorholds, with OpenAI Codex assistance. Apache-2.0. +The primary engine uses the declared simple-root coordinates and polar equations. +The mathematical argument, including the characteristic-zero transfer, is separate. +""" + +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations, combinations_with_replacement, product +import json +from pathlib import Path +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] +CONSUMED_INPUTS = {"research/p112-root-simplex-exclusion/geometry.py", + "research/one-sided-decoders-all-m/data/data.json"} +RETAINED_INPUTS = {"inputs/pr3154/land_e2_k8.out", "inputs/pr3154/land_e3_k8.out"} + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def strict_json(raw): + def pairs(items): + result = {} + for key, value in items: + need(key not in result, "duplicate JSON key") + result[key] = value + return result + + def constant(_): + raise ValueError("nonfinite JSON number") + + return json.loads(raw, object_pairs_hook=pairs, parse_constant=constant) + + +def canonical_json(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False) + + +def digest(value): + return sha256(canonical_json(value).encode()).hexdigest() + + +def regular_bytes(root, name): + relative = Path(name) + need(not relative.is_absolute() and all(x not in (".", "..") for x in relative.parts), + "noncanonical source path") + path = root + for part in relative.parts: + path /= part + need(not path.is_symlink(), "linked source input") + need(path.is_file(), "missing source input") + return path.read_bytes() + + +def authenticate(): + sources = strict_json(regular_bytes(PACKAGE, "SOURCES.json")) + live = [row["path"] for row in sources["files"] if row["usage"] == "input"] + retained = [row["retained_path"] for row in sources["retained_pr_sources"]] + need(len(live) == len(CONSUMED_INPUTS) and set(live) == CONSUMED_INPUTS, + "source inventory differs from consumed inputs") + need(len(retained) == len(RETAINED_INPUTS) and set(retained) == RETAINED_INPUTS, + "retained source inventory differs from consumed inputs") + need(len({row["path"] for row in sources["files"]}) == len(sources["files"]), + "duplicate source row") + checked = [] + for row in sources["files"]: + if row["usage"] == "input": + raw = regular_bytes(ROOT, row["path"]) + need(sha256(raw).hexdigest() == row["sha256"], "live source hash differs") + checked.append(row["path"]) + for row in sources["retained_pr_sources"]: + raw = regular_bytes(PACKAGE, row["retained_path"]) + need(sha256(raw).hexdigest() == row["sha256"], "retained PR source hash differs") + checked.append(row["retained_path"]) + return checked + + +def rank(rows): + pivots = {} + for value in rows: + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + value ^= pivots[pivot] + else: + pivots[pivot] = value + break + return len(pivots) + + +def span_coordinates(rows): + """Coordinates in an incrementally selected basis, not row positions.""" + pivots, coordinates = {}, [] + for value in rows: + coordinate = 0 + while value: + pivot = value.bit_length() - 1 + if pivot in pivots: + value ^= pivots[pivot][0] + coordinate ^= pivots[pivot][1] + else: + bit = 1 << len(pivots) + pivots[pivot] = (value, coordinate ^ bit) + coordinate = bit + break + coordinates.append(coordinate) + return len(pivots), coordinates + + +def rational_rank(rows): + matrix = [[Fraction(x) for x in row] for row in rows] + if not matrix: + return 0 + row = 0 + for col in range(len(matrix[0])): + pivot = next((i for i in range(row, len(matrix)) if matrix[i][col]), None) + if pivot is None: + continue + matrix[row], matrix[pivot] = matrix[pivot], matrix[row] + scale = matrix[row][col] + matrix[row] = [x / scale for x in matrix[row]] + for i in range(row + 1, len(matrix)): + scale = matrix[i][col] + if scale: + matrix[i] = [x - scale * y for x, y in zip(matrix[i], matrix[row])] + row += 1 + return row + + +def indices(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +class Geometry: + def __init__(self): + authenticate() + path = ROOT / "research/p112-root-simplex-exclusion/geometry.py" + module = ModuleType("six_seven_frozen_geometry") + module.__file__ = str(path) + exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__) + self.source = module + roots, points, _, coordinates = module.root_data() + self.roots, self.points = roots, points + self.index = {r: i for i, r in enumerate(roots)} + self.residues = tuple(sum((int(x) % 2) << j for j, x in enumerate(c)) + for c in coordinates) + self.labels = tuple(1 | (r << 1) for r in self.residues) + self.by_residue = {x: i for i, x in enumerate(self.residues)} + self.all = (1 << 120) - 1 + self.live = sum(1 << self.index[r] for r in points) + self.frame = self.all ^ self.live + self.dots = tuple(tuple(module.dot(a, b) for b in roots) for a in roots) + self.neighbors = tuple(sum(1 << j for j, value in enumerate(row) if abs(value) == 4) + for row in self.dots) + self.off = tuple(self.neighbors[i] | (1 << i) for i in range(120)) + gram = [[module.dot(a, b) // 4 for b in module.SIMPLE] for a in module.SIMPLE] + edges = [(i, j) for i in range(8) for j in range(i + 1, 8) if gram[i][j] % 2] + self.q = tuple((x.bit_count() + sum(((x >> i) & 1) * ((x >> j) & 1) + for i, j in edges)) % 2 for x in range(256)) + need(len(set(self.residues)) == 120 and rank(self.labels) == 9, + "declared root-label embedding") + need({x for x in range(256) if self.q[x]} == set(self.residues), + "quadratic anisotropic points differ from roots") + need(sum((-1) ** y for y in self.q) == 16, "ambient Gauss sign") + polar_rows = [sum(self.b(1 << i, 1 << j) << j for j in range(8)) + for i in range(8)] + need(rank(polar_rows) == 8, "degenerate polar model") + need(all(self.b(self.residues[i], self.residues[j]) == (self.dots[i][j] // 4) % 2 + for i in range(120) for j in range(120)), "polar/root pairing binding") + need(Counter((x & self.live).bit_count() for x in self.off) == {53: 112, 56: 8}, + "root off-support convention") + need(all((self.neighbors[i] & self.frame).bit_count() + == (0 if self.frame >> i & 1 else 4) for i in range(120)), + "fixed-frame incidence") + self.polar_masks = tuple(sum(1 << i for i, r in enumerate(self.residues) if self.b(x, r)) + for x in range(256)) + + def b(self, a, b): + return self.q[a ^ b] ^ self.q[a] ^ self.q[b] + + def affine_sections(self): + """Every polar two-plane, with all four affine right-hand sides.""" + for a in range(1, 256): + for b in range(a + 1, 256): + if (a ^ b) < b: + continue + for alpha in range(2): + for beta in range(2): + ma = self.polar_masks[a] if alpha else self.all ^ self.polar_masks[a] + mb = self.polar_masks[b] if beta else self.all ^ self.polar_masks[b] + yield a, b, ma & mb + + +def completion_checks(g): + counts, qualifiers, maximum, total = Counter(), [], 0, 0 + for a, b, section in g.affine_sections(): + total += 1 + counts[section.bit_count()] += 1 + for v in range(120): + full_intersection = section & g.off[v] + maximum = max(maximum, full_intersection.bit_count()) + if (full_intersection & g.live).bit_count() < 29: + continue + need(section.bit_count() == 32, "large residual has no32 completion") + need(section & ~g.neighbors[v] == 0, "completion contains self or orthogonal root") + rv = g.residues[v] + need(rv in (a, b, a ^ b), "normal not in affine annihilator") + mates = [g.by_residue[x] for x in (a, b, a ^ b) + if x in g.by_residue and x != rv and not g.b(rv, x)] + need(len(mates) == 1, "completion mate is not unique") + w = mates[0] + need(not g.dots[v][w] and section == g.neighbors[v] & ~g.neighbors[w], + "wrong orthogonal completion orientation") + qualifiers.append((v, w)) + expected = [] + full_count = 0 + for v in range(120): + for w in range(120): + if g.dots[v][w]: + continue + full_count += 1 + section = g.neighbors[v] & ~g.neighbors[w] + need(section.bit_count() == 32, "orthogonal completion size") + need(rank(g.labels[i] for i in indices(section)) == 7, "completion rank") + if (section & g.live).bit_count() >= 29: + expected.append((v, w)) + need(total == 43180 and full_count == 7560 and maximum == 32, + "incomplete affine/root domain or wrong cap") + need(len(qualifiers) == len(set(qualifiers)) and sorted(qualifiers) == sorted(expected), + "large completion classification is incomplete") + return {"count": total, "cardinality_histogram": {str(k): v for k, v in sorted(counts.items())}, + "qualifying29": len(qualifiers), "completion_digest": digest(sorted(qualifiers))}, full_count + + +def core_checks(g): + aggregate, pairs = Counter(), 0 + optimal, per_word = [], Counter() + small_flat_count = 0 + for v, w in combinations(range(120), 2): + if g.dots[v][w]: + continue + core = g.neighbors[v] & g.neighbors[w] + ids = list(indices(core)) + dim, coordinates = span_coordinates(g.labels[i] for i in ids) + need(len(ids) == 24 and dim == 7, "common core cardinality/rank") + sections = Counter() + for f in range(1, 128): + low = sum(1 << i for i, x in zip(ids, coordinates) if not ((f & x).bit_count() % 2)) + sections[low.bit_count()] += 1 + if low.bit_count() != 16 or low & g.frame: + continue + for normal, mate in ((v, w), (w, v)): + high = g.neighbors[normal] & ~g.neighbors[mate] & g.live + target = g.off[normal] & g.live + sparse = target & ~(low | high) + floor = 5 if g.live >> normal & 1 else 8 + if sparse.bit_count() != floor: + continue + need(high.bit_count() == 32 and not high & low, + "uniform cover partition changed") + need([rank(g.labels[i] for i in indices(part)) for part in (high, low, sparse)] + == [7, 6, 4], "uniform cover support ranks") + if floor == 5: + need(sparse >> normal & 1 + and rank(g.labels[i] for i in indices(sparse ^ (1 << normal))) == 3, + "uniform four-plus-self boundary") + four = list(indices(sparse ^ (1 << normal))) + closure = {g.labels[i] for i in four} + closure.update(g.labels[normal] ^ g.labels[four[0]] ^ g.labels[i] + for i in four) + roots = {i for i, label in enumerate(g.labels) if label in closure} + need(len(closure) == len(roots) == 8 + and all(g.live >> i & 1 for i in roots), "small flat root closure") + need(sum(1 << i for i in roots if g.dots[normal][i]) == sparse, + "small flat contains extra nonorthogonal roots") + small_flat_count += 1 + if not per_word[normal]: + for i in indices(g.live): + coefficient = g.dots[normal][i] // 4 + need(sum(coefficient for part in (high, low, sparse) if part >> i & 1) + == coefficient, "uniform coefficient partition") + optimal.append((normal, mate, low)) + per_word[normal] += 1 + need(sections == {0: 1, 8: 15, 12: 96, 16: 15}, "core hyperplane capacity") + aggregate.update(sections) + pairs += 1 + need(pairs == 3780, "incomplete orthogonal-pair domain") + need(all(per_word[i] == (3 if g.live >> i & 1 else 945) for i in range(120)), + "uniform optimal-cover count") + need(small_flat_count == 336, "nonframe small-flat inventory") + return {"pairs": pairs, "forms_per_pair": 127, + "aggregate_histogram": {str(k): v for k, v in sorted(aggregate.items())}, + "uniform_sharpness": {"nonframe_words": 112, "frame_words": 8, + "five_site_covers": sum(per_word[i] for i in indices(g.live)), + "eight_site_covers": sum(per_word[i] for i in indices(g.frame)), + "covers_per_nonframe_word": 3, "covers_per_frame_word": 945, + "partition_ranks": [7, 6, 4], + "nonframe_small_flats": small_flat_count, + "nonframe_small_flat_roots": 8, + "extra_orthogonal_roots": 3, + "cover_digest": digest(sorted(optimal))}} + + +def root764_checks(g): + """Complementary 28-sections, using ambient dual masks rather than local bases.""" + polar_one = [sum(1 << i for i, residue in enumerate(g.residues) if g.b(a, residue)) + for a in range(256)] + sections, pairs = set(), 0 + for v, residue in enumerate(g.residues): + local = set() + for a in range(256): + if not g.b(residue, a): + continue + for offset in (0, 1): + section = g.neighbors[v] & (polar_one[a] if offset else g.all ^ polar_one[a]) + need(section.bit_count() == 28, "root764 complementary section28") + local.add(section) + need(len(local) == 128, "root764 complementary multiplicity") + pairs += len(local) + sections.update(local) + dual_masks = [sum(1 << i for i, label in enumerate(g.labels) + if not ((label & a).bit_count() & 1)) for a in range(512)] + for section in sections: + need(rank(g.labels[i] for i in indices(section)) == 7, "root764 complementary rank7") + need(Counter((section & cut).bit_count() for cut in dual_masks) + == {0: 4, 12: 252, 16: 252, 28: 4}, "root764 complementary cut capacities") + return {"root_high_pairs": pairs, "c28_sections": len(sections), + "c28_section_histogram": {"0": 1, "12": 63, "16": 63}, + "c28_digest": sha256(json.dumps(sorted(sections), separators=(",", ":")).encode()).hexdigest()} + + +def quotient6_checks(): + """All affine codimension-one/two sections of the split six-quadric.""" + roots = [x for x in range(64) + if sum(((x >> (2*j)) & 1) * ((x >> (2*j+1)) & 1) for j in range(3)) & 1] + hist = {4: Counter(), 5: Counter()} + for a in range(1, 64): + for offset in (0, 1): + hist[5][sum(((a & x).bit_count() & 1) == offset for x in roots)] += 1 + for b in range(a + 1, 64): + if b > (a ^ b): + continue + for first in (0, 1): + for second in (0, 1): + count = sum(((a & x).bit_count() & 1) == first + and ((b & x).bit_count() & 1) == second for x in roots) + hist[4][count] += 1 + need(len(roots) == 28 and sum(hist[4].values()) == 2604 + and sum(hist[5].values()) == 126 and max(hist[4]) == 10 and max(hist[5]) == 16, + "six-quadric affine capacities") + return {str(d): {str(k): v for k, v in sorted(counts.items())} + for d, counts in hist.items()} + + +def witness_checks(g): + vroot, wroot = (2, 0, 2, 0, 0, 0, 0, 0), (2, 0, -2, 0, 0, 0, 0, 0) + v, w = g.index[vroot], g.index[wroot] + x = g.neighbors[v] & ~g.neighbors[w] & g.live + yr = {tuple(2 if j == center else sign * 2 if j == other else 0 for j in range(8)) + for center in (0, 2) for other in range(4, 8) for sign in (-1, 1)} + y = sum(1 << g.index[r] for r in yr) + target = g.off[v] & g.live + sparse = target & ~(x | y) + supports = [sparse, y, x] + sizes = [m.bit_count() for m in supports] + ranks = [rank(g.labels[i] for i in indices(m)) for m in supports] + need(sizes == [5, 16, 32] and ranks == [4, 6, 7], "sharp witness changed") + need(not x & y and (sparse | y | x) == target, "witness is not a disjoint partition") + old = strict_json(regular_bytes(ROOT, "research/one-sided-decoders-all-m/data/data.json")) + old_roots = [tuple(int(2 * Fraction(str(z))) for z in r) for r in old["L"]] + old_frame = [tuple(int(2 * Fraction(str(z))) for z in r) for r in old["F0"]] + need(set(old_roots) == set(g.points) and set(old_roots + old_frame) == set(g.roots), + "old/new root or frame binding") + graph = [old_label | (g.labels[g.index[r]] << 9) + for r, old_label in zip(old_roots + old_frame, old["LAB"] + old["Z"])] + need(rank(graph) == 9 and rank(old["LAB"] + old["Z"]) == 9, "old/new label map") + for i, r in enumerate(old_roots): + need(old["FC"][i] == [g.source.dot(r, f) // 4 for f in old_frame], + "historical frame coefficient row") + small_four = sparse ^ (1 << v) + four_supports = [x, y, small_four, 1 << v] + qrows = [[Fraction(g.dots[v][g.index[r]], 4) if (m >> g.index[r]) & 1 else Fraction(0) + for m in four_supports] for r in old_roots] + need(all(sum(qrows[i]) == Fraction(g.source.dot(vroot, r), 4) + for i, r in enumerate(old_roots)), "coefficient identity") + c_rank = rational_rank(old["FC"]) + q_rank = rational_rank(qrows) + joint = rational_rank([old["FC"][i] + qrows[i] for i in range(112)]) + need((c_rank, q_rank, joint) == (8, 4, 11), "slack-nine intersection") + sranks = [rank(g.labels[i] for i in indices(m)) for m in four_supports] + need(sranks == [7, 6, 3, 1], "slack-nine support ranks") + return {"sizes": sizes, "ranks": ranks, + "sparse_indices": [i for i, r in enumerate(old_roots) if sparse >> g.index[r] & 1], + "slack9": {"sizes": [m.bit_count() for m in four_supports], "ranks": sranks, + "code_rank": c_rank, "pieces_rank": q_rank, "joint_rank": joint, "cost": 17}} + + +def frame_plane_checks(g): + """All G4 cuts, by the ambient dual no-coloop criterion.""" + phases = [(normal, sum(1 << i for i in indices(g.live) + if (normal & g.labels[i]).bit_count() % 2)) + for normal in range(1, 512)] + masks = [mask for _, mask in phases] + records, minimum = [], 112 + for i in indices(g.frame): + matched = [mask for normal, mask in phases + if not (normal & g.labels[i]).bit_count() % 2] + need(len(matched) == 255, "matched frame hyperplane inventory") + for j in indices(g.frame): + if i == j: + continue + for coefficient in (1, -1, 2): + off = sum(1 << k for k in indices(g.live) + if g.dots[i][k] + coefficient * g.dots[j][k]) + for outside in matched: + deleted = off & outside + counts = [(deleted & mask).bit_count() for mask in masks] + need(counts.count(0) == 1 and 1 not in counts, + "frame-plane rank or one-point deletion failed") + minimum = min(minimum, deleted.bit_count()) + records.append((i, j, coefficient, deleted)) + need(len(records) == 42840, "frame-plane case inventory") + return {"cases": len(records), "minimum_deleted": minimum, + "rank": 8, "all_one_point_deletions_preserve_rank": True, + "case_digest": digest(sorted(records))} + + +def invoice_profile_checks(): + capacity = {1: 1, 2: 2, 3: 4, 4: 8, 5: 12, 6: 20, 7: 36} + answer = {} + for length, budget in ((3, 16), (4, 16), (4, 17)): + kept, examined = [], 0 + for ascending in combinations_with_replacement(range(1, 8), length): + if sum(ascending) > budget: + continue + examined += 1 + weights = list(reversed(ascending)) + bound = sum(capacity[w] for w in weights) + if bound < 53: + continue + if bound < 70 and sum(32 if w == 7 else capacity[w] for w in weights) < 53: + continue + remaining = weights.copy() + if 7 in remaining and 6 in remaining: + remaining.remove(7) + remaining.remove(6) + if all(w <= 3 for w in remaining) and sum(1 << (w - 1) for w in remaining) <= 4: + continue + kept.append(weights) + answer[str(length) + ":" + str(budget)] = {"examined": examined, "survivors": sorted(kept)} + need(answer["3:16"]["survivors"] == [[7, 7, 1], [7, 7, 2]] + and answer["4:16"]["survivors"] == [[7, 7, 1, 1]] + and answer["4:17"]["survivors"] == [[7, 5, 4, 1], [7, 6, 3, 1], + [7, 7, 1, 1], [7, 7, 2, 1]], + "actual-invoice profile exhaustion") + return answer + + +def d2_profile_checks(): + cap = (0, 1, 2, 4, 8, 12, 20, 36) + answer = {} + for length, budget in ((4, 24), (5, 25)): + candidates, examined = [], 0 + for ascending in combinations_with_replacement(range(1, 8), length): + if sum(ascending) > budget: + continue + examined += 1 + weights = list(reversed(ascending)) + if weights[0] <= 6: + # Four-six-plus-nine, or the sole 55555 boundary and distance53. + continue + remaining = weights[1:] + crude = sum(cap[w] for w in remaining) + if crude < 53 or (crude < 70 and sum(32 if w == 7 else cap[w] + for w in remaining) < 53): + continue + sparse = remaining.copy() + if 7 in sparse and 6 in sparse: + sparse.remove(7) + sparse.remove(6) + if sum(cap[w] for w in sparse) <= 4: + continue + candidates.append(weights) + intrinsic = [[7, 7, 5, 5], [7, 7, 6, 4]] if length == 4 else [[7, 6, 6, 5, 1]] + need(all(row in candidates for row in intrinsic), "intrinsic d2 profile boundary") + actual = [row for row in sorted(candidates) if row not in intrinsic] + expected = ([[7, 7, 7, k] for k in (1, 2, 3)] if length == 4 else + [[7, 7, 5, 4, 1], [7, 7, 5, 4, 2], [7, 7, 5, 5, 1], + [7, 7, 6, 3, 1], [7, 7, 6, 3, 2], [7, 7, 6, 4, 1], + [7, 7, 7, 1, 1], [7, 7, 7, 2, 1], [7, 7, 7, 2, 2], + [7, 7, 7, 3, 1]]) + need(actual == expected, "complete d2 minimum-profile exhaustion") + answer[str(length) + ":" + str(budget)] = { + "examined": examined, "intrinsic_exclusions": intrinsic, "actual_profiles": actual} + return answer + + +def root_plane_checks(g): + planes = set() + for i, j in combinations(range(120), 2): + ab = g.dots[i][j] + mask = 0 + for k in range(120): + ac, bc = g.dots[i][k], g.dots[j][k] + if 512 + 2 * ab * ac * bc - 8 * (ab * ab + ac * ac + bc * bc) == 0: + mask |= 1 << k + need(mask.bit_count() in (2, 3), "root plane has more than three root lines") + planes.add(mask) + histogram = Counter(mask.bit_count() for mask in planes) + need(histogram == {2: 3780, 3: 1120}, "root-plane inventory") + active_histogram = Counter() + for plane in planes: + if plane.bit_count() != 3: + continue + active = sum(any(g.dots[i][f] for i in indices(plane)) for f in indices(g.frame)) + need((active, (plane & g.frame).bit_count()) in ((4, 1), (6, 0)), + "A2 active-frame geometry") + active_histogram[active] += 1 + need(active_histogram == {4: 224, 6: 896}, "A2 active-frame inventory") + return {"root_pairs": 7140, "distinct_planes": len(planes), + "root_line_histogram": {str(k): v for k, v in sorted(histogram.items())}, + "a2_active_axes": {str(k): v for k, v in sorted(active_histogram.items())}, + "plane_digest": digest(sorted(planes))} + + +def four_axis_checks(g): + def canonical(form): + first = next((x for x in form if x), 1) + return tuple(x if first > 0 else -x for x in form) + + counts = Counter() + for axes in combinations(list(indices(g.frame)), 4): + forms = Counter(canonical(tuple(g.dots[i][a] // 4 for a in axes)) + for i in indices(g.live)) + block = forms[(0, 0, 0, 0)] == 8 + expected = Counter({(0, 0, 0, 0): 8}) if block else Counter() + sizes = (2, 4) if block else (1, 2, 3) + for size in sizes: + multiplicity = {2: 8, 4: 1}[size] if block else {1: 8, 2: 4, 3: 2}[size] + for support in combinations(range(4), size): + for signs in product((-1, 1), repeat=size - 1): + form = [0] * 4 + for axis, sign in zip(support, (1,) + signs): + form[axis] = sign + expected[tuple(form)] = multiplicity + need(forms == expected, "four-axis restricted-form inventory") + counts["block" if block else "nonblock"] += 1 + need(counts == {"block": 14, "nonblock": 56}, "four-axis block inventory") + return {"sets": 70, "block_sets": counts["block"], "nonblock_sets": counts["nonblock"], + "block_multiplicities": {"zero": 8, "pair": 8, "four": 1}, + "nonblock_multiplicities": {"singleton": 8, "pair": 4, "triple": 2}} + + +def pencil_callers(): + import ast + import re + rows, shared = [], [] + for t in (2, 3): + for line in regular_bytes(PACKAGE, f"inputs/pr3154/land_e{t}_k8.out").decode().splitlines(): + match = re.fullmatch(r"d (\d+) slack (\d+) (\{.*\}) (\[.*\])", line) + d, slack = int(match[1]), int(match[2]) + if d < 2: + continue + for weights in ast.literal_eval(match[4]): + remaining = sorted(weights, reverse=True)[d - 2:] + if t == 2 and all(w <= cap for w, cap in zip(remaining, (7, 7, 5, 5))): + shared.append((t, d, slack, weights)) + if max(remaining) <= 6 and (t == 2 or min(remaining) <= 4): + rows.append((t, d, slack, weights)) + need(Counter(row[0] for row in rows) == {2: 2, 3: 83}, "literal root-pencil applications") + need(shared == [(2, 2, 8, [7, 7, 5, 5]), (2, 3, 7, [7, 7, 7, 5, 5])], + "shared-frame profile applications") + return {"t2": 2, "t3": 83, "total": len(rows), "application_digest": digest(sorted(rows)), + "shared_frame_7755": shared} + + +def frame_sign_checks(g): + records = [] + for a, b in combinations(list(indices(g.frame)), 2): + common = g.neighbors[a] & g.neighbors[b] + positive = sum(1 << site for site in indices(common) + if g.dots[a][site] * g.dots[b][site] > 0) + negative = common ^ positive + need(common.bit_count() == 24 and positive.bit_count() == negative.bit_count() == 12, + "frame sign-half partition") + need(rank(g.labels[i] for i in indices(positive)) == 7 + and rank(g.labels[i] for i in indices(negative)) == 7, + "frame sign-half label rank") + radical = (0, g.residues[a], g.residues[b], g.residues[a] ^ g.residues[b]) + fibers = {tuple(sorted(g.by_residue[g.residues[i] ^ r] for r in radical)) + for i in indices(common)} + need(len(fibers) == 6 and all(len(set(fiber)) == 4 for fiber in fibers), + "frame sign-half radical fibers") + need(all(sum((positive >> i) & 1 for i in fiber) == 2 for fiber in fibers), + "frame sign halves must meet every radical fiber twice") + records.append((a, b, positive, negative)) + return {"frame_pairs": 28, "sign_halves": 56, "half_size": 12, + "binary_rank": 7, "radical_fibers_per_pair": 6, "half_points_per_fiber": 2, + "case_digest": digest(records)} + + +def caller_checks(): + import ast + import re + parsed = {} + for t in (2, 3): + raw = regular_bytes(PACKAGE, f"inputs/pr3154/land_e{t}_k8.out").decode() + entries = [] + for line in raw.splitlines(): + match = re.fullmatch(r"d (\d+) slack (\d+) (\{.*\}) (\[.*\])", line) + need(match is not None, "malformed historical caller line") + d, slack = int(match[1]), int(match[2]) + counters, rows = ast.literal_eval(match[3]), ast.literal_eval(match[4]) + need(counters["SURV"] == len(rows), "historical survivor counter") + for weights in rows: + need(len(weights) == d + t and sum(weights) - 8 * d == slack, + "historical caller dimensions/ledger") + entries.append((d, slack, weights)) + parsed[t] = entries + selected = [] + capacity = {1: 1, 2: 2, 3: 4} + for t, entries in parsed.items(): + for d, slack, weights in entries: + low = [w for w in weights if w != 7] + if weights.count(7) == d and low.count(6) == 1: + extras = [w for w in low if w != 6] + if all(w in capacity for w in extras) and sum(capacity[w] for w in extras) <= 4: + selected.append({"t": t, "d": d, "slack": slack, "weights": weights}) + selected.sort(key=lambda row: (row["t"], row["d"], row["slack"], row["weights"])) + need(len(parsed[2]) == 35 and len(parsed[3]) == 280 and len(selected) == 9, + "historical or new caller count") + return selected + + +def run(): + g = Geometry() + affine, full_count = completion_checks(g) + stable = {"root_inventory": {"full": 120, "live": 112, "frame": 8}, + "affine6_sections": affine, "core_sections": core_checks(g), + "witness": witness_checks(g), "callers": caller_checks(), + "frame_plane": frame_plane_checks(g), "invoice_profiles": invoice_profile_checks(), + "root_planes": root_plane_checks(g), "pencil_callers": pencil_callers(), + "frame_sign_halves": frame_sign_checks(g), + "root764": root764_checks(g), "quotient6": quotient6_checks(), + "d2_profiles": d2_profile_checks(), "four_axes": four_axis_checks(g)} + return stable, {"full_ordered_completions": full_count, + "chamber_receipt": g.source.chamber_receipt(g.roots, g.points, + g.source.root_data()[3]), + "ambient_gauss_sum": 16, "polar_rank": 8} diff --git a/research/p112-six-seven-supplement/test_package.py b/research/p112-six-seven-supplement/test_package.py new file mode 100644 index 0000000000..036a506c82 --- /dev/null +++ b/research/p112-six-seven-supplement/test_package.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python3 +"""Exercise the real CLI on private copies, including scientific mutants. + +conorholds, with OpenAI Codex assistance. Apache-2.0. +No predecessor or original package file is modified. +""" + +from hashlib import sha256 +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + + +PACKAGE = Path(__file__).resolve().parent +ROOT = PACKAGE.parents[1] + + +def need(value, message): + if not value: + raise ValueError(message) + + +def snapshot(): + return {str(p.relative_to(PACKAGE)): sha256(p.read_bytes()).hexdigest() + for p in PACKAGE.rglob("*") if p.is_file()} + + +def main(): + before = snapshot() + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + checked = [] + with tempfile.TemporaryDirectory(prefix="p112-six-seven-controls-") as temp: + root = Path(temp) / "tree" + package = root / "research" / PACKAGE.name + shutil.copytree(PACKAGE, package, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.olean")) + for row in sources["files"]: + if row["usage"] == "input": + target = root / row["path"] + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes((ROOT / row["path"]).read_bytes()) + + def cli(expected, message=None, sources_only=False): + args = [sys.executable, "-I", "-O", "-Werror", "-B", str(package / "verify.py")] + if sources_only: + args.append("--sources-only") + result = subprocess.run(args, cwd=root, text=True, capture_output=True, timeout=90) + output = result.stdout + result.stderr + need(result.returncode == expected, + "actual CLI returned an unexpected exit status: " + output) + if message: + need(message in output, "actual CLI rejected for the wrong reason: " + output) + + cli(0, "PASS_P112_SIX_SEVEN_SUPPLEMENT") + checked.append("complete optimized Git-free positive") + cli(0, "source-integrity-only", sources_only=True) + manifest_path = package / "SOURCES.json" + manifest_bytes = manifest_path.read_bytes() + for relabel in (False, True): + broken = json.loads(manifest_bytes) + index = next(i for i, row in enumerate(broken["files"]) if row["usage"] == "input") + if relabel: + broken["files"][index]["usage"] = "provenance" + else: + broken["files"].pop(index) + manifest_path.write_text(json.dumps(broken)) + cli(1, "source inventory differs from consumed inputs", sources_only=True) + manifest_path.write_bytes(manifest_bytes) + checked.append("missing or relabeled consumed source pin rejected") + for relative, message in ( + ("research/p112-root-simplex-exclusion/geometry.py", "live source hash differs"), + ("research/one-sided-decoders-all-m/data/data.json", "live source hash differs"), + (str((package / "inputs/pr3154/land_e2_k8.out").relative_to(root)), + "retained PR source hash differs"), + ): + path = root / relative + original = path.read_bytes() + path.write_bytes(original + b"\n") + cli(1, message, sources_only=True) + path.write_bytes(original) + checked.append("two changed live sources and changed retained caller rejected") + + caller = package / "inputs/pr3154/land_e2_k8.out" + original = caller.read_bytes() + respaced = original.replace(b"'LP': 0", b"'LP': 0", 1) + need(respaced != original, "retained caller spacing anchor changed") + caller.write_bytes(respaced) + repinned = json.loads(manifest_bytes) + row = next(row for row in repinned["retained_pr_sources"] + if row["retained_path"] == "inputs/pr3154/land_e2_k8.out") + row["sha256"] = sha256(caller.read_bytes()).hexdigest() + manifest_path.write_text(json.dumps(repinned)) + cli(0, "source-integrity-only", sources_only=True) + cli(1, "scientific receipt or JSON types differ") + caller.write_bytes(original) + manifest_path.write_bytes(manifest_bytes) + checked.append("repinned caller bytes invalidate the frozen receipt") + + linked = root / "research/p112-root-simplex-exclusion/geometry.py" + original = linked.read_bytes() + saved = linked.with_suffix(".saved") + saved.write_bytes(original) + linked.unlink() + linked.symlink_to(saved.name) + cli(1, "linked source input", sources_only=True) + linked.unlink() + linked.write_bytes(original) + saved.unlink() + checked.append("linked source rejected") + + path = package / "model.py" + source = path.read_text() + mutations = [ + ("self.neighbors[i] | (1 << i)", "self.neighbors[i]", + "root off-support convention", "omit actual root self"), + ("section == g.neighbors[v] & ~g.neighbors[w]", + "section == g.neighbors[v] & g.neighbors[w]", + "wrong orthogonal completion orientation", "reverse completion half"), + ("for a in range(1, 256):", "for a in range(2, 256):", + "incomplete affine/root domain or wrong cap", "omit affine annihilator family"), + ("target = g.off[v] & g.live", "target = g.neighbors[v] & g.live", + "sharp witness changed", "drop self only in claimed sharp witness"), + ("if low.bit_count() != 16 or low & g.frame:", + "if low.bit_count() != 16 or low & g.live:", + "uniform optimal-cover count", "confuse frame and live sites in the uniform construction"), + ("for coefficient in (1, -1, 2):", "for coefficient in (1, -1, 0):", + "frame-plane rank or one-point deletion failed", "replace generic two-axis stratum by an axis"), + ("if g.dots[a][site] * g.dots[b][site] > 0", + "if g.dots[a][site] * g.dots[a][site] > 0", + "frame sign-half partition", "erase the second frame axis from coefficient-sign partition"), + ] + for old, new, message, name in mutations: + need(source.count(old) == 1, "mutation anchor changed") + path.write_text(source.replace(old, new)) + cli(1, message) + path.write_text(source) + checked.append(name) + + actual_path = package / "actual_controls.py" + actual_source = actual_path.read_text() + anchor = "scale * value / 2 - coefficient * pivot_unit[i]" + need(actual_source.count(anchor) == 1, "actual factorization mutation anchor changed") + actual_path.write_text(actual_source.replace(anchor, anchor.replace(" - ", " + "))) + cli(1, "actual d1 consumer is not the exact Gram factorization") + actual_path.write_text(actual_source) + checked.append("wrong actual singleton compensation sign rejected by Gram entries") + + d2_path = package / "d2_controls.py" + d2_source = d2_path.read_text() + anchor = "high[j] = [x - scalar*y for x, y in zip(high[j], high[chosen])]" + need(d2_source.count(anchor) == 1, "actual d2 marked shear mutation anchor changed") + d2_path.write_text(d2_source.replace(anchor, anchor.replace(" - ", " + "))) + cli(1, "actual d2 restricted dual expansion") + d2_path.write_text(d2_source) + checked.append("wrong actual d2 marked shear rejected by restricted dual expansion") + + independent_path = package / "independent.py" + independent_source = independent_path.read_text() + anchor = '"qualifying29": len(qualifying)' + need(independent_source.count(anchor) == 1, "independent mutation anchor changed") + independent_path.write_text(independent_source.replace(anchor, anchor + " + 1")) + cli(1, "separate exact engines disagree") + independent_path.write_text(independent_source) + checked.append("actual independent-engine disagreement rejected") + + receipt_path = package / "RESULT.json" + receipt = receipt_path.read_bytes() + wrong = json.loads(receipt) + wrong["finite_inputs"]["affine6_sections"]["count"] = True + receipt_path.write_text(json.dumps(wrong)) + cli(1, "scientific receipt or JSON types differ") + receipt_path.write_bytes(receipt) + checked.append("Boolean masquerading as an integer receipt rejected") + + need(snapshot() == before, "original package bytes changed during controls") + print("PASS_P112_SIX_SEVEN_CLI_CONTROLS groups=" + str(len(checked)) + + " scientific_mutants=" + str(len(mutations) + 2) + + " engine_disagreement=1 original_bytes=unchanged") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/research/p112-six-seven-supplement/verify.py b/research/p112-six-seven-supplement/verify.py new file mode 100644 index 0000000000..4d89a59fd6 --- /dev/null +++ b/research/p112-six-seven-supplement/verify.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 +"""Replay two bounded exact reconstructions; the theorem is in PROOF.md. + +conorholds, with substantial OpenAI Codex assistance. Apache-2.0. +Default verification is read-only. --emit deliberately writes RESULT.json. +""" + +import argparse +from hashlib import sha256 +import json +from pathlib import Path +import sys +from types import ModuleType + + +PACKAGE = Path(__file__).resolve().parent + + +def local_module(name): + path = PACKAGE / (name + ".py") + module = ModuleType("six_seven_" + name) + module.__file__ = str(path) + sys.modules[module.__name__] = module + exec(compile(path.read_bytes(), str(path), "exec"), module.__dict__) + return module + + +def run(): + model = local_module("model") + inputs = model.authenticate() + primary, primary_engine = model.run() + other = local_module("independent").run() + independent_engine = other.pop("independent_engine") + model.need(model.canonical_json(primary) == model.canonical_json(other), + "separate exact engines disagree") + controls = local_module("controls").run(model) + actual = local_module("actual_controls").run(model) + actual_d2 = local_module("d2_controls").run(model) + scientific = {str(path.relative_to(PACKAGE)): sha256(path.read_bytes()).hexdigest() + for path in sorted(PACKAGE.rglob("*")) + if path.is_file() and path.suffix in (".py", ".md", ".lean")} + source_hashes = {name: sha256(model.regular_bytes( + PACKAGE if name in model.RETAINED_INPUTS else model.ROOT, name)).hexdigest() + for name in inputs} + source_hashes["SOURCES.json"] = sha256((PACKAGE / "SOURCES.json").read_bytes()).hexdigest() + return {"schema_version": 1, "finite_inputs": primary, "consumed_source_sha256": source_hashes, + "primary_engine": primary_engine, "independent_engine": independent_engine, + "controls": controls, "actual_factorization_controls": actual, + "actual_d2_factorization_controls": actual_d2, + "scientific_sha256": scientific} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--emit", action="store_true") + parser.add_argument("--sources-only", action="store_true") + args = parser.parse_args() + try: + model = local_module("model") + if args.sources_only: + model.authenticate() + print("PASS_P112_SIX_SEVEN_SOURCES scope=source-integrity-only") + return 0 + result = run() + path = PACKAGE / "RESULT.json" + if args.emit: + path.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + else: + expected = model.strict_json(path.read_bytes()) + model.need(model.canonical_json(expected) == model.canonical_json(result), + "scientific receipt or JSON types differ") + except (OSError, ValueError, KeyError, TypeError, RuntimeError) as error: + print("FAIL_P112_SIX_SEVEN_SUPPLEMENT: " + str(error), file=sys.stderr) + return 1 + print("PASS_P112_SIX_SEVEN_SUPPLEMENT affine6=43180 completions=6216 " + "orthogonal_pairs=3780 sharp_sparse=5 optimal_covers=7896 frame_cuts=42840 " + "callers=9 shared_frame_profiles=2 actual_d1_controls=2 actual_d2_controls=2 engines=2 " + "scope=finite-proof-inputs-and-controls") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())