Correct the κ=0.1 complex cost screen and bound scalar-query repairs

research/kappa01-bit-repair/PLANE_REPAIR.md

@@ -0,0 +1,183 @@
+# Two explicit geometry repair attempts
+
+The first construction changes the bit label form to an indefinite rational
+form, escaping the positive-definite sign-class argument. The second changes
+the complex-side port geometry to rank-two subspaces of a five-dimensional
+binary space. Both are concrete geometry changes. Neither achieves the
+target after even an optimistic decoder bill.
+
+## An indefinite rational pentagon
+
+With form `diag(1,1,-1)`, take the five rational lines generated by
+
+```
+(1,0,0), (0,1,0), (4,0,3), (3,3,4), (0,4,3).
+```
+
+Their norms are `1,1,7,2,7`, so every port is nondegenerate. Their exact
+orthogonality graph is the five-cycle. This gives an explicit indefinite
+geometry whose free mask has an odd cycle; the positive-definite proof is
+not silently being reapplied to it.
+
+The checker exhausts all `2^10=1024` binary fitting matrices, with diagonal
+one and off-diagonal entries permitted only on directed cycle edges. Their
+minimum binary rank is three; an attaining matrix is retained in the receipt.
+Already the independent pair of ports gives a weaker, sufficient obstruction:
+after deleting zero-pairing terms, any scalar fitting decoder needs at least
+two positive-cost terms. Pricing every term at rank one gives
+
+```
+3*(2/7)^(8/9) + (3/5)*(1/7)^(8/9) > 1.091559257463.
+```
+
+This excludes this five-port decoder at the target. It does not exclude
+other indefinite rational geometries or a non-label bit circuit.
+
+## All nondegenerate binary planes in dimension five
+
+Use `F2^5` with the standard dot product. A two-dimensional subspace has three
+nonzero vectors `{a,b,a+b}`. It is nondegenerate exactly when its two-by-two
+Gram determinant is one. Enumerating all unordered distinct nonzero `a,b`
+and deduplicating gives exactly **80 planes**: 20 alternating planes and 60
+nonalternating planes.
+
+Let two different planes be adjacent precisely when they are fully
+orthogonal. The exact graph has 160 edges and is four-regular. Full
+orthogonality is stronger than having a low-rank, nonzero pairing. Only the
+former is being declared free in this model.
+
+One explicitly retained independent set has 34 planes. Starting from it,
+apply the group generated by the four adjacent coordinate swaps and
+
+```
+x -> x + (a dot x)*a,       a=(1,1,1,1,0).
+```
+
+The checker builds 720 distinct dot-preserving linear maps and obtains 30
+distinct independent sets. It verifies every set against every relevant
+pairing. Each alternating plane belongs to 15 of these sets; every other
+plane belongs to 12. Thus **every subset S of the 80 planes** satisfies
+
+```
+alpha(G[S]) >= (2/5)*|S|.                    (1)
+```
+
+Indeed, summing `|S intersect I|` over the 30 certified independent sets gives
+at least `12*|S|`; one intersection has size at least `2*|S|/5`. This is an
+exact finite covering certificate for all subsets at once. It requires no
+optimizer optimality claim, classification of the orthogonal group, or
+external graph theorem. The saved independent sets and their multiplicities
+are in `PLANE_RESULT.json`.
+
+The same certificate permits repeated ports. Give each plane its nonnegative
+integer multiplicity and replace intersection sizes by their total weights.
+The sum over the 30 sets is still at least 12 times the total port count.
+All copies of one plane can belong to the independent restriction: their
+mutual pairing is nonzero, so the scalar fitting conditions force zero
+off-diagonal entries between those copies. Thus (1) remains valid with
+`|S|` interpreted as the number of ports counted with multiplicity.
+
+## Scalar query costs, including rank-one pairings
+
+Here a scalar fitting matrix `K` has diagonal one and may be nonzero off the
+diagonal only at the full-orthogonality edges. A proposed scalar query decoder
+factors it as
+
+```
+K = sum_j f_j*g_j^T
+```
+
+over the scalar field. A term is charged by the binary pairing rank between
+the span of its reader planes and the span of its source planes. In
+particular, a nonzero pairing can have rank **one**, despite the individual
+port planes having dimension two. The proof does not replace that one by two.
+
+A zero-cost term pairs its entire source and reader spans to zero, so it is
+supported only on full-orthogonality edges and has zero diagonal. Deleting all
+such terms preserves the fitting conditions. Let `L` be the number of
+remaining terms. Restrict to an independent set `I` in the chosen port
+subset. The remaining fitting matrix is the identity on `I`, so rank
+subadditivity gives `L>=|I|`. Every remaining term has a positive integer
+pairing rank and therefore rank at least one. By (1),
+
+```
+L >= (2/5)*V.
+```
+
+At three stages, `h=5,k=2,d=3,m=11`, the ideal data bill is
+`3*(3/11)^(8/9)`. Grant every positive-cost query term rank exactly one,
+charge no other decoder work, and divide the three invocations among the
+two data banks. The complete necessary lower floor is
+
+```
+3*(3/11)^(8/9) + (3/5)*(1/11)^(8/9)
+    > 1.016448096636709 > 1.                  (2)
+```
+
+Consequently **no subset or multiset of these 80 planes admits the target within this
+scalar full-orthogonality-mask/support-pairing-cost model**. The margin is
+over 1.64% even after giving all factors their most favorable unit rank and
+waiving every other charge.
+
+## Extension to every odd stage count
+
+The same exclusion holds at every odd stage count `s>=3`, under the coverage
+and active-child hypotheses in [PROOF.md](PROOF.md). This extension uses the
+pressure comparison, so it also grants every additional paid child its most
+favorable full rank `m`. Put `k=2`, `d=h-k=3`, and `m=2+3s`. Let `C` be the
+sum of query tariffs in one invocation and retain the bound `L/V>=2/5`.
+Each query factor is charged separately at its full support-pairing rank;
+splitting that charge into smaller-rank children can only increase its
+`8/9` moment. Fusing different queries or different active climbs is outside
+these assumptions.
+
+For `P=sum r*((m/r)^(1/9)-1)` and deficit `D=mW-sum r`, the coverage law gives
+`D<=(s-1)*V*k-s*C`. Combining the copy part `s*C` with its pressure and
+pricing each of the `L` positive query ranks at one yields
+
+```
+(P-D)/(s*V) >= F(s),
+F(s) = [2*3^(8/9)+2/5]*(2+3s)^(1/9) - 8 + 2/s.
+```
+
+The exact enclosures verify `F(3)>0` and
+
+```
+F'(3) = [2*3^(8/9)+2/5]/[3*11^(8/9)] - 2/9
+       > 0.003655132585 > 0.
+```
+
+Writing `A=2*3^(8/9)+2/5`, the condition `F'(s)>0` is equivalent to
+`s^2/(2+3s)^(8/9)>6/A`. The left side increases strictly for `s>0`, because
+its logarithmic derivative is
+
+```
+2/s - 8/[3*(2+3s)] = (12+10s)/[3s*(2+3s)] > 0.
+```
+
+Hence `F` is positive and increasing on `s>=3`. The target moment requires
+`P<D`; this positive lower bound rules it out at every allowed odd stage.
+
+This does not identify the scalar fitting matrix with a vector-valued
+`I_2`-block fitting matrix. It does not charge every nonzero term rank two.
+It also does not exclude a redesigned endpoint that admits partial nonzero
+pairings for free, a different boundary or coverage law, a non-scalar query
+program outside this factorization, or higher ambient dimensions. Those
+would change stated hypotheses.
+
+## Verification and next construction question
+
+```sh
+python3 -I -O -B research/kappa01-bit-repair/plane_search.py
+```
+
+The all-subset result follows from the 30 exact independent sets, not a
+numerical maximum-independent-set result. Integer-root enclosures certify
+both target bills and the all-stage derivative witness. The indefinite binary fitting census uses ordinary exact
+F2 elimination and has a positive rank-three witness.
+
+The next geometry should change either this free mask or its ambient/rank
+pair. Rank-three planes in binary dimension eight have density `3/8` and
+avoid this particular 80-plane certificate; no favorable fitting decoder for
+them is supplied here. The original bit-side indefinite family remains open
+beyond the explicitly checked five-cycle.