From d4558153de55f3b77ae8727872a3e18d92789268 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Fri, 16 Oct 2026 22:27:54 -0500 Subject: [PATCH 1/2] Audit kappa 0.1 proposal and constrain scalar-query repair routes --- research/kappa01-bit-repair/PLANE_REPAIR.md | 183 + research/kappa01-bit-repair/PLANE_RESULT.json | 1859 ++++++++ research/kappa01-bit-repair/PROOF.md | 213 + research/kappa01-bit-repair/README.md | 84 + research/kappa01-bit-repair/RESULT.json | 236 + research/kappa01-bit-repair/SOURCES.json | 29 + research/kappa01-bit-repair/WALSH-CHARGE.md | 238 + research/kappa01-bit-repair/WALSH-RESULT.json | 386 ++ .../kappa01-bit-repair/WALSH-SOURCES.json | 17 + research/kappa01-bit-repair/plane_search.py | 186 + research/kappa01-bit-repair/verify.py | 191 + research/kappa01-bit-repair/walsh_charge.py | 182 + .../LINE3-COROLLARY.md | 44 + .../PLANES6-RESULT.json | 4169 +++++++++++++++++ .../PLANES6-SOURCES.json | 22 + research/kappa01-fieldline-repair/PLANES6.md | 132 + research/kappa01-fieldline-repair/README.md | 244 + research/kappa01-fieldline-repair/RESULT.json | 81 + .../kappa01-fieldline-repair/SOURCES.json | 40 + research/kappa01-fieldline-repair/planes6.py | 149 + research/kappa01-fieldline-repair/verify.py | 227 + research/kappa01-haemers-repair/README.md | 131 + research/kappa01-haemers-repair/RESULT.json | 171 + research/kappa01-haemers-repair/SOURCES.json | 19 + research/kappa01-haemers-repair/verify.py | 127 + .../kappa01-outer-repair/ADAPTER-FUSION.md | 176 + .../kappa01-outer-repair/ADAPTER-RESULT.json | 468 ++ .../CONVOLUTION-FRAMES.md | 218 + .../CONVOLUTION-RESULT.json | 470 ++ research/kappa01-outer-repair/README.md | 247 + research/kappa01-outer-repair/RESULT.json | 109 + .../kappa01-outer-repair/adapter_fusion.py | 363 ++ .../convolution_frames.py | 245 + research/kappa01-outer-repair/verify.py | 233 + research/kappa01-plane-audit/README.md | 219 + research/kappa01-plane-audit/RESULT.json | 515 ++ research/kappa01-plane-audit/SOURCES.json | 57 + research/kappa01-plane-audit/verify.py | 222 + research/kappa01-repair/CHECKPOINT.md | 89 + research/kappa01-repair/FIELD-GEOMETRY.md | 94 + research/kappa01-repair/FIELD-RESULT.json | 82 + research/kappa01-repair/README.md | 168 + research/kappa01-repair/REPLAY.json | 91 + research/kappa01-repair/field_geometry.py | 178 + research/kappa01-repair/verify.py | 51 + 45 files changed, 13655 insertions(+) create mode 100644 research/kappa01-bit-repair/PLANE_REPAIR.md create mode 100644 research/kappa01-bit-repair/PLANE_RESULT.json create mode 100644 research/kappa01-bit-repair/PROOF.md create mode 100644 research/kappa01-bit-repair/README.md create mode 100644 research/kappa01-bit-repair/RESULT.json create mode 100644 research/kappa01-bit-repair/SOURCES.json create mode 100644 research/kappa01-bit-repair/WALSH-CHARGE.md create mode 100644 research/kappa01-bit-repair/WALSH-RESULT.json create mode 100644 research/kappa01-bit-repair/WALSH-SOURCES.json create mode 100644 research/kappa01-bit-repair/plane_search.py create mode 100644 research/kappa01-bit-repair/verify.py create mode 100644 research/kappa01-bit-repair/walsh_charge.py create mode 100644 research/kappa01-fieldline-repair/LINE3-COROLLARY.md create mode 100644 research/kappa01-fieldline-repair/PLANES6-RESULT.json create mode 100644 research/kappa01-fieldline-repair/PLANES6-SOURCES.json create mode 100644 research/kappa01-fieldline-repair/PLANES6.md create mode 100644 research/kappa01-fieldline-repair/README.md create mode 100644 research/kappa01-fieldline-repair/RESULT.json create mode 100644 research/kappa01-fieldline-repair/SOURCES.json create mode 100644 research/kappa01-fieldline-repair/planes6.py create mode 100644 research/kappa01-fieldline-repair/verify.py create mode 100644 research/kappa01-haemers-repair/README.md create mode 100644 research/kappa01-haemers-repair/RESULT.json create mode 100644 research/kappa01-haemers-repair/SOURCES.json create mode 100644 research/kappa01-haemers-repair/verify.py create mode 100644 research/kappa01-outer-repair/ADAPTER-FUSION.md create mode 100644 research/kappa01-outer-repair/ADAPTER-RESULT.json create mode 100644 research/kappa01-outer-repair/CONVOLUTION-FRAMES.md create mode 100644 research/kappa01-outer-repair/CONVOLUTION-RESULT.json create mode 100644 research/kappa01-outer-repair/README.md create mode 100644 research/kappa01-outer-repair/RESULT.json create mode 100644 research/kappa01-outer-repair/adapter_fusion.py create mode 100644 research/kappa01-outer-repair/convolution_frames.py create mode 100644 research/kappa01-outer-repair/verify.py create mode 100644 research/kappa01-plane-audit/README.md create mode 100644 research/kappa01-plane-audit/RESULT.json create mode 100644 research/kappa01-plane-audit/SOURCES.json create mode 100644 research/kappa01-plane-audit/verify.py create mode 100644 research/kappa01-repair/CHECKPOINT.md create mode 100644 research/kappa01-repair/FIELD-GEOMETRY.md create mode 100644 research/kappa01-repair/FIELD-RESULT.json create mode 100644 research/kappa01-repair/README.md create mode 100644 research/kappa01-repair/REPLAY.json create mode 100644 research/kappa01-repair/field_geometry.py create mode 100644 research/kappa01-repair/verify.py diff --git a/research/kappa01-bit-repair/PLANE_REPAIR.md b/research/kappa01-bit-repair/PLANE_REPAIR.md new file mode 100644 index 0000000000..d40b01c79e --- /dev/null +++ b/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=3` be odd, let `v>0` count ports, let a port label have rank `k`, +and let the local ambient width be `h>k>0`. Put + +``` +d = h-k, m = k+s*d. +``` + +Here `d` is an active frame climb, not the primitive exponent saving. Assume: + +1. **Coverage:** for `W` roles, the total paid child rank mass `R` has deficit + `D=mW-R <= (s-1)*v*k-s*C`, where `C>=0` is the per-invocation copy rank + charge. For the first obstruction it is enough to take `C=0`. +2. **Active data:** the `s` stages force `2*s*v` active data climbs, each + of rank `d`. All their rank mass is paid by children of rank at most `d`. + A child cannot discharge several such frame changes with one uncharged + combination. This is the relevant single-frame-change (Bat) hypothesis. +3. **Other charges:** every other child has rank at most `m`, and all + surcharges are nonnegative. Children of rank exactly `m` are granted + freely as a relaxation of the usual strict recursive shrinkage limit. + +No helper lower bound, copy lower bound, chronological hosting restriction, +idle-rank bound below `m`, or supplier precision cost is used. These costs can +only worsen the following necessary conditions. The theorem remains scoped +to the coverage and active-data laws; a construction that changes those laws +is outside it. + +At exponent saving `q=1/9`, define the rank pressure + +``` +P = sum_children r*((m/r)^q-1). +``` + +The normalized moment is `(R+P)/(mW)`. A necessary condition for strict +admission is therefore `P= 2*s*v*d*((m/d)^q-1). +``` + +Writing `t=d/k`, and dividing by `v*k`, gives the necessary inequality + +``` +2*s*t*((s+1/t)^(1/9)-1) < s-1. (1) +``` + +## Every stage count at least five fails if h/k is at least three + +For fixed `s>1`, the function + +``` +f(t)=t*((s+1/t)^q-1) +``` + +is strictly increasing for `t>0`. To check this, set `x=s+1/t>s`. +Its derivative in `t` is + +``` +(1-q)*x^q + q*s*x^(q-1) - 1. +``` + +As a function of `x`, the displayed expression has derivative +`q*(1-q)*x^(q-2)*(x-s)>0`; its value at `x=s` is `s^q-1>0`. + +Now suppose `h/k>=3`, equivalently `t>=2`. + +* For `s=5`, the left side of (1) is at least + `20*((11/2)^(1/9)-1)>4`. The strict comparison is the integer inequality + `2*6^9 < 11*5^9`. +* For `s=7`, it is greater than `28*(7^(1/9)-1)>6`. + The strict comparison is `17^9 < 7*14^9`. +* For every `s>=9`, it is greater than + `4*s*(9^(1/9)-1)>s>s-1`. + The strict comparison is `5^9 < 9*4^9`. + +These cases include every odd `s>=5`, and contradict (1). This is an analytic +all-stage proof with three finite integer comparisons, not a stage-count +search. + +## The exact three-stage density threshold + +When `s=3`, (1) is equivalent to + +``` +3*((h-k)/(3*h-2*k))^(8/9) < 1. (2) +``` + +The left side is also the ideal normalized bill for two banks with no helper +or copy charge. Solving (2) gives + +``` +h/k < 1 + 1/(3^(9/8)-3) = 3.264451365238..., +k/h > (3^(9/8)-3)/(3^(9/8)-2) = 0.306330187868.... +``` + +Because the width-ratio boundary is greater than three, the preceding +all-stage theorem applies to every `s>=5` at and above that boundary. +Consequently **every odd stage count fails whenever +`h/k >= 1+1/(3^(9/8)-3)`**. Equivalently, an admitted construction in this +model at `q=1/9` must have label density `k/h>0.306330187868...`. +Equality does not pass the strict moment test. + +For a simpler exact corollary, every geometry with `h/k>=4` fails. Its +three-stage bill is at least `3*(3/10)^(8/9)>1`, witnessed by +`3^17>10^8`. Thus the bit E8 line geometry `(h,k)=(8,1)` and its hypothetical +rank-two geometry `(8,2)` both fail in this model even with all helpers and +centre charges removed. + +## What a three-stage repair would still have to pay + +Suppose the geometry clears the density test. Grant every unit of copy rank +mass a child of the maximum local rank `h`, with every other non-data expense +zero. The copy pressure is at least +`3*C*((m/h)^(1/9)-1)`, while coverage loses `3*C`. Hence strict admission +requires + +``` +C/(v*k) < +[2-6*((h-k)/k)*((m/(h-k))^(1/9)-1)] / +[3*(m/h)^(1/9)], m=3*h-2*k. (3) +``` + +This uses the copy-rank cap `h` in (Bat), in addition to the earlier +hypotheses. It is a necessary allowance, not an attained copy price. + +| h | k | k/h | Ideal data bill | Strict copy-rank allowance C/(v*k) | +|---:|---:|---:|---:|---:| +| 8 | 1 | 1/8 | 1.084063962275 | none; data already fail | +| 8 | 2 | 1/4 | 1.028821775684 | none; data already fail | +| 3 | 1 | 1/3 | 0.985156473147 | <0.063046005269 | +| 8 | 3 | 3/8 | 0.960793691650 | <0.143312658260 | +| 5 | 2 | 2/5 | 0.945249921321 | <0.183911638463 | +| 8 | 4 | 1/2 | 0.874896779682 | <0.308879754981 | + +Thus even the density-one-third candidate needs a complete decoder with copy +rank per port below 6.31% of the label rank, before helpers, framing, +restoration, hosting and any other local expense. No such decoder is supplied +here. Density-one-third is a geometrically meaningful target that survives +this relaxed arithmetic, but is far from sufficient. + +## The rank-one positive-definite three-dimensional attempt fails + +There is a stronger obstruction for one concrete surviving geometry. Suppose +`h=3,k=1`, the label form is positive definite, and decoding is a sum of binary +scalar outer products. Require the resulting fitting matrix to have diagonal +one and to vanish off the diagonal unless the two port lines are orthogonal. +Price a term by the rational rank of the pairing between the spans of its +reader lines and source lines. This is a label-decoder restriction, not a +restriction on every possible bit circuit. + +Any finite collection of lines in a positive-definite real three-dimensional +space has a pairwise nonorthogonal subset of size at least `v/4`. To see this, +identify the form with the standard dot product and choose a generic rotation +so every coordinate of every representative is nonzero. Orient each line so +its first coordinate is positive. There are four sign choices for the other +two coordinates. Two representatives of the same sign choice have positive +dot product. One class has at least `ceil(v/4)` members. + +Restrict the fitting matrix to such a subset `S`; it is `I_S` over `F2`. +Every scalar outer product has restricted binary rank at most one. If a term +has zero pairing-rank cost, it is identically zero on `S x S`: any nonzero +restricted entry would exhibit a nonzero pairing between two lines in `S`. +Thus each nonzero restricted term costs at least one, and rank subadditivity +gives total copy charge `C>=|S|>=v/4`. + +This contradicts the necessary allowance `C/v<0.063046005269...` from (3). +Hence the positive-definite three-dimensional rank-one **label-decoder** +attempt cannot repair the target even with all other local costs waived. +The elementary upper bound `0.063046005269...<1/4` is checked in the receipt. +Indefinite label forms, arbitrary non-label circuits, and general rank-k +subspace systems are outside this argument. + +## Tensor and aggregation boundaries + +A uniform direct-sum lift `(h,k)->(d*h,d*k)` preserves the ratios in (1)--(3). +Tensoring with an identity of dimension `d` has this same scaling. It cannot +turn a failing rank-density screen into a passing one. + +A literal tensor power of the port subspace in its ambient space has density +`(k/h)^d`, which decreases for `h>k` and `d>1`. It also fails to provide the +needed density gain by itself. These statements do not cover a redesigned +subspace embedding, a new coverage law, or a global operator decomposition +that changes the active-climb obligation. + +The active-child cap is substantive: if the rank mass of the three-stage E8 +line example is arbitrarily repacked into rank-`m` children, its fractional +bill becomes `3*(h-k)/m=21/22<1`. This is an intentional scope control. Such +repacking violates the stated active-climb cap and is not a physical word. +The present theorem therefore identifies a hypothesis a block construction +must change; it does not rule out that construction universally. + +Finally, passing `q=1/9` only leaves a possible strict neighborhood. The +retained outer transfer needs positive margin beyond the boundary to claim +`kappa=1/10` with all finite transfer losses. This package establishes no +outer-transfer margin or multiplication theorem. diff --git a/research/kappa01-bit-repair/README.md b/research/kappa01-bit-repair/README.md new file mode 100644 index 0000000000..3f7f0b335f --- /dev/null +++ b/research/kappa01-bit-repair/README.md @@ -0,0 +1,84 @@ +# Bit repair requirements for kappa = 0.1 + +**Scoped necessary conditions and candidate budgets; no new supplier or +kappa improvement.** The selected result is unchanged. + +A target repair within the compressed-window model needs label density +`k/h>0.306330187868...`. Every odd stage count fails at primitive saving +`1/9` when `h/k>=3.264451365238...`, even with helpers and centre charges +free and every remaining idle charge placed at full rank. Every odd stage +count at least five already fails when `h/k>=3`. + +This is stronger for the stated family than observing that the selected +PR589 profile costs more than one: it permits arbitrary helper improvements, +copy deletion, and ideal idle placement, while retaining the specific +coverage and active-data-climb laws. Uniform rank scaling preserves the +obstruction. A different global block or coverage law may escape it. + +The proof and exact hypotheses are in [PROOF.md](PROOF.md). In particular, +the source's general-rank law is an explicitly stated premise; this package +does not claim that every conceivable rank-k bit network obeys it. + +For a three-stage replacement with `(h,k)=(3,1)`, the ideal data-only bill is +`0.985156473147...`, so it survives the density screen. But even granting +free helpers and maximum rank-h copies, its copy-rank charge must satisfy +`C/(v*k)<0.063046005269...`. The corresponding allowances for `(8,3)`, +`(5,2)`, and `(8,4)` are approximately `0.143313`, `0.183912`, and `0.308880`. +These are concrete design budgets, not existing bit decoders. + +The positive-definite `(h,k)=(3,1)` label-decoder attempt can also be excluded: +a four-sign-class argument gives copy rank `C/v>=1/4`, already above its +`0.063046...` allowance. This extra argument is specific to positive-definite +rank-one labels and scalar outer-product decoding; it leaves indefinite +geometries and general subspace/circuit replacements open. + +Two concrete geometry changes are checked in +[PLANE_REPAIR.md](PLANE_REPAIR.md): an indefinite rational five-cycle and all +80 nondegenerate binary rank-two planes in dimension five. A certificate of +30 independent sets excludes every subset or multiset of the latter geometry +in the scalar full-orthogonality/support-pairing model. Its optimistic +three-stage target bill exceeds `1.016448`; the pressure argument extends the +exclusion to every odd stage under the stated coverage and separate-charge +hypotheses. These are checked repair attempts, not a general circuit barrier. + +## Reproduce + +Python standard library, from the repository root: + +```sh +python3 -I -B research/kappa01-bit-repair/verify.py --check-sources +python3 -I -O -B research/kappa01-bit-repair/verify.py +python3 -I -O -B research/kappa01-bit-repair/plane_search.py +``` + +The first command verifies exact pinned source bytes from the repository's +Git object database. The second is an independent execution under optimized +Python and proves that acceptance does not rely on `assert`. Both compare +the computed rational receipt to [RESULT.json](RESULT.json). + +The verifier checks five integer witnesses in the all-stage proof, enclosures +for the exact algebraic density threshold, ten candidate geometries, +direct-sum invariance, literal tensor-power deterioration, and controls that +preserve passing examples outside the stated obstruction. It also confirms +that removing the active-child rank cap reverses the E8 relaxed verdict. +It is a finite check accompanying the analytic proof, not a formal proof +assistant or supplier replay. + +## Open next questions + +1. Construct an explicit rational bit port system with density above the + threshold and a fully charged decoder below (3). For density one-third, + the very small copy allowance is the immediate obstacle. +2. Exhibit a chronological block that genuinely combines multiple active + climbs into higher-rank children, and prove its common-frame, dirty-input + and endpoint identities. This changes the precise cap used here. +3. Derive a different coverage law or an outer transfer that eliminates the + bit bottleneck. Neither is supplied by improved scalar addition counts. + +Source pin: `997e6a9ca7b4f95d50e366f61412fd640d72a88a`. +Credit DreamingOfClouds and the format-limits predecessor chain for the +compressed-window accounting, DreamingOfClouds' PR589 on eumemic's PR555 +for the selected bit supplier, and the retained independent projector-ledger +and revision-3 lever audits. The new contribution is the analytic +target-1/9 density obstruction and its repair allowances. Prepared with +substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/kappa01-bit-repair/RESULT.json b/research/kappa01-bit-repair/RESULT.json new file mode 100644 index 0000000000..f8e91ef6bd --- /dev/null +++ b/research/kappa01-bit-repair/RESULT.json @@ -0,0 +1,236 @@ +{ + "all_odd_stage_obstruction": "h/k >= 1 + 1/(3^(9/8)-3)", + "candidate_budgets": [ + { + "ambient_h": 8, + "data_relaxation_passes": false, + "density_k_over_h": "1/8", + "label_rank_k": 1, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "-1849407170050333441422005267112942440/1678440702945417338244438168735216399", + "lower_decimal": "-1.101860296169471474", + "upper": "-3698814340100666882844010534225884838/3356881405890834676488876337470432801", + "upper_decimal": "-1.101860296169471474" + }, + "s3_data_only_bill": { + "lower": "135507995284376894553534120835868991/125000000000000000000000000000000000", + "lower_decimal": "1.084063962275015156", + "upper": "1084063962275015156428272966686951931/1000000000000000000000000000000000000", + "upper_decimal": "1.084063962275015156" + }, + "s3_width_m": 22 + }, + { + "ambient_h": 16, + "data_relaxation_passes": false, + "density_k_over_h": "1/8", + "label_rank_k": 2, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "-1849407170050333441422005267112942440/1678440702945417338244438168735216399", + "lower_decimal": "-1.101860296169471474", + "upper": "-3698814340100666882844010534225884838/3356881405890834676488876337470432801", + "upper_decimal": "-1.101860296169471474" + }, + "s3_data_only_bill": { + "lower": "135507995284376894553534120835868991/125000000000000000000000000000000000", + "lower_decimal": "1.084063962275015156", + "upper": "1084063962275015156428272966686951931/1000000000000000000000000000000000000", + "upper_decimal": "1.084063962275015156" + }, + "s3_width_m": 44 + }, + { + "ambient_h": 24, + "data_relaxation_passes": false, + "density_k_over_h": "1/8", + "label_rank_k": 3, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "-1849407170050333441422005267112942440/1678440702945417338244438168735216399", + "lower_decimal": "-1.101860296169471474", + "upper": "-3698814340100666882844010534225884838/3356881405890834676488876337470432801", + "upper_decimal": "-1.101860296169471474" + }, + "s3_data_only_bill": { + "lower": "135507995284376894553534120835868991/125000000000000000000000000000000000", + "lower_decimal": "1.084063962275015156", + "upper": "1084063962275015156428272966686951931/1000000000000000000000000000000000000", + "upper_decimal": "1.084063962275015156" + }, + "s3_width_m": 66 + }, + { + "ambient_h": 8, + "data_relaxation_passes": false, + "density_k_over_h": "1/4", + "label_rank_k": 2, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "-288217756848833655325408665074038868/1660759768334866607376611481172469523", + "lower_decimal": "-0.173545724278840422", + "upper": "-576435513697667310650817330148077718/3321519536669733214753222962344939049", + "upper_decimal": "-0.173545724278840422" + }, + "s3_data_only_bill": { + "lower": "205764355136976673106508173301480777/200000000000000000000000000000000000", + "lower_decimal": "1.028821775684883365", + "upper": "64301360980305210345783804156712743/62500000000000000000000000000000000", + "upper_decimal": "1.028821775684883365" + }, + "s3_width_m": 20 + }, + { + "ambient_h": 9, + "data_relaxation_passes": false, + "density_k_over_h": "2/9", + "label_rank_k": 2, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "-967492790213609197107950526025918645/3329640934609599238045594562597122389", + "lower_decimal": "-0.290569706828477537", + "upper": "-120936598776701149638493815753239828/416205116826199904755699320324640299", + "upper_decimal": "-0.290569706828477537" + }, + "s3_data_only_bill": { + "lower": "1042064903922330834656867414175039939/1000000000000000000000000000000000000", + "lower_decimal": "1.042064903922330834", + "upper": "521032451961165417328433707087519971/500000000000000000000000000000000000", + "upper_decimal": "1.042064903922330834" + }, + "s3_width_m": 23 + }, + { + "ambient_h": 3, + "data_relaxation_passes": true, + "density_k_over_h": "1/3", + "label_rank_k": 1, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "103904687966598685951054118625734908/1648077265540004258195174419692308019", + "lower_decimal": "0.063046005268784273", + "upper": "207809375933197371902108237251469828/3296154531080008516390348839384616035", + "upper_decimal": "0.063046005268784273" + }, + "s3_data_only_bill": { + "lower": "985156473147628759149849411624895011/1000000000000000000000000000000000000", + "lower_decimal": "0.985156473147628759", + "upper": "492578236573814379574924705812447507/500000000000000000000000000000000000", + "upper_decimal": "0.985156473147628759" + }, + "s3_width_m": 7 + }, + { + "ambient_h": 9, + "data_relaxation_passes": true, + "density_k_over_h": "1/3", + "label_rank_k": 3, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "103904687966598685951054118625734908/1648077265540004258195174419692308019", + "lower_decimal": "0.063046005268784273", + "upper": "207809375933197371902108237251469828/3296154531080008516390348839384616035", + "upper_decimal": "0.063046005268784273" + }, + "s3_data_only_bill": { + "lower": "985156473147628759149849411624895011/1000000000000000000000000000000000000", + "lower_decimal": "0.985156473147628759", + "upper": "492578236573814379574924705812447507/500000000000000000000000000000000000", + "upper_decimal": "0.985156473147628759" + }, + "s3_width_m": 21 + }, + { + "ambient_h": 8, + "data_relaxation_passes": true, + "density_k_over_h": "3/8", + "label_rank_k": 3, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "470475700205080950439152740232508780/3282862141536807183182059591022384289", + "lower_decimal": "0.143312658260098923", + "upper": "235237850102540475219576370116254395/1641431070768403591591029795511192143", + "upper_decimal": "0.143312658260098923" + }, + "s3_data_only_bill": { + "lower": "960793691649576587463403938313957599/1000000000000000000000000000000000000", + "lower_decimal": "0.960793691649576587", + "upper": "480396845824788293731701969156978801/500000000000000000000000000000000000", + "upper_decimal": "0.960793691649576587" + }, + "s3_width_m": 18 + }, + { + "ambient_h": 5, + "data_relaxation_passes": true, + "density_k_over_h": "2/5", + "label_rank_k": 2, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "602250865473144013293145278047528549/3274675113042453877400197583387646126", + "lower_decimal": "0.183911638462846268", + "upper": "602250865473144013293145278047528558/3274675113042453877400197583387646123", + "upper_decimal": "0.183911638462846268" + }, + "s3_data_only_bill": { + "lower": "945249921320623271518804974722951949/1000000000000000000000000000000000000", + "lower_decimal": "0.945249921320623271", + "upper": "59078120082538954469925310920184497/62500000000000000000000000000000000", + "upper_decimal": "0.945249921320623271" + }, + "s3_width_m": 11 + }, + { + "ambient_h": 8, + "data_relaxation_passes": true, + "density_k_over_h": "1/2", + "label_rank_k": 4, + "s3_copy_rank_C_over_vk_strict_upper_budget": { + "lower": "1000825762543300514637844192035991628/3240179216676918509618792493865790739", + "lower_decimal": "0.308879754981495471", + "upper": "500412881271650257318922096017995817/1620089608338459254809396246932895368", + "upper_decimal": "0.308879754981495471" + }, + "s3_data_only_bill": { + "lower": "174979355936417487134053895199100209/200000000000000000000000000000000000", + "lower_decimal": "0.874896779682087435", + "upper": "109362097460260929458783684499437631/125000000000000000000000000000000000", + "upper_decimal": "0.874896779682087435" + }, + "s3_width_m": 16 + } + ], + "maximum_width_ratio_h_over_k_for_any_odd_stage": { + "lower": "1441608071319631268419175840609792123/441608071319631268419175840609792123", + "lower_decimal": "3.264451365238319065", + "upper": "720804035659815634209587920304896061/220804035659815634209587920304896061", + "upper_decimal": "3.264451365238319065" + }, + "minimum_density_k_over_h_for_any_odd_stage": { + "lower": "220804035659815634209587920304896061/720804035659815634209587920304896061", + "lower_decimal": "0.306330187868182767", + "upper": "441608071319631268419175840609792123/1441608071319631268419175840609792123", + "upper_decimal": "0.306330187868182767" + }, + "positive_definite_h3_k1_label_decoder_copy_floor_C_over_v": "1/4", + "power_scale": "1000000000000000000000000000000000000", + "scope_control_without_active_child_rank_cap": "21/22", + "stages_at_least_five_obstruction": "h/k >= 3", + "status": "scoped necessary conditions; no supplier or kappa improvement", + "strict_integer_witnesses": { + "density_one_quarter_s3": { + "left": 100000000, + "right": 129140163 + }, + "density_one_third_s3_pass": { + "left": 5038848, + "right": 5764801 + }, + "s5_t2": { + "left": 20155392, + "right": 21484375 + }, + "s7_t2_relaxed": { + "left": 118587876497, + "right": 144627327488 + }, + "s_ge_9_t2_relaxed": { + "left": 1953125, + "right": 2359296 + } + }, + "target_kappa": "1/10", + "target_primitive_saving": "1/9" +} diff --git a/research/kappa01-bit-repair/SOURCES.json b/research/kappa01-bit-repair/SOURCES.json new file mode 100644 index 0000000000..3eca0ef29d --- /dev/null +++ b/research/kappa01-bit-repair/SOURCES.json @@ -0,0 +1,29 @@ +{ + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "sources": [ + { + "path": "research/format-limits/README.md", + "sha256": "0fa0d6b2df96ddc06b876c41c5fa8d2335b97f36bc8f17d1371296d23199c263" + }, + { + "path": "research/bit589-projector-ledger/README.md", + "sha256": "61225b31eaf04cd6175c92c86729442287ffb0958f112bb4962cd237f3648446" + }, + { + "path": "research/bit-revision3-levers-seed03/README.md", + "sha256": "630911d0652f28d38dbce939bbacdb8ceac23d5fc3a20b02ec8180e4193020c2" + }, + { + "path": "upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + { + "path": "research/bit-orthogonal-pair-decoders/README.md", + "sha256": "7c833024359891e15766be310c3d1a4579dd0231fe7ffdbf981fd0814bac2dfb" + }, + { + "path": "research/bit-orthogonal-pair-decoders/PROOF.md", + "sha256": "d89b42d4aa2e6bf2c3ac454404fd1aeddbf2eb07f6ff1fc606057e3b2a928f78" + } + ] +} diff --git a/research/kappa01-bit-repair/WALSH-CHARGE.md b/research/kappa01-bit-repair/WALSH-CHARGE.md new file mode 100644 index 0000000000..f3b8a0b98b --- /dev/null +++ b/research/kappa01-bit-repair/WALSH-CHARGE.md @@ -0,0 +1,238 @@ +# A character-rank constraint on asymmetric scalar queries + +For binary rank-k ports and complex scalar queries, the complete +support-pairing tariffs obey the dimension-dependent inequality + +``` +sum_j (2^r_j - 1) >= V*(2^k - 1). (1) +``` + +This is a constructive test of the remaining low-tariff route. A term with +`r_j2`. Thus a uniform query-rank cap R gives + +``` +C/V >= R*(2^k-1)/(2^R-1), +sum_j r_j^(8/9)/V >= (2^k-1)*R^(8/9)/(2^R-1). (3) +``` + +The automatic cap is `R=h`. Within the three-stage coverage and separate +active-climb model of [PROOF.md](PROOF.md), put `m=3h-2k` and define G by + +``` +G = 3*((h-k)/m)^(8/9) + + (3/2)*(2^k-1)/(2^R-1)*(R/m)^(8/9). (4) +``` + +For two data banks, `W=2V`, this is the absolute moment lower bound +`M(1/9)>=G`. The coverage proof permits general W as well. Writing P for +pressure and D for deficit as in that proof gives + +``` +P-D >= 2*V*m*(G-1), +M(1/9) >= 1+(2V/W)*(G-1). +``` + +Thus `G>1` excludes the target for any W in that model; G itself is not a +uniform absolute moment bound when `W>2V`. The table and receipt use the +two-bank normalization for their displayed moment floors. + +All other costs are granted free in G. Splitting a separately charged rank-r +query into smaller children cannot lower its `8/9` moment. Fusing different +queries or active climbs changes the hypotheses. + +| h | k | cap R | Two-bank floor G, displayed downward | Consequence | +|---:|---:|---:|---:|---| +| 3 | 1 | 3 | 1.086059162874567 | All such binary-port scalar decoders fail | +| 4 | 2 | 4 | 1.036905740515933 | All such decoders fail | +| 5 | 2 | 5 | 1.017273567501908 | All such decoders fail | +| 6 | 2 | 6 | 1.018790703056608 | All such decoders fail | +| 6 | 3 | 5 | 1.030443929272086 | A viable decoder needs rank-six queries | +| 6 | 3 | 6 | 0.964901757923112 | Relaxation passes; no decoder supplied | +| 7 | 3 | 6 | 1.000366619854099 | A viable decoder needs rank-seven queries | +| 7 | 3 | 7 | 0.968547347614850 | Relaxation passes; no decoder supplied | +| 8 | 3 | 6 | 1.023562078533451 | A viable decoder needs rank-seven or eight queries | +| 8 | 3 | 7 | 0.996503379474117 | Relaxation passes narrowly | +| 8 | 3 | 8 | 0.980819865933461 | Relaxation passes; no decoder supplied | + +The mass-only comparison is also decisive at the previously enumerated +small dimensions. For `(h,k)=(5,2)`, (3) gives `C/V>=15/31`, exceeding the +necessary allowance `C/V<0.367823...`. For `(6,2)`, it gives `C/V>=2/7`, +exceeding `0.126092...`. These conclusions cover arbitrary ports with +multiplicities and any qualifying binary bilinear form, without graph +enumeration. At `(8,3)`, the full-rank mass floor is only `56/255` per port, +below the allowance `0.429937...`; the result deliberately leaves that +higher-dimensional regime open. + +The `(5,2)` and `(6,2)` exclusions extend to every allowed odd stage count +under the same coverage and active-climb hypotheses. For `(5,2)`, (3) gives +`sum r_j^(8/9)/V >= 3*5^(8/9)/31 > 2/5`; the last inequality has the integer +witness `62^9 < 15^9*5^8`. This supplies at least the query coefficient used +in the all-stage pressure proof in [PLANE_REPAIR.md](PLANE_REPAIR.md), so +that proof applies without its plane enumeration. For `(6,2)`, the +data-only obstruction in [PROOF.md](PROOF.md) already excludes every odd +stage count at least five; (4) supplies the remaining three-stage gate. + +## Conditional corollary for rational bit labels + +There is also a bit-side application with a separate arithmetic hypothesis. +For label geometry over a prime field `F_p`, replace `(-1)^B` by `zeta^B`, +where zeta is a primitive p-th root of unity in an extension of the scalar +coefficient field. Provided the scalar characteristic differs from p, the +character table is invertible: multiplication by the table of inverse +characters gives `p^r I`. The same proof yields + +``` +sum_j (p^r_j-1) >= V*(p^k-1). (5) +``` + +In particular, binary scalar coefficients can be extended to a finite +field containing p-th roots for any odd prime p. + +Now fix a rational-label/binary-scalar instance with an integral +presentation: an integer ambient pairing matrix and integer basis columns +for each rank-k port. Suppose each port Gram determinant is nonzero modulo +the chosen odd prime p. Reduction modulo p preserves each port's rank and +nondegeneracy, and every originally orthogonal pair remains orthogonal. +Each query's full pairing matrix is integral; its reduced rank is at most +its rational rank. Applying (5) to the reduced geometry therefore proves +(5) with the original rational query tariffs. No claim is made that an +arbitrary rational port system has such a presentation for a specified p. + +For `h=3,k=1`, a good reduction at p=3 implies `C/V>=3/13`; at p=5 it +implies `C/V>=3/31`. Both exceed the target allowance +`0.063046005269...`. Thus these good-reduction subclasses cannot repair +the rational bit geometry, including indefinite forms satisfying the +stated arithmetic condition. Merely removing positive definiteness is not +enough in these subclasses. + +The argument can be applied just to ports whose Gram determinants are +units in the fixed integral presentation. If their fraction is f, the +same respective floors become `3f/13` and `3f/31`. The exact receipt +records the resulting upper bounds on f for a putative target repair. +This is a constraint on an explicit integral presentation, not a universal +claim about all rational labels or arbitrary bit circuits. + +## Exact replay and remaining construction + +```sh +python3 -I -O -B research/kappa01-bit-repair/walsh_charge.py +``` + +The verifier checks character orthogonality through rank eight, exact +small character-matrix ranks, the explicit asymmetric cancellation example, +and rational enclosures for all listed gates, including the two conditional +odd-prime bit gates. It compares its result with +`WALSH-RESULT.json`. The interval routines and pressure proofs are pinned +in `WALSH-SOURCES.json`; existing packages are not modified. + +The next candidate must use high-rank queries efficiently enough to satisfy +(1), while its low-rank corrections and all other required work fit the +remaining moment budget. This character bound does not provide such a +factorization and does not establish kappa 0.1. It is a necessary condition +within the stated scalar-query model. Prepared with substantial OpenAI +Codex assistance and an independent AI review of the central rank argument. +Apache-2.0. diff --git a/research/kappa01-bit-repair/WALSH-RESULT.json b/research/kappa01-bit-repair/WALSH-RESULT.json new file mode 100644 index 0000000000..32bc25c9a1 --- /dev/null +++ b/research/kappa01-bit-repair/WALSH-RESULT.json @@ -0,0 +1,386 @@ +{ + "all_stage_h5k2_integer_witness": { + "left": 13537086546263552, + "right": 15016937255859375 + }, + "asymmetric_cancellation_control": { + "direct_diagonal_charge": 6, + "lifted_fitting_rank": 14, + "lifted_query_ranks": [ + 13, + 1, + 1 + ], + "port_bases": [ + [ + 1, + 2, + 4 + ], + [ + 4, + 8, + 16 + ] + ], + "queries": [ + [ + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ], + [ + [ + -1, + 0 + ], + [ + 0, + 1 + ] + ], + [ + [ + 0, + -1 + ], + [ + 1, + 0 + ] + ] + ], + "tariffs": [ + 5, + 1, + 1 + ], + "total_charge": 7 + }, + "character_checks": [ + { + "binary_rank": 0, + "character_order": 1, + "nonconstant_character_rank": 0 + }, + { + "binary_rank": 1, + "character_order": 2, + "nonconstant_character_rank": 1 + }, + { + "binary_rank": 2, + "character_order": 4, + "nonconstant_character_rank": 3 + }, + { + "binary_rank": 3, + "character_order": 8, + "nonconstant_character_rank": 7 + }, + { + "binary_rank": 4, + "character_order": 16, + "nonconstant_character_rank": 15 + }, + { + "binary_rank": 5, + "character_order": 32, + "nonconstant_character_rank": 31 + }, + { + "binary_rank": 6, + "character_order": 64, + "nonconstant_character_rank": 63 + }, + { + "binary_rank": 7, + "character_order": 128, + "nonconstant_character_rank": 127 + }, + { + "binary_rank": 8, + "character_order": 256, + "nonconstant_character_rank": 255 + } + ], + "conditional_rational_bit_good_reduction_gates": [ + { + "full_good_reduction_mass_floor_C_over_V": "3/13", + "hypothesis": "fixed integral pairing and port bases; every counted port Gram determinant is a unit modulo p", + "necessary_good_port_fraction_upper_bound": { + "lower": "103904687966598685951054118625734908/380325522816924059583501789159763389", + "lower_decimal": "0.273199356164731849", + "upper": "2701521887131565834727407084269107764/9888463593240025549171046518153848105", + "upper_decimal": "0.273199356164731849" + }, + "reduction_prime": 3, + "target_moment_floor": { + "lower": "27026705958015494244920519919126391443/26000000000000000000000000000000000000", + "lower_decimal": "1.039488690692903624", + "upper": "6756676489503873561230129979781597881/6500000000000000000000000000000000000", + "upper_decimal": "1.039488690692903624" + } + }, + { + "full_good_reduction_mass_floor_C_over_V": "3/31", + "hypothesis": "fixed integral pairing and port bases; every counted port Gram determinant is a unit modulo p", + "necessary_good_port_fraction_upper_bound": { + "lower": "3221045326964559264482677677397782148/4944231796620012774585523259076924057", + "lower_decimal": "0.651475387777437488", + "upper": "6442090653929118528965355354795564668/9888463593240025549171046518153848105", + "upper_decimal": "0.651475387777437488" + }, + "reduction_prime": 5, + "target_moment_floor": { + "lower": "62492338991330129574315098737622611839/62000000000000000000000000000000000000", + "lower_decimal": "1.007940951473066606", + "upper": "15623084747832532393578774684405653007/15500000000000000000000000000000000000", + "upper_decimal": "1.007940951473066606" + } + } + ], + "exact_target_gates": [ + { + "character_mass_floor_C_over_V": "3/7", + "excluded_by_character_moment": true, + "h": 3, + "k": 1, + "m": 7, + "mass_floor_C_over_Vk": "3/7", + "necessary_copy_allowance_C_over_Vk": { + "lower": "103904687966598685951054118625734908/1648077265540004258195174419692308019", + "lower_decimal": "0.063046005268784273", + "upper": "207809375933197371902108237251469828/3296154531080008516390348839384616035", + "upper_decimal": "0.063046005268784273" + }, + "query_rank_cap": 3, + "target_moment_floor": { + "lower": "2172118325749135590731760997089664473/2000000000000000000000000000000000000", + "lower_decimal": "1.086059162874567795", + "upper": "3801207070060987283780581744906912839/3500000000000000000000000000000000000", + "upper_decimal": "1.086059162874567795" + } + }, + { + "character_mass_floor_C_over_V": "4/5", + "excluded_by_character_moment": true, + "h": 4, + "k": 2, + "m": 8, + "mass_floor_C_over_Vk": "2/5", + "necessary_copy_allowance_C_over_Vk": { + "lower": "1000825762543300514637844192035991628/3240179216676918509618792493865790739", + "lower_decimal": "0.308879754981495471", + "upper": "500412881271650257318922096017995817/1620089608338459254809396246932895368", + "upper_decimal": "0.308879754981495471" + }, + "query_rank_cap": 4, + "target_moment_floor": { + "lower": "5184528702579666805756045503443952909/5000000000000000000000000000000000000", + "lower_decimal": "1.036905740515933361", + "upper": "10369057405159333611512091006887905851/10000000000000000000000000000000000000", + "upper_decimal": "1.036905740515933361" + } + }, + { + "character_mass_floor_C_over_V": "15/31", + "excluded_by_character_moment": true, + "h": 5, + "k": 2, + "m": 11, + "mass_floor_C_over_Vk": "15/62", + "necessary_copy_allowance_C_over_Vk": { + "lower": "602250865473144013293145278047528549/3274675113042453877400197583387646126", + "lower_decimal": "0.183911638462846268", + "upper": "602250865473144013293145278047528558/3274675113042453877400197583387646123", + "upper_decimal": "0.183911638462846268" + }, + "query_rank_cap": 5, + "target_moment_floor": { + "lower": "63070961185118352666984359682897083733/62000000000000000000000000000000000000", + "lower_decimal": "1.017273567501908913", + "upper": "7883870148139794083373044960362135491/7750000000000000000000000000000000000", + "upper_decimal": "1.017273567501908913" + } + }, + { + "character_mass_floor_C_over_V": "2/7", + "excluded_by_character_moment": true, + "h": 6, + "k": 2, + "m": 14, + "mass_floor_C_over_Vk": "1/7", + "necessary_copy_allowance_C_over_Vk": { + "lower": "103904687966598685951054118625734908/1648077265540004258195174419692308019", + "lower_decimal": "0.063046005268784273", + "upper": "207809375933197371902108237251469828/3296154531080008516390348839384616035", + "upper_decimal": "0.063046005268784273" + }, + "query_rank_cap": 6, + "target_moment_floor": { + "lower": "2037581406113216875777052881196414839/2000000000000000000000000000000000000", + "lower_decimal": "1.018790703056608437", + "upper": "3565767460698129532609842542093725979/3500000000000000000000000000000000000", + "upper_decimal": "1.018790703056608437" + } + }, + { + "character_mass_floor_C_over_V": "35/31", + "excluded_by_character_moment": true, + "h": 6, + "k": 3, + "m": 12, + "mass_floor_C_over_Vk": "35/93", + "necessary_copy_allowance_C_over_Vk": { + "lower": "1000825762543300514637844192035991628/3240179216676918509618792493865790739", + "lower_decimal": "0.308879754981495471", + "upper": "500412881271650257318922096017995817/1620089608338459254809396246932895368", + "upper_decimal": "0.308879754981495471" + }, + "query_rank_cap": 5, + "target_moment_floor": { + "lower": "63887523614869377820217624991301012263/62000000000000000000000000000000000000", + "lower_decimal": "1.030443929272086739", + "upper": "6388752361486937782021762499130101247/6200000000000000000000000000000000000", + "upper_decimal": "1.030443929272086739" + } + }, + { + "character_mass_floor_C_over_V": "2/3", + "excluded_by_character_moment": false, + "h": 6, + "k": 3, + "m": 12, + "mass_floor_C_over_Vk": "2/9", + "necessary_copy_allowance_C_over_Vk": { + "lower": "1000825762543300514637844192035991628/3240179216676918509618792493865790739", + "lower_decimal": "0.308879754981495471", + "upper": "500412881271650257318922096017995817/1620089608338459254809396246932895368", + "upper_decimal": "0.308879754981495471" + }, + "query_rank_cap": 6, + "target_moment_floor": { + "lower": "2894705273769338849479041135808652363/3000000000000000000000000000000000000", + "lower_decimal": "0.964901757923112949", + "upper": "1157882109507735539791616454323460949/1200000000000000000000000000000000000", + "upper_decimal": "0.964901757923112949" + } + }, + { + "character_mass_floor_C_over_V": "2/3", + "excluded_by_character_moment": true, + "h": 7, + "k": 3, + "m": 15, + "mass_floor_C_over_Vk": "2/9", + "necessary_copy_allowance_C_over_Vk": { + "lower": "122408209008713007712620925197252608/544185578933666636207405065145631959", + "lower_decimal": "0.224938355126154354", + "upper": "734449254052278046275725551183515656/3265113473601999817244430390873791751", + "upper_decimal": "0.224938355126154354" + }, + "query_rank_cap": 6, + "target_moment_floor": { + "lower": "6002199719124597600868327730935882471/6000000000000000000000000000000000000", + "lower_decimal": "1.000366619854099600", + "upper": "600219971912459760086832773093588249/600000000000000000000000000000000000", + "upper_decimal": "1.000366619854099600" + } + }, + { + "character_mass_floor_C_over_V": "49/127", + "excluded_by_character_moment": false, + "h": 7, + "k": 3, + "m": 15, + "mass_floor_C_over_Vk": "49/381", + "necessary_copy_allowance_C_over_Vk": { + "lower": "122408209008713007712620925197252608/544185578933666636207405065145631959", + "lower_decimal": "0.224938355126154354", + "upper": "734449254052278046275725551183515656/3265113473601999817244430390873791751", + "upper_decimal": "0.224938355126154354" + }, + "query_rank_cap": 7, + "target_moment_floor": { + "lower": "61502756573543000923565427569198272089/63500000000000000000000000000000000000", + "lower_decimal": "0.968547347614850408", + "upper": "246011026294172003694261710276793089139/254000000000000000000000000000000000000", + "upper_decimal": "0.968547347614850408" + } + }, + { + "character_mass_floor_C_over_V": "2/3", + "excluded_by_character_moment": true, + "h": 8, + "k": 3, + "m": 18, + "mass_floor_C_over_Vk": "2/9", + "necessary_copy_allowance_C_over_Vk": { + "lower": "470475700205080950439152740232508780/3282862141536807183182059591022384289", + "lower_decimal": "0.143312658260098923", + "upper": "235237850102540475219576370116254395/1641431070768403591591029795511192143", + "upper_decimal": "0.143312658260098923" + }, + "query_rank_cap": 6, + "target_moment_floor": { + "lower": "1228274494240142107130229132928938577/1200000000000000000000000000000000000", + "lower_decimal": "1.023562078533451755", + "upper": "255890519633362938985464402693528871/250000000000000000000000000000000000", + "upper_decimal": "1.023562078533451755" + } + }, + { + "character_mass_floor_C_over_V": "49/127", + "excluded_by_character_moment": false, + "h": 8, + "k": 3, + "m": 18, + "mass_floor_C_over_Vk": "49/381", + "necessary_copy_allowance_C_over_Vk": { + "lower": "470475700205080950439152740232508780/3282862141536807183182059591022384289", + "lower_decimal": "0.143312658260098923", + "upper": "235237850102540475219576370116254395/1641431070768403591591029795511192143", + "upper_decimal": "0.143312658260098923" + }, + "query_rank_cap": 7, + "target_moment_floor": { + "lower": "253111858386425941585411276725602687853/254000000000000000000000000000000000000", + "lower_decimal": "0.996503379474117880", + "upper": "63277964596606485396352819181400672159/63500000000000000000000000000000000000", + "upper_decimal": "0.996503379474117880" + } + }, + { + "character_mass_floor_C_over_V": "56/255", + "excluded_by_character_moment": false, + "h": 8, + "k": 3, + "m": 18, + "mass_floor_C_over_Vk": "56/765", + "necessary_copy_allowance_C_over_Vk": { + "lower": "470475700205080950439152740232508780/3282862141536807183182059591022384289", + "lower_decimal": "0.143312658260098923", + "upper": "235237850102540475219576370116254395/1641431070768403591591029795511192143", + "upper_decimal": "0.143312658260098923" + }, + "query_rank_cap": 8, + "target_moment_floor": { + "lower": "41684844302172103125797423568608260549/42500000000000000000000000000000000000", + "lower_decimal": "0.980819865933461250", + "upper": "166739377208688412503189694274433042713/170000000000000000000000000000000000000", + "upper_decimal": "0.980819865933461250" + } + } + ], + "general_coverage_pressure_translation": "P-D>=2*V*m*(G-1); M>=1+(2*V/W)*(G-1), so rejection sign is unchanged", + "moment_normalization": "displayed target_moment_floor is G for two data banks W=2V", + "scope": "binary nondegenerate ports, complex scalar fitting queries, full-orthogonality mask, complete support-pairing tariffs, separate query charges", + "status": "NECESSARY_QUERY_CAPACITY_BOUND; NO_WORKING_SUPPLIER", + "theorem": "sum(2^query_pairing_rank-1)>=V*(2^port_rank-1)" +} diff --git a/research/kappa01-bit-repair/WALSH-SOURCES.json b/research/kappa01-bit-repair/WALSH-SOURCES.json new file mode 100644 index 0000000000..a8999ade1c --- /dev/null +++ b/research/kappa01-bit-repair/WALSH-SOURCES.json @@ -0,0 +1,17 @@ +{ + "local_files": [ + { + "path": "research/kappa01-bit-repair/verify.py", + "sha256": "5bc7e03b25456ab139786ee79e35edbfb3631288c527f4b7d8ba15c4da437b81" + }, + { + "path": "research/kappa01-bit-repair/PROOF.md", + "sha256": "85f5dfd939e6f4fcb5baa5aae4a317a96aa01a68967483e507bdd903d657e952" + }, + { + "path": "research/kappa01-bit-repair/PLANE_REPAIR.md", + "sha256": "e36987fc02767c0a4a5cce6098a3f816fc1a3d30adfa9055f615b35c135c0f6a" + } + ], + "source_base": "997e6a9ca7b4f95d50e366f61412fd640d72a88a" +} diff --git a/research/kappa01-bit-repair/plane_search.py b/research/kappa01-bit-repair/plane_search.py new file mode 100644 index 0000000000..3db4c8b9a9 --- /dev/null +++ b/research/kappa01-bit-repair/plane_search.py @@ -0,0 +1,186 @@ +#!/usr/bin/env python3 +"""Exact constructive geometry attempts and their independently checked bills.""" +from __future__ import annotations + +import argparse +from collections import Counter +from fractions import Fraction as F +import importlib.util +from itertools import combinations +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("local_exact_budget", HERE / "verify.py") +budget = importlib.util.module_from_spec(spec) +spec.loader.exec_module(budget) + + +def require(x: bool, text: str) -> None: + if not x: + raise ValueError(text) + + +def parity(x: int) -> int: + return x.bit_count() % 2 + + +def rank2(rows: list[int]) -> int: + pivots = {} + for row in rows: + while row: + pivot = row.bit_length() - 1 + if pivot not in pivots: + pivots[pivot] = row + break + row ^= pivots[pivot] + return len(pivots) + + +def indefinite_pentagon() -> dict: + ports = [(1, 0, 0), (0, 1, 0), (4, 0, 3), (3, 3, 4), (0, 4, 3)] + pairing = [[a[0]*b[0]+a[1]*b[1]-a[2]*b[2] for b in ports] for a in ports] + require([pairing[i][i] for i in range(5)] == [1, 1, 7, 2, 7], "pentagon nondegeneracy") + allowed = [(i, j) for i in range(5) for j in range(5) if i != j and pairing[i][j] == 0] + require(set(allowed) == {(i, j) for i in range(5) for j in range(5) + if (i-j) % 5 in (1, 4)}, "pentagon free mask") + counts = Counter() + witness = None + for mask in range(1 << len(allowed)): + rows = [1 << i for i in range(5)] + for bit, (i, j) in enumerate(allowed): + if mask >> bit & 1: + rows[i] |= 1 << j + r = rank2(rows) + counts[r] += 1 + if r == 3 and witness is None: + witness = rows + require(min(counts) == 3 and sum(counts.values()) == 1024, "pentagon minrank census") + # Even the weaker size-two independent set already excludes this target + # with scalar factors charged only one each. + floor = budget.add(budget.scale(budget.power(F(2, 7), 8, 9), F(3)), + budget.scale(budget.power(F(1, 7), 8, 9), F(3, 5))) + require(floor[0] > 1, "pentagon target floor") + return {"form": [[1, 0, 0], [0, 1, 0], [0, 0, -1]], "ports": ports, + "pairing": pairing, "binary_fitting_rank_counts": dict(sorted(counts.items())), + "rank_three_fitting_rows_bitmask": witness, + "independent_set_indices": [0, 2], + "weak_unit_factor_target_floor": budget.record(floor)} + + +def apply(columns: tuple[int, ...], x: int) -> int: + out = 0 + for i in range(5): + if x >> i & 1: + out ^= columns[i] + return out + + +def plane_geometry() -> dict: + planes = sorted({tuple(sorted((a, b, a ^ b))) + for a, b in combinations(range(1, 32), 2) + if parity(a)*parity(b) ^ parity(a & b)}) + require(len(planes) == 80, "nondegenerate plane count") + lookup = {plane: i for i, plane in enumerate(planes)} + adjacency = [sum(1 << j for j, v in enumerate(planes) + if all(parity(a & b) == 0 for a in u for b in v)) for u in planes] + require(all(x.bit_count() == 4 for x in adjacency), "plane degree four") + require(all(not (adjacency[i] >> i & 1) for i in range(80)), "no self adjacency") + require(all(((adjacency[i] >> j) & 1) == ((adjacency[j] >> i) & 1) + for i in range(80) for j in range(80)), "symmetric graph") + + def independent(s: tuple[int, ...]) -> bool: + bits = sum(1 << i for i in s) + return len(set(s)) == len(s) and all(not (adjacency[i] & bits) for i in s) + + # Discovered by a small optimization, accepted only by exact checks here. + # No optimizer, optimality claim, or floating point is used in this replay. + seed = (2, 5, 9, 12, 16, 19, 22, 25, 28, 31, 34, 41, 42, 43, 44, 45, 48, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 63, 64, 65, 66, 67, 71, 75, 79) + require(independent(seed), "independent seed") + generators = [] + for i in range(4): + g = [1 << j for j in range(5)] + g[i], g[i+1] = g[i+1], g[i] + generators.append(tuple(g)) + generators.append(tuple((1 << i) ^ (15 if parity(15 & (1 << i)) else 0) + for i in range(5))) + identity = (1, 2, 4, 8, 16) + matrices, seen = [identity], {identity} + for g in matrices: + for h in generators: + gh = tuple(apply(g, x) for x in h) + if gh not in seen: + seen.add(gh) + matrices.append(gh) + require(len(matrices) == 720, "generated maps") + family = set() + for g in matrices: + require(all(parity(g[i] & g[j]) == (i == j) + for i in range(5) for j in range(5)), "dot-preserving map") + image = tuple(sorted(lookup[tuple(sorted(apply(g, x) for x in planes[i]))] + for i in seed)) + require(independent(image), "independent image") + family.add(image) + family = sorted(family) + counts = [sum(i in s for s in family) for i in range(80)] + require(len(family) == 30, "independent-set cover size") + require(Counter(counts) == Counter({12: 60, 15: 20}), "cover multiplicities") + require(all(counts[i] == (15 if not any(parity(x) for x in u) else 12) + for i, u in enumerate(planes)), "cover by geometric type") + + # A complete scalar fitting factorization has at least alpha positive-cost + # factors after removing zero-pairing factors. Price each one at only rank1. + floor = budget.add(budget.scale(budget.power(F(3, 11), 8, 9), F(3)), + budget.scale(budget.power(F(1, 11), 8, 9), F(3, 5))) + require(floor[0] > F(1016, 1000), "strict plane target floor") + # With the source coverage law and separate active/query charges, + # (P-D)/(s*V) >= A*(2+3*s)^(1/9)-8+2/s. Its derivative is + # A/(3*(2+3*s)^(8/9))-2/s**2, positive for all s>=3 once positive at3. + coefficient = budget.add(budget.scale(budget.power(F(3), 8, 9), F(2)), + (F(2, 5), F(2, 5))) + width_power = budget.power(F(11), 1, 9) + pressure_margin = budget.add((coefficient[0] * width_power[0], + coefficient[1] * width_power[1]), + (F(-22, 3), F(-22, 3))) + derivative = budget.add(budget.divide(coefficient, + budget.scale(budget.power(F(11), 8, 9), F(3))), + (F(-2, 9), F(-2, 9))) + require(pressure_margin[0] > 0, "all-stage pressure base") + require(derivative[0] > F(3655, 10**6), "all-stage derivative base") + require(not independent((0, next(i for i in range(80) if adjacency[0] >> i & 1))), + "orthogonal pair must not be independent") + return {"ambient_dimension": 5, "port_dimension": 2, "plane_count": 80, + "planes_nonzero_vector_bitmasks": planes, + "orthogonality_adjacency_bitmasks": adjacency, + "degree": 4, "edges": 160, + "generators_as_column_bitmasks": generators, "generated_maps": 720, + "independent_seed": seed, "independent_set_cover": family, + "cover_multiplicities": counts, + "universal_induced_subset_independence_fraction": "2/5", + "also_valid_with_nonnegative_port_multiplicities": True, + "unit_factor_target_floor": budget.record(floor), + "all_stage_pressure_margin_at_s3": budget.record(pressure_margin), + "all_stage_pressure_derivative_at_s3": budget.record(derivative), + "all_stage_extension_hypotheses": "source coverage law, active children rank at most3, separate per-query support-pairing tariff, all other children rank at most m", + "scope": "nondegenerate rank2 planes, full-orthogonality free mask, scalar outer-product decoding and full support-pairing tariffs"} + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true") + args = parser.parse_args() + result = {"indefinite_bit_pentagon": indefinite_pentagon(), + "binary_five_dimensional_planes": plane_geometry(), + "status": "two concrete repair geometries checked; neither supplies kappa0.1"} + path = HERE / "PLANE_RESULT.json" + canonical = json.loads(json.dumps(result)) + if args.write: + path.write_text(json.dumps(canonical, indent=2, sort_keys=True) + "\n") + else: + require(canonical == json.loads(path.read_text()), "geometry receipt changed") + print("PASS_KAPPA01_GEOMETRY_REPAIRS indefinite_c5=1024 binary_planes=80 cover_sets=30 subset_fraction=2/5 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-bit-repair/verify.py b/research/kappa01-bit-repair/verify.py new file mode 100644 index 0000000000..9435ec6793 --- /dev/null +++ b/research/kappa01-bit-repair/verify.py @@ -0,0 +1,191 @@ +#!/usr/bin/env python3 +"""Exact target-scale window obstruction and optimistic repair budgets. + +No floating point is used for an acceptance decision. This does not construct +a supplier; PROOF.md lists the necessary scope hypotheses. +""" +from __future__ import annotations + +import argparse +from fractions import Fraction as F +import hashlib +import json +from pathlib import Path +import subprocess + + +ROOT = Path(__file__).resolve().parents[2] +HERE = Path(__file__).resolve().parent +SCALE = 10**36 + + +def require(value: bool, message: str) -> None: + if not value: + raise ValueError(message) + + +def floor_root(value: int, degree: int) -> int: + require(value >= 0 and degree > 0, "invalid integer-root input") + lo, hi = 0, 1 << ((value.bit_length() + degree - 1) // degree) + while lo + 1 < hi: + mid = (lo + hi) // 2 + if mid**degree <= value: + lo = mid + else: + hi = mid + if hi**degree <= value: + lo = hi + require(lo**degree <= value < (lo + 1)**degree, "root bracket") + return lo + + +def power(value: F, numerator: int, denominator: int) -> tuple[F, F]: + require(value > 0, "positive power input required") + a = value.numerator**numerator * SCALE**denominator + b = value.denominator**numerator + lower = floor_root(a // b, denominator) + require(lower**denominator * b <= a, "power lower witness") + require((lower + 1)**denominator * b > a, "power upper witness") + return F(lower, SCALE), F(lower + 1, SCALE) + + +def add(left: tuple[F, F], right: tuple[F, F]) -> tuple[F, F]: + return left[0] + right[0], left[1] + right[1] + + +def scale(value: tuple[F, F], coefficient: F) -> tuple[F, F]: + values = coefficient * value[0], coefficient * value[1] + return min(values), max(values) + + +def divide(left: tuple[F, F], right: tuple[F, F]) -> tuple[F, F]: + require(right[0] > 0, "positive denominator interval required") + values = [a / b for a in left for b in right] + return min(values), max(values) + + +def decimal(value: F, places: int = 18) -> str: + # A display only, truncated toward zero. Exact endpoints are also retained. + sign = "-" if value < 0 else "" + scaled = abs(value.numerator) * 10**places // value.denominator + return f"{sign}{scaled // 10**places}.{scaled % 10**places:0{places}d}" + + +def record(interval: tuple[F, F]) -> dict[str, str]: + return { + "lower": str(interval[0]), + "upper": str(interval[1]), + "lower_decimal": decimal(interval[0]), + "upper_decimal": decimal(interval[1]), + } + + +def data_bill(h: int, k: int, stages: int = 3) -> tuple[F, F]: + require(h > k > 0 and stages >= 3 and stages % 2 == 1, "geometry") + climb, width = h - k, k + stages * (h - k) + return scale(power(F(climb, width), 8, 9), F(2 * stages, stages - 1)) + + +def data_pressure(h: int, k: int, stages: int) -> tuple[F, F]: + climb, width = h - k, k + stages * (h - k) + return scale(add(power(F(width, climb), 1, 9), (F(-1), F(-1))), + F(2 * stages * climb, k)) + + +def copy_allowance(h: int, k: int) -> tuple[F, F]: + # C/(v*k), granting every copy rank unit a rank-h child, no helpers, + # and rank-m children for every other paid unit. + climb, width = h - k, k + 3 * (h - k) + remaining = add((F(2), F(2)), scale(data_pressure(h, k, 3), F(-1))) + tariff = scale(power(F(width, h), 1, 9), F(3)) + return divide(remaining, tariff) + + +def build() -> dict: + # Finite integer inequalities used by the analytic all-stage proof. + integer_checks = { + "s5_t2": (2 * 6**9, 11 * 5**9), + "s7_t2_relaxed": (17**9, 7 * 14**9), + "s_ge_9_t2_relaxed": (5**9, 9 * 4**9), + "density_one_quarter_s3": (10**8, 3**17), + "density_one_third_s3_pass": (3**9 * 2**8, 7**8), + } + for name, (lo, hi) in integer_checks.items(): + require(lo < hi, name) + + x = power(F(3), 9, 8) + density = ((x[0] - 3) / (x[0] - 2), (x[1] - 3) / (x[1] - 2)) + width_ratio = (1 / density[1], 1 / density[0]) + require(F(3, 10) < density[0] < density[1] < F(1, 3), "density threshold") + + geometries = [(8, 1), (16, 2), (24, 3), (8, 2), (9, 2), + (3, 1), (9, 3), (8, 3), (5, 2), (8, 4)] + candidates = [] + for h, k in geometries: + bill = data_bill(h, k) + fee = copy_allowance(h, k) + candidates.append({"ambient_h": h, "label_rank_k": k, + "density_k_over_h": str(F(k, h)), + "s3_width_m": k + 3 * (h - k), + "s3_data_only_bill": record(bill), + "s3_copy_rank_C_over_vk_strict_upper_budget": record(fee), + "data_relaxation_passes": bill[1] < 1}) + + # Positive controls outside the obstruction, and negative controls inside. + require(data_bill(3, 1)[1] < 1, "rank density 1/3 must remain open") + require(copy_allowance(3, 1)[1] < F(1, 4), "positive-definite three-line decoder floor") + require(data_bill(8, 4)[1] < 1, "rank density 1/2 must remain open") + require(data_bill(8, 2)[0] > 1, "rank density 1/4 must fail") + require(data_pressure(3, 1, 5)[0] > 4, "s5 endpoint at h/k=3") + require(data_pressure(3, 1, 7)[0] > 6, "s7 endpoint at h/k=3") + require(data_pressure(3, 1, 9)[0] > 8, "s9 endpoint at h/k=3") + require(data_bill(8, 1) == data_bill(24, 3), "direct-sum invariance") + require(copy_allowance(8, 1) == copy_allowance(24, 3), "copy-scale invariance") + require(data_bill(64, 1)[0] > data_bill(8, 1)[1], "literal tensor powers worsen density") + + # Removing the active rank cap makes the otherwise failing h=8,k=1 + # three-stage family pass this *fractional* cost screen. This is not a word. + all_mass_at_m = F(3 * (8 - 1), 1 + 3 * (8 - 1)) + require(all_mass_at_m < 1, "active-child-cap scope control") + return { + "status": "scoped necessary conditions; no supplier or kappa improvement", + "target_kappa": "1/10", "target_primitive_saving": "1/9", + "all_odd_stage_obstruction": "h/k >= 1 + 1/(3^(9/8)-3)", + "stages_at_least_five_obstruction": "h/k >= 3", + "minimum_density_k_over_h_for_any_odd_stage": record(density), + "maximum_width_ratio_h_over_k_for_any_odd_stage": record(width_ratio), + "strict_integer_witnesses": {name: {"left": a, "right": b} + for name, (a, b) in integer_checks.items()}, + "candidate_budgets": candidates, + "positive_definite_h3_k1_label_decoder_copy_floor_C_over_v": "1/4", + "scope_control_without_active_child_rank_cap": str(all_mass_at_m), + "power_scale": str(SCALE), + } + + +def check_sources() -> None: + manifest = json.loads((HERE / "SOURCES.json").read_text()) + for entry in manifest["sources"]: + value = subprocess.run(["git", "show", f"{manifest['base_commit']}:{entry['path']}"], + cwd=ROOT, check=True, stdout=subprocess.PIPE).stdout + require(hashlib.sha256(value).hexdigest() == entry["sha256"], "source digest " + entry["path"]) + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true", help="regenerate this package's RESULT.json") + parser.add_argument("--check-sources", action="store_true", help="check pinned source bytes from Git") + args = parser.parse_args() + if args.check_sources: + check_sources() + result = build() + path = HERE / "RESULT.json" + if args.write: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + else: + require(result == json.loads(path.read_text()), "receipt differs") + print("PASS_KAPPA01_BIT_WINDOW_DENSITY exact_integer_witnesses=5 scope_controls=12 no_new_kappa") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-bit-repair/walsh_charge.py b/research/kappa01-bit-repair/walsh_charge.py new file mode 100644 index 0000000000..0dd87cd935 --- /dev/null +++ b/research/kappa01-bit-repair/walsh_charge.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact character-rank charge gates for binary ports / complex queries.""" +from __future__ import annotations + +import argparse +from fractions import Fraction as F +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def rank2(rows): + pivots = {} + for row in rows: + while row: + p = row.bit_length()-1 + if p not in pivots: + pivots[p] = row + break + row ^= pivots[p] + return len(pivots) + + +def rational_rank(matrix): + rows = [[F(x) for x in row] for row in matrix] + rank = 0 + for col in range(len(rows[0]) if rows else 0): + pivot = next((i for i in range(rank, len(rows)) if rows[i][col]), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + a = rows[rank][col] + rows[rank] = [x/a for x in rows[rank]] + for i in range(rank+1, len(rows)): + if rows[i][col]: + a = rows[i][col] + rows[i] = [x-a*y for x, y in zip(rows[i], rows[rank])] + rank += 1 + return rank + + +def character(a, b): + return -1 if (a & b).bit_count() % 2 else 1 + + +def span(basis): + values = [0] + for x in basis: + values += [x ^ y for y in values] + return values + + +def pairing_rank(left, right): + return rank2([sum(((a & b).bit_count() % 2) << j + for j, b in enumerate(right)) for a in left]) + + +def cancellation_control(): + ports = [span([1, 2, 4]), span([4, 8, 16])] + queries = [([1, 1], [1, 1]), ([-1, 0], [0, 1]), ([0, -1], [1, 0])] + K = [[sum(u[i]*v[j] for u, v in queries) for j in range(2)] for i in range(2)] + require(K == [[1, 0], [0, 1]], "cancellation fitting identity") + require(pairing_rank(ports[0], ports[1]) == 1, "partial nonzero pairing") + index = [(i, x) for i, port in enumerate(ports) for x in port] + lifted = [[K[i][j]*(character(x, y)-1) for j, y in index] for i, x in index] + tariffs, term_ranks, terms = [], [], [] + for u, v in queries: + readers = [x for i, port in enumerate(ports) if u[i] for x in port] + sources = [x for j, port in enumerate(ports) if v[j] for x in port] + r = pairing_rank(readers, sources) + term = [[u[i]*v[j]*(character(x, y)-1) for j, y in index] for i, x in index] + term_rank = rational_rank(term) + require(term_rank <= 2**r-1, "query character-rank upper bound") + tariffs.append(r) + term_ranks.append(term_rank) + terms.append(term) + require(tariffs == [5, 1, 1], "complete asymmetric tariffs") + require(all(lifted[a][b] == sum(t[a][b] for t in terms) + for a in range(16) for b in range(16)), "lifted query identity") + require(rational_rank(lifted) == 14, "two diagonal rank-seven blocks") + require(all(u[0]*v[1] == 1 and u[1]*v[0] == 1 for u, v in queries[:1]), + "deleting low-rank queries destroys fitting") + return dict(port_bases=[[1, 2, 4], [4, 8, 16]], queries=queries, + tariffs=tariffs, lifted_query_ranks=term_ranks, + lifted_fitting_rank=14, total_charge=7, direct_diagonal_charge=6) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--write", action="store_true") + args = parser.parse_args() + manifest = json.loads((HERE / "WALSH-SOURCES.json").read_text()) + for item in manifest["local_files"]: + require(hashlib.sha256((ROOT / item["path"]).read_bytes()).hexdigest() == item["sha256"], + "pinned dependency "+item["path"]) + spec = importlib.util.spec_from_file_location("walsh_exact_budget", HERE / "verify.py") + budget = importlib.util.module_from_spec(spec) + spec.loader.exec_module(budget) + + character_checks = [] + for r in range(9): + q = 2**r + # Every pair of character rows has inner product equal to this sum + # for the xor of its row indices. Thus H*H^T=q*I exactly. + sums = [sum(character(x, y) for y in range(q)) for x in range(q)] + require(sums == [q]+[0]*(q-1), "character orthogonality") + if r <= 4: + require(rational_rank([[character(x, y)-1 for y in range(q)] for x in range(q)]) == q-1, + "small exact H-minus-J rank") + if r: + require(F(r+1, r) <= 2 < F(2**(r+1)-1, 2**r-1), "decreasing capacity-to-cost ratio") + character_checks.append(dict(binary_rank=r, character_order=q, + nonconstant_character_rank=q-1)) + + cases = [(3, 1, 3), (4, 2, 4), (5, 2, 5), (6, 2, 6), + (6, 3, 5), (6, 3, 6), (7, 3, 6), (7, 3, 7), + (8, 3, 6), (8, 3, 7), (8, 3, 8)] + records = [] + for h, k, cap in cases: + m = 3*h-2*k + capacity_ratio = F(2**k-1, 2**cap-1) + moment = budget.add(budget.data_bill(h, k), + budget.scale(budget.power(F(cap, m), 8, 9), F(3, 2)*capacity_ratio)) + fee = budget.copy_allowance(h, k) + mass = cap*capacity_ratio + excludes = (h, k, cap) not in ((6, 3, 6), (7, 3, 7), (8, 3, 7), (8, 3, 8)) + require(moment[0] > 1 if excludes else moment[1] < 1, "strict gate / open control") + records.append(dict(h=h, k=k, query_rank_cap=cap, m=m, + character_mass_floor_C_over_V=str(mass), + mass_floor_C_over_Vk=str(mass/k), + necessary_copy_allowance_C_over_Vk=budget.record(fee), + target_moment_floor=budget.record(moment), + excluded_by_character_moment=excludes)) + for h, k in ((5, 2), (6, 2)): + mass_per_vk = F(h*(2**k-1), k*(2**h-1)) + require(mass_per_vk > budget.copy_allowance(h, k)[1], "small dimension mass exclusion") + require(62**9 < 15**9*5**8, "h5k2 dominates the all-stage query coefficient") + require(F(8*7, 3*255) < budget.copy_allowance(8, 3)[0], "higher dimension remains open") + odd_prime_controls = [] + for p in (3, 5): + mass = F(3*(p-1), p**3-1) + allowance = budget.copy_allowance(3, 1) + require(mass > allowance[1], "conditional rational-bit mass exclusion") + floor = budget.add(budget.data_bill(3, 1), + budget.scale(budget.power(F(3, 7), 8, 9), F(3*(p-1), 2*(p**3-1)))) + require(floor[0] > 1, "conditional rational-bit moment exclusion") + odd_prime_controls.append(dict(reduction_prime=p, + full_good_reduction_mass_floor_C_over_V=str(mass), + target_moment_floor=budget.record(floor), + necessary_good_port_fraction_upper_bound=budget.record(budget.scale(allowance, 1/mass)), + hypothesis="fixed integral pairing and port bases; every counted port Gram determinant is a unit modulo p")) + result = dict(status="NECESSARY_QUERY_CAPACITY_BOUND; NO_WORKING_SUPPLIER", + theorem="sum(2^query_pairing_rank-1)>=V*(2^port_rank-1)", + moment_normalization="displayed target_moment_floor is G for two data banks W=2V", + general_coverage_pressure_translation="P-D>=2*V*m*(G-1); M>=1+(2*V/W)*(G-1), so rejection sign is unchanged", + character_checks=character_checks, + asymmetric_cancellation_control=cancellation_control(), + exact_target_gates=records, + all_stage_h5k2_integer_witness={"left": 62**9, "right": 15**9*5**8}, + conditional_rational_bit_good_reduction_gates=odd_prime_controls, + scope="binary nondegenerate ports, complex scalar fitting queries, full-orthogonality mask, complete support-pairing tariffs, separate query charges") + path = HERE / "WALSH-RESULT.json" + canonical = json.loads(json.dumps(result)) + if args.write: + path.write_text(json.dumps(canonical, indent=2, sort_keys=True)+"\n") + else: + require(canonical == json.loads(path.read_text()), "character receipt changed") + print("PASS_WALSH_QUERY_CAPACITY ranks=0..8 asymmetric_tariffs=5,1,1 target_gates=11 no_new_supplier") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-fieldline-repair/LINE3-COROLLARY.md b/research/kappa01-fieldline-repair/LINE3-COROLLARY.md new file mode 100644 index 0000000000..d207e6451b --- /dev/null +++ b/research/kappa01-fieldline-repair/LINE3-COROLLARY.md @@ -0,0 +1,44 @@ +# Distinct nondegenerate lines in a three-dimensional space + +Let `F` be any field and let `B` be a nondegenerate symmetric bilinear form +on `F^3`. Choose finitely many distinct lines `E_i`, each nondegenerate for +`B`. Permit a scalar decoder's off-diagonal fitting entry only when the two +complete lines are orthogonal. + +Two distinct lines span dimension two. Their common perpendicular space +has dimension one, so they have at most one common orthogonal line among +the chosen ports. Consequently the undirected orthogonality graph is +`C4`-free, including for indefinite symmetric forms and in characteristic +two whenever the stated nondegeneracy hypotheses hold. + +The coefficient field matters. For fitting matrices **over the complex +numbers**, the source-derived rank lemma in [the parent audit](README.md) +therefore gives `rank_C(M)>V/4`. It does not require a positive-definite +label form or a symmetric fitting matrix. + +Suppose the native accounting uses `h=3,k=1`, each scalar query carries one +total, and its tariff is the rank over `F` of the pairing between the +complete source and reader support spans. Zero-tariff terms can be deleted +without changing the fitting conditions. The remaining number of queries +exceeds `V/4`, and each has integer tariff at least one. Keeping the separate +public legs of the three-stage model forces + +``` +M(1/9) > 3*(2/7)^(8/9) + (3/8)*(1/7)^(8/9) + = 1.051658213344872081... > 1. +``` + +This is the already verified parent-package gate; no new numerical +approximation or enumeration is needed. A restriction-of-scalars model +with `h=3k` has the same conclusion if every nonzero support pairing tariff +is at least `k`, as proved there for full finite-field lines. + +This is a conditional obstruction in the stated **complex scalar decoder** +model. The graph fact holds over any label field, but the fitting-rank proof +uses complex absolute values, positive scaling and a Hermitian Gram matrix. +It therefore does **not** imply the same rank lower bound for fitting +coefficients over `F2`, including binary bit decoders on indefinite rational +label geometries. Repeated copies of one geometric line also require a new +argument: the distinct-line hypothesis is essential to the common-neighbor +bound. A different tariff or a query serving several independent totals +changes the stated native model. diff --git a/research/kappa01-fieldline-repair/PLANES6-RESULT.json b/research/kappa01-fieldline-repair/PLANES6-RESULT.json new file mode 100644 index 0000000000..b0af55552f --- /dev/null +++ b/research/kappa01-fieldline-repair/PLANES6-RESULT.json @@ -0,0 +1,4169 @@ +{ + "controls": [ + "reject_K5_for_overlap_cap4", + "do_not_price_every_query_rank2", + "data_only_pass_does_not_admit_query_decoder" + ], + "data_only_moment": { + "lower": "4925782365738143795749247058124475064969/5000000000000000000000000000000000000000", + "lower_decimal": "0.985156473147628759", + "upper": "9851564731476287591498494116248950129941/10000000000000000000000000000000000000000", + "upper_decimal": "0.985156473147628759" + }, + "geometries": [ + { + "adjacency_bitmasks": [ + 10821753624780884505779247490158092964606962392451134708392512397631389854681912475939504128, + 99076261717386406383413061406181208079828500425508029110362384114134700494727622033408, + 6784727238007305699203983841034188501981983651605156455246379301865102311424, + 8275522761932297245340538200972247809960151473528014553009680487480350877778549297131814912, + 22987433569707621763874641687972214407233780810795646976, + 2164383750226559304523755087604972109740002641864749420172411430989444473087721237454520320, + 636573744620237852966340948876729742175847174679306015304433775268059812869467826194219008, + 5830378100022258133898202864472248774933899292361552194016617853707976753757674274816, + 1436714598106726360242165105498281109326488032542130176, + 41718496795330867904988539849044386018079568010561090419654532488365018197688416748629804449792, + 141842889139090975219107671486799185943989926709992060610649780204057524920413563503466000678912, + 166876533476291518294718906353713080786949196535343492773364687186905081916348587603200838205440, + 542340458405344317948308896988158755105903190428535316660516070015226445674296060740075605983232, + 567380213819391162207472622426901694156929679368189511584285119575536892031629210871492876828672, + 667506133998416699641572424810973671136313117146132735719072704505450954958192436037283578183680, + 709214445520616602575587408438458789117972180905957822986778043438442104092749245787551324700672, + 387104996697628722192342566581852108009741131219765661388888235794474382814854791444, + 26523411212781052021984569282802030102428005724291827637567595084741878034, + 8275458904281011629840072240517033905752519205856916995606725573580645991256442437604737024, + 5612440318907673397961884641408529361887393635895558, + 2164350853860747591259704063444938189353279582373875557996608520986992100909317619309346816, + 636573743612381255514724799396705323186916332147199862093795661490662561178661914457145344, + 24188504278950228978183384534923037425738461457895504908070904311871511195516168448, + 350777519931729587372617790088034166047843368829078, + 162962878107292456859282290490060929004080464921914352119511349143759476540268440076454723584, + 554073785699574121949763033980727027064715371509009284620995518700556570541321634115020128256, + 654397807397453655213738177409772395785279996025112647080851542402982595023188923697684570256, + 2118517415645876241985581628859995137132434339259847962799752495113351126334072783564336791552, + 2224952545151342427748263957006170227116625095539510020272252657542767221445796532359834650756, + 2617591229955576819664359310650900187260820110181111657309511240859193956733017002605149169794, + 2770368927815879288895190741111876164372805358979747234604388179704104191058556528740318314496, + 70814378201885931965481820303748566295877228724674490333937879810852854022516700407211867396007526400, + 74402836422312632617891356954639195246603204110147292312814163610918119658140654029653323517918183424, + 13415791625398741489208678292183587066347377492498948407022947632695942058219573431112826880, + 9332127359978242008904506627695799588933106113241364389981791441686628159212196777349203914047619072, + 19550771069741532477354502275431853494254152730046421597716741156531665494724556714114285568, + 21006933509996089699312550392505565218440343596371427286445194720277537612265812165713199104, + 13399046676331868947575397759241771351001500692411607010031120544387262535773650133685263575208165376, + 21643507252585332046427273602589108996079137844083059066206488060470536608440524033931345920, + 13174768037560173388931794341996005648947192345159770914435958031481866196586476755887287761949949952, + 9586309817252830308701640348827022382618570260475668060754896432138687550297919836876807124696432640, + 19168826824194100891016379110575875776606799015044084643020171031678064025558431870111186944, + 74657018879587220917712112260922988224621557940799059106760835462045392148891749337621863413428781056, + 13033847379827688317726234686048161923798722546648704165700965182486760566509588760714280960, + 11458327367393748438046540884577096898823832561977592645222433997177888655595103282853314560, + 70590099563114236406814595301358480152540902479360740222551783452872697610870898007608739893774123008, + 404716375831497392161601423241118666437880396242818441088283351453969, + 64358495605337532471030056769798608513765987054400086767686765705209960387095929290752, + 334527515520229095185004914962654175093196037, + 33154376523961759030341202638717995314402877841824962954536914108994024214085289115648, + 5828303104425634877038149452633232406812385395361798086646949955763074326857181560832, + 23121364378907383837008655829199146941335430565307265926132826428119638493198570752, + 20907969720014318449062807185165889969979477, + 1491969887086008995145582672181425456845530377899678196157878253630903724794412756107264, + 8454631612872857538218692919047205344547109980687301907904080400512495669384457874833408, + 8986786295436222682073438214660991204216788966639839114028538798815900590125179331432528, + 16411924812235207921039466126734199965243549047796742098252055265915815090223686562742272, + 16975040780268420622023148428704812300298948960093721994969568605893641323017995494114372, + 23965128149555508814357469908195041075497292374386256526382358512883071897236912274936897, + 25363485323684092352704497792433072592251082458188148801209499100133690549046542172422144, + 87500715184274600824853321209900870753802635966140783749240133002319251253421718078803734818231943168, + 3128887463630008943893454516588175043639449832333101353209302155869574923648311183881187360768, + 2744744905601999280766854107664632017543838015162378046318319968259479685412472937568992639421906944, + 4693331186702996453526970002451762524369705796197817398874999966525952202640696860101025202176, + 378825191881191853423121438760038264078662981442042927254736797568382961101512025309184, + 19960798850680904721048617768601973196713437607558073683928492634719607113258284692924607202708160512, + 396309196858023890953257462242289432389389889149978490445320581150393422942395592998912, + 19762152056340260083389817650925870972030320181777309065598639283799442981587227010697096322070085632, + 3075822896169740343534145511050446270984026485211747261065442604516623910146115034506039509161607168, + 4693331180875004829593460355120110486640321494361821497021830223973306288301475723873873821696, + 87831793174842341887640297538784613558510795186706108898483609129025069438000632437570084631095672832, + 3128887457801997635575102142526910350457318561270646573429741474920420444786269176387476652032, + 116560286379143941842100355001243974456299446978660564147600052172012560889278056628224, + 70615731407545287327803335801229737341579313785294464889073666628885683942980030113639869511676985344, + 104996044740969275782689088233043961410656816935347904202631721354989970678520692761606656913525735704, + 800995138471138081464970240698415071007582960127384814883019097596219943564664759750241877491712, + 1647246502264256844168986956862091762230976247090792085638420793058683773903206060490588634073825572, + 1201492707706672969610667350577712085525421785724874599956305626465970507282783265424463236169728, + 1485473728548128712407467789292390010607370423127518789419163890719879931340661997864, + 36365179286553494154731675376608745114389329573085435750701484063893599015122403624065560427163025408, + 1553755686262570419082571266578078884888214535388369800266753737862029654905860424212, + 36230612103290476819542749785318671781128606540008067902890449219069375311629562335949946869430353920, + 2050948052053308849739669904492676830952532492219826130402779396852076110055631086639793316791599640, + 1201492707706650218838417734461654364859318660452347640581818106883177501693017374919751211417600, + 105399746290758327788277556574193689033848228405605409190763373177753394153268345314961599128217338404, + 800995138471115313045734837106281903604981029391697258767901986306839486814912960065796292214784, + 455404739805589571421917827418207626856718244981381820776925432144605957647845327400, + 70679811018622914630275247726671016887167841808588871679636627301057132236451244912580292859433844736, + 4086717503471947062752589156075639439717031433646685543156909140079148007424, + 2346685337666784410339784749580514756006355101404042363496614633938268224076361955811860152320, + 600746371756392471426104491395749203906957066052887728618330693943869002657183596468103498694656, + 552835267689368847924566015099592362755762102014762918514732699111145802846743440196351826067456, + 13795827167766116832340307920798186611305139928114921472, + 782233750670116492121341685130285083919339296810527346521906223611247748092472070522282180608, + 200248794564050048449666464108631028940657573901596886559177086957113870316297350455326295457792, + 150773254824373322176229906029694011467581430729380971038063309361190448136631325396978517409792, + 862239197985382302021269245049922083116920599050452992, + 83436993590661735847971358979082849769170000901597647400333317275984464363338982713350844055552, + 325925756215652053761390840478288731184390356798651689519642766185810293745831567118731051008, + 5967881682623824804735560606772095606115416119804453641899553628512700861526786311192576, + 670103378646511003099985416176829936494968401133204723179143011780249592826145299116174373552128, + 750932942315946877622491942446505217217779942969347999911189694182002595809899130364773525356544, + 2933331805922638208362964814921489528611505129412250312675428360958129569055485431767606755328, + 29839394451390335319925370935624978245574199988463179219513983456513692393496075472732160, + 1188426064712798348300886541059, + 2270398479297460541593412170539217992631414507679342178427296892628647280640, + 1357007698017936920183009419590724533055857564036525801701055152114695667712, + 5383444294084141228804733948637673115849074033631178482757493176271909632, + 74276629044549896770818736179, + 347376309284186366300256049510484294247625560839869556758871520025703866171392, + 578971047269601537243224210538534260363167834237940510135161368944698197540864, + 697466412515399248770130102376273455665477313333143079079296101199725503459376, + 1042146471876099179969031050522526831869219033630498983941381957069246114627584, + 1162444021184093662500279127025253901392708830000836384430199728969585579270690, + 1394954130721766084213743521117883989097433563092285759896136369062589666169377, + 1736881400676411565478909849436997489222092629974095517112194867058911767166976, + 181559289169158083531755076271308843219045382330105276172740711215359617107512618217883749817843712, + 4302219982997357685303698616652537752953926565365792937716931821253543944654696226492648521728, + 64652999656356938711242487701827056717063665286190148167712273583618681622467648657031168, + 22011346405164978437023450483609472117103570834944986767369882994230318423282424133937779459313631232, + 108556187956249617765851311172849440408441569099911718999629199606261387689984, + 18736878279103196475133228273189327840299634078657866632472408313358079299920903618376840457700245504, + 5639006165942110073744185867829193548433241069605620210337843634742614761585913386539198761250062336, + 4302284634039167954309364781103055417926919136122666807081408071544079690093770684193010876416, + 92958162061132099017366225172989593305486594662187823525483262769024137901348109899050668913793761280, + 2346665445010515825058648956666189799193661538800896864289967918166577512635320370976757121024, + 19893202644231573734789615692686243993633874825756335914209469560280101619739094426058752, + 71128368296166306957922280457417093604955360331657556786529538820505649656718469375584688340425768960, + 109035463226771536388768435513255364150378154209710252154072388859108451510982683580088418993996098, + 1101368315647323548332343647158040148794861904192524368600723382767995004368398211150074494320640, + 64405301783959941748505850966062319125969506780483347920041972013809855887301181102367048, + 39441000618279614384768536933521649667146191375207222955729807940219144372251079124685679482449690624, + 425368430911473319727108553434143113922535354388518261312378367489513391122, + 37255885880535000273316017532675620153087241642714192852002876078100913505808681260804484949981790208, + 6664379676465548249732579989891479310183628236553762645791643357753740216734031358693693686768739352, + 1101368379551416758097674932347702334791463214054337086555538738820345508787616372992280203624448, + 111551388954290431370407731828674525070706176101386737516513585185227344150250973116910584837592589378, + 600746353922692040793885117649119272756420407493151115529457917918907815285022503233371280244736, + 17973572590872551395675987305489805627586143056569477349356162907240030385795860170572872, + 72217721684486280712798440003134229440426036470684291967593145036490438179445744446731438697740238848, + 7664348426425282305998023875251108316708780950364880896, + 1173332722861923927622528034216515059144963622504788801994751194912311625104061441585459494912, + 300373177052651460647314102675860438546924927519759556106792072694674788351801877528395376492544, + 50257751625676757703688964450360847483535262704869287842599539646100573209438837524383836143616, + 479021776651580144124876493944047450039364833054294016, + 283685778348118030558341589526698798059647027897200752989854879787047437607936367060746799939584, + 1108147571672336056869017681427823937392373586766094676854922562684308064692902638168626429952, + 5558020948546981629405018418873149029919467676309829657323495692784730525138944, + 569587851558743662887543505141437441972616887116914864205344178739400941295823806417837993492480, + 851057334625466111788851560008154420298566200672225309046003847400185548237970658460260821368832, + 3324442899874094946460323007779758988727061125037436934359590276103700259870330996938856464384, + 78010304650964849358798488725270685055027964222010200658612130294524513876871793868800, + 32064934796561959019001674313889066384793703946604378351156518540192865788369982477613139878773121, + 1076353640922080293000936950416333855272429699681742725208989695872342185509053917175678002003968, + 4220865857713576076128616521649317438551206933993610186920097023339687439355826871081317175688, + 52513241278497518621244324787353779281846324434160073791613604987528462466118105589444644768023838720, + 6490686452867372446182240224777460567005601375311168042992760995219473, + 43766374463797174452329326900299522822576982924633676364141025356495682092127050833210048348355821568, + 26272665572925271211623795052546110211309205598129934460673877997806367981165602491203239728843331608, + 1080541659574675475488924482569370135378157460868184180522704951044940768280644903952582159892480, + 131236651759476607160467019945223412139798366564713039740871093627660192425668819343953716447260186753, + 550692560471762010372572393386698777610436352309351118267369545506142439642171002137050639237120, + 2159512764411597062205337603337729040828992606511543052015918444563217259855885603122425399432, + 78753842038848386453918283341692748364667400941702565253214166478371269297148241353474177274891730944, + 4597487536147693648832754423116280623179649889375092736, + 32823826866461727805999221015252361617283586788864172353004087949836411984549559263035392, + 275346280235881007270602107704980375922616027462509744412598766497142749001713178720950520119296, + 75094443048338898644585671578166048017803727254371062932113395789903191292019682026383835398144, + 287342971009230853052047154346189509266429869087522816, + 333753066952583036589437812707426065157872909439222010003047094014547673760393567897771429068800, + 33818526451491430152874771566917034368577103841078260552469582419636635937503457896300544, + 9263536756313624467336543827897326122453717960513668578329399156916827251539968, + 542340475248283614698777705749329023451159863238987891938263885303172800666996485949491215597568, + 876088432702664276817044983068209500350260560905143995229221733294949238846795370229231444295680, + 12272942828120714825784409186208243137134100205562389034889704643461264481902057985006370816, + 9166662197057623086509532334406871172908166767907127953805662997704688972947608772154490880, + 1123529450665701428410013737614204196256073325219584, + 32452283852186690265293076171263263504414250684027803435642855131632259885283440689416544, + 1079756382205802367167936827394735805654546538399034808217430179566569784127860862541497370016, + 294483506722001862957523216546071213206233963546350636831299724601621183465925592749388596160, + 70220590666606339275629340360374875330311245267184, + 1308795614794907310427476354819544791570622787477637967735575218654869490131206516563985303184, + 35947145181744890728293752858643964816867159065322495870350412059293192093500070839716432, + 11159462600246387980322081638020375290647637013330065696199064646593071292615728, + 2118533827054668094807177779448895439349797187885718322491453520559819379379999176424010285056, + 3422220626738150311167504662818017777560091082991448138555053368932395320459181113387343937536, + 12274434797829962207550932610742632685434401255636923919180948181282091218125679044983783424, + 9166739600273034586740760580540334872911239594134923523439602422268592977414315153498832896, + 11075092781249918815160939377809757050936638479858668409217875633971312690195522389836877760982679552, + 9913115833708953405739764556297130195802629713238997341326492698820156075421489463357208329480830976, + 3300099970879750322863032396562117600399072841664959599191898768727042175686211933749700856318525440, + 224278639153649555501406350252262052315316865285985722050506251750315689052519797629103926658727936, + 16551173740011538380218678577898864728356776553045077583254127157520283801267125289467510784, + 16550918309406347259248650739534266191938991612649098501044900858748224285765046611006717952, + 257433982421350132795794467131463531879101577243360664447840187803480051103832547000320, + 65387480055551153004041426497210231035472502938346390939823546472064205455360, + 71171088036884725159570181130945013145832807759963527801341049152899405663759869105862177272081940480, + 72333064984426009857247832688928133799786628967208616077298394234788142633513297389271842510017134592, + 78946080872081268361333897050086602550717584674333753067722055446917419045250883742424001328344727552, + 82021902203807690921173480309864165900225175118837466526556155497917523934641313265281526661120000000, + 4642331819176946101700198415, + 18831305206708239209977651942389028516180062143409077354496, + 31385510921799918792112939947287693260772280304544250200064, + 37671805385565279916172863937446616336601558948581436558348, + 56493919359924541449105499136470365885215907636348941828096, + 62786342309275734217551628130851096913133974262938119178762, + 75343615262233747497861259450353561338524641918644734133769, + 94156526031622306177548098128181782841407396773013772828672, + 367798944422830570437938516827309257940232246539801788416, + 37328509439758797832303434134476548604296100098102204449046011290970066834772514342869396795810643968, + 43915893849644818750270848824601301557051149140179533362223615739100123786976830989909739561678929920, + 1173365545702267031644344452246680540775428599342575344778730026569737020273592034829598195712, + 46479079466122419683797798332328507954340869643566185427302590895956203846538533182435983413303377920, + 782221815064221306610108430082615474150082343169307638634491992997984856862018733846707568640, + 11935909449010635096297518141420409825821274360759557810991041062579993179203411205160960, + 35585544018442362579785090565472506572916403879981772675389862346689009060756559816478505799293861888, + 89812198617258858857855134511980772808105962621669382, + 18664254719879398916151717067238274302148050049051106631863880721496954853070736724697302289977704448, + 26349636199512655569093004653291912746897547202589637748624842473995876346267095825758875720521619492, + 300373209252388346981977924986883763435537985615526985475466540554920173355058807646035571113984, + 27887847238592578478814013452017683336078689799706968321433852290585304669134861456695757547151300674, + 200248784656438705595533667282616491421299502645502340096491008870849445592132982621065290186752, + 9985318108365135466244023437311773385968540741443351804079183255067477390611508206014560, + 18083266246106580171067662580031722059480134875579877160350174850603893887005682273046413461728264192, + 1176956575419264950623603246401925562031621680892525674496, + 1084680916942790120631291169600498214248071048935357662020751313929904348303423279361292549226496, + 4237034831807773908715981131251946149406527541477554536891428001009514589864833578068313374720, + 301300883307331827359642384347510948969105804250860599902208, + 167525838693748135734716973419016206753690437633041144355721315348765065428163175287768901222400, + 1251554903861001002655443227387355484121027840000115374692816939267379581657660506145383774158848, + 4888886622947087147254551877629664332501975045817648717789651544671449434960276236247876239360, + 46806178638410528845795397511459931257846166332619308925149038395498849485379526983680, + 5353224450352613429934597401303002669260120069, + 5489486780094465775812506451330976555966370265504343234421934150971517880331259758493611315426361344, + 6587409049878163892275227318158438477575189853903280364771097165731279689024850921903155139080889380, + 276417633844684423970456440656063784850692389385332971632319497066961186172448772678537000779776, + 8202592286060267640926104931232612674726435543629620025427854084803076865424225699723914219976926337, + 150188880128662370286417763795046553504208849271861360823450569745354654240427911229053460283392, + 588958026657710382091601905851674075811570839125711763386797738397390313453783590764451766432, + 4934130059088410219335973838766654483482653828651834571198170042269550769717698467943306370085814272, + 1961594432612494924507058746706931539781805074043663417344, + 1134760427638782324490933803415792141560577817648330462695917517486844154025481992437511365984256, + 65647699248940831687393058106994876636334238001627282357454196657192421367184293961531392, + 502168174748798700673807013195095588122481741340070784663552, + 141842898055941190535204245042085777522426859741125613831589730905250117344685154593948578086912, + 1276586001938199167683277564966026621152787700520946982812483083407443612714558208630364775120896, + 18407922272471901573409634411838565499233920625874062241392981378972150516938060152315052032, + 3055554146626967628213745984975836007865465454387717928367590169793092617110797662940037120, + 2354487836597829994760803996091283947627719967292128231628, + 4449905090302684855794062199022481659109562516301782607799340234747215163709741836453581689476, + 67900163121073682491974826034888941331627846012905714298299830343455045367879570739438148, + 602748886169044478658765822999131934560182982649210369749004, + 554082240057999181838430802065023335336922624754012315241169079047847588432523080013214384128, + 4986664349811142419691055792939515404954554681514139115080030555770610508393022405427312197632, + 18409414242181072362355917002063330194867288133068272244389138294376487885612987440871505920, + 3055600588555142663514056231553887796437260681771609737892067228483960318159334108718694400, + 4328833551195454283131932567688388712491195161248234113802309953496078710521502956708167680, + 4328701965732207431249050316420544667061411770897257110242489835390699867417834574760116224, + 132617506095847036114175601143935632059438834400849880422226335068913375641537186103296, + 220733234684257869317444926732673699093789353281880850432, + 35628263759160780781432990879903986143404384650054619658117480451465273586531292373936758699329585152, + 18198609546046309315516962995138720469002874112941281345107928989766298988228293092253800109168394240, + 5126368892321292126751510353612265946326666629421833242741256014757017794891073080585194164742782976, + 57415331531665326964377048599508906125033223807963421355473548545124988113260237280117473133962723328, + 19014991131348771223769798787075, + 363117893886768270130038366712535647164826338765323438328940992925921291256792902357813075275481088, + 435766386430935514026632618431470822918331166594449517670208303459191648589696055232520215123214914, + 75386627423888205736138552987270713313575031977017841208145407409131381330568764811741478518784, + 512737405652011650907110604366075646167661629810615011995093563568771013793995228914461624001118849, + 50062964518842114478656991829021939412640018671861462608147517727337448734320394368939085266944, + 196322337814667908638348811030714142137489309030900424554199810854958599482783171961971327168, + 320398056915932997184543680485018110907988269624872925528916101019850863062164900946659994377388032, + 3530869959995283840569093696029397903243742980735543607296, + 1335012268183329612936814840430215685327684049329936527987150803051075900949087956082831915024384, + 41718496795331461452524093240401866797215660802069050790473138636259881694194127746899527073792, + 1376710394245902930104629379308841539602794986049042262298665101380682794246340969283002442973184, + 16674343550017586879504496808360429309907504538087983479667396212412930455568384, + 903902709758792663185687986183525853596770181838192452632576, + 16805799351732868369879493947976956597460714432337582526134852145132494151413916053895380992, + 4583459162899480655830148373509746067905268326002508841954162896808872828500175190841360384, + 3924146394329733388596976758178193557073035251196165619882, + 5235182460642678036947531823391498875141006669002990465103164008596015883533289869829793125506, + 162962878108893745650744063877754666624909835000576118703105552034524791147285879429789646848, + 5377774977526956173733503524060741650966308252044553721376444755702665128045489821426911281152, + 18599104338945498600004466032404062422283341280013382150867118344831362580628514, + 1004581476948411747480826050093617550610108998450809376100362, + 16805547791290162739816893092881508927615528447340632397522784095751546273530895995192213504, + 4583331447596933754314107249415922818986825676553473876299506623825708512529679283812040704, + 1273147486216944333667266434656609879234922472459898438484125470713292846289684249626804224, + 1273147487224762634708744071573892817685387404566348122238534493630931270186103657398796288, + 36140900647781798596080190528288123572495800417445536764413674255815524810094975168090902429121380352, + 19736520211909209162397171216691471285217854671234276530682302557350720464280500745770945781199536128, + 36326375660301475240863595671950946283757850526812554091334656473930078879744, + 122629574822804081228200483512137579231617321759177441280, + 3588458221874905920674501031066184356207604712074242261766691015108776647803352015730640202927964160, + 52801599529492674219055832018631966606330433211152180751584435396243102978538166211845110482121785344, + 4708975953889609218616328715647097583657790119923349192809, + 1491972555283121953028563352309365774094538800114746726809245741216126830025186715107328, + 95860517933921507312960164750931153502327963376225919498246624989737758673573461291444289, + 96978035368527003225158012303602433188853735114488136307694588680855367014477555071713280, + 22319266091548257347419896337886143825558937009476572158338181904941543807010849, + 253533490115636552391488382574245295973928569848026198348016750336845674196165254447104, + 1205497844195739959965780151205656981416394270698186893189129, + 128716991240644324369551865845631916927709498384682126808220114194984825204138934534144, + 23312323156168282129954081771235992315999787491559967869835063702083840629020651683840, + 36166532492212849517068930669073899377591191788726372871699204986201798114145747243775671035645394944, + 23314398128696331243516487501378351999551186904627584013949193998516780133931406065664, + 13200399881991224309912676119038754618793879841840889629753857988861268913731557081789849311201198080, + 21711571028520009313761592515465031476285460316944496625567952442145151909888, + 10124578550265133217241325144700028140031888598473243223417763114098748044968051076791732309826994176, + 73559793270854911535400648311985678540903268797242146816, + 39652463334835794196270120589260959757534245924745454483842369138029906039494974609742732943299706880, + 91418317706109565617214921533764875761482569017678417441279030415774007872658118144, + 19826231667417887385857731371326268291437076992455191953836158440920245235546533565511820658912264192, + 92485457515630486949902140399535590153391538981947871180419229876708859749251197440, + 13264479493068851612384511451659793330072782489631936339990948198130987137289158939306861007785164800, + 85141242066438418203250253833838891739889970032978406072134342983341362176, + 11213931938584778008459367560123334874273653053949863670788216490326539629316153420205335401971318784, + 17963317695131234154910488536276093663861968094687232, + 22150185562499837630321878755619514101873276959717332422512595716163662598195193632246127493969346560, + 5884782876976394136096756133011361445297917472991139069952, + 1418428891041233205151174816876917578235944361811909936982444980670439036483709989329732445929472, + 5540737855633715000930590691920517161318288208760478865768616416886612536798199864388692738048, + 5967879020332109099183918609747681769176355154077912271898293212133204979576077320978432, + 101453944496156052644136162240622883889207606159960110144137298938395928553646459315027968, + 325925756214060607117295849101520462648626207637210715882088361590932030494045571741137240064, + 83436993590661154065092997238525927685894568853023705193972304049707770107035478164218809679872, + 1340206805036050922972997794093593989034407718463935296676702433605977248182635751122346486792192, + 27790102410822585047662557590991959827553482079585527793897836531648546337718272, + 1108181389106036296421825253817440089867891869792604303746540432675407085373758522987923898368, + 283685814015518891822727193573099848379853747684820007088560348869978094000843704371016351350784, + 1139175703117487345228157588047214907671332009608046510809044884766664890954471116057753398804480, + 335051677387496271469433946831688994492283760937671617053886571139594386423799361851458049802240, + 1084680984314547321473939571282599542685961323317899752826624559807516814727901600999830359900160, + 4237100477442953825335981715942109370459333998366456235333003879850955434418917231032153407488, + 1506504416505956898840769570050908525179159065573375912968192 + ], + "adjacent_overlap_counts": { + "3": 3360 + }, + "closed_row_overlap_counts": { + "0": 15120, + "1": 30240, + "3": 3360, + "4": 7560 + }, + "degree": 20, + "edges": 3360, + "form": "standard_dot", + "matrix_rows": [ + 1, + 2, + 4, + 8, + 16, + 32 + ], + "overlap_four_witness": [ + 1, + 0 + ], + "planes": [ + [ + 1, + 2, + 3 + ], + [ + 1, + 4, + 5 + ], + [ + 1, + 8, + 9 + ], + [ + 1, + 14, + 15 + ], + [ + 1, + 16, + 17 + ], + [ + 1, + 22, + 23 + ], + [ + 1, + 26, + 27 + ], + [ + 1, + 28, + 29 + ], + [ + 1, + 32, + 33 + ], + [ + 1, + 38, + 39 + ], + [ + 1, + 42, + 43 + ], + [ + 1, + 44, + 45 + ], + [ + 1, + 50, + 51 + ], + [ + 1, + 52, + 53 + ], + [ + 1, + 56, + 57 + ], + [ + 1, + 62, + 63 + ], + [ + 2, + 4, + 6 + ], + [ + 2, + 8, + 10 + ], + [ + 2, + 13, + 15 + ], + [ + 2, + 16, + 18 + ], + [ + 2, + 21, + 23 + ], + [ + 2, + 25, + 27 + ], + [ + 2, + 28, + 30 + ], + [ + 2, + 32, + 34 + ], + [ + 2, + 37, + 39 + ], + [ + 2, + 41, + 43 + ], + [ + 2, + 44, + 46 + ], + [ + 2, + 49, + 51 + ], + [ + 2, + 52, + 54 + ], + [ + 2, + 56, + 58 + ], + [ + 2, + 61, + 63 + ], + [ + 3, + 5, + 6 + ], + [ + 3, + 9, + 10 + ], + [ + 3, + 13, + 14 + ], + [ + 3, + 17, + 18 + ], + [ + 3, + 21, + 22 + ], + [ + 3, + 25, + 26 + ], + [ + 3, + 29, + 30 + ], + [ + 3, + 33, + 34 + ], + [ + 3, + 37, + 38 + ], + [ + 3, + 41, + 42 + ], + [ + 3, + 45, + 46 + ], + [ + 3, + 49, + 50 + ], + [ + 3, + 53, + 54 + ], + [ + 3, + 57, + 58 + ], + [ + 3, + 61, + 62 + ], + [ + 4, + 8, + 12 + ], + [ + 4, + 11, + 15 + ], + [ + 4, + 16, + 20 + ], + [ + 4, + 19, + 23 + ], + [ + 4, + 25, + 29 + ], + [ + 4, + 26, + 30 + ], + [ + 4, + 32, + 36 + ], + [ + 4, + 35, + 39 + ], + [ + 4, + 41, + 45 + ], + [ + 4, + 42, + 46 + ], + [ + 4, + 49, + 53 + ], + [ + 4, + 50, + 54 + ], + [ + 4, + 56, + 60 + ], + [ + 4, + 59, + 63 + ], + [ + 5, + 9, + 12 + ], + [ + 5, + 11, + 14 + ], + [ + 5, + 17, + 20 + ], + [ + 5, + 19, + 22 + ], + [ + 5, + 25, + 28 + ], + [ + 5, + 27, + 30 + ], + [ + 5, + 33, + 36 + ], + [ + 5, + 35, + 38 + ], + [ + 5, + 41, + 44 + ], + [ + 5, + 43, + 46 + ], + [ + 5, + 49, + 52 + ], + [ + 5, + 51, + 54 + ], + [ + 5, + 57, + 60 + ], + [ + 5, + 59, + 62 + ], + [ + 6, + 10, + 12 + ], + [ + 6, + 11, + 13 + ], + [ + 6, + 18, + 20 + ], + [ + 6, + 19, + 21 + ], + [ + 6, + 26, + 28 + ], + [ + 6, + 27, + 29 + ], + [ + 6, + 34, + 36 + ], + [ + 6, + 35, + 37 + ], + [ + 6, + 42, + 44 + ], + [ + 6, + 43, + 45 + ], + [ + 6, + 50, + 52 + ], + [ + 6, + 51, + 53 + ], + [ + 6, + 58, + 60 + ], + [ + 6, + 59, + 61 + ], + [ + 7, + 8, + 15 + ], + [ + 7, + 9, + 14 + ], + [ + 7, + 10, + 13 + ], + [ + 7, + 11, + 12 + ], + [ + 7, + 16, + 23 + ], + [ + 7, + 17, + 22 + ], + [ + 7, + 18, + 21 + ], + [ + 7, + 19, + 20 + ], + [ + 7, + 32, + 39 + ], + [ + 7, + 33, + 38 + ], + [ + 7, + 34, + 37 + ], + [ + 7, + 35, + 36 + ], + [ + 7, + 56, + 63 + ], + [ + 7, + 57, + 62 + ], + [ + 7, + 58, + 61 + ], + [ + 7, + 59, + 60 + ], + [ + 8, + 16, + 24 + ], + [ + 8, + 19, + 27 + ], + [ + 8, + 21, + 29 + ], + [ + 8, + 22, + 30 + ], + [ + 8, + 32, + 40 + ], + [ + 8, + 35, + 43 + ], + [ + 8, + 37, + 45 + ], + [ + 8, + 38, + 46 + ], + [ + 8, + 49, + 57 + ], + [ + 8, + 50, + 58 + ], + [ + 8, + 52, + 60 + ], + [ + 8, + 55, + 63 + ], + [ + 9, + 17, + 24 + ], + [ + 9, + 19, + 26 + ], + [ + 9, + 21, + 28 + ], + [ + 9, + 23, + 30 + ], + [ + 9, + 33, + 40 + ], + [ + 9, + 35, + 42 + ], + [ + 9, + 37, + 44 + ], + [ + 9, + 39, + 46 + ], + [ + 9, + 49, + 56 + ], + [ + 9, + 51, + 58 + ], + [ + 9, + 53, + 60 + ], + [ + 9, + 55, + 62 + ], + [ + 10, + 18, + 24 + ], + [ + 10, + 19, + 25 + ], + [ + 10, + 22, + 28 + ], + [ + 10, + 23, + 29 + ], + [ + 10, + 34, + 40 + ], + [ + 10, + 35, + 41 + ], + [ + 10, + 38, + 44 + ], + [ + 10, + 39, + 45 + ], + [ + 10, + 50, + 56 + ], + [ + 10, + 51, + 57 + ], + [ + 10, + 54, + 60 + ], + [ + 10, + 55, + 61 + ], + [ + 11, + 16, + 27 + ], + [ + 11, + 17, + 26 + ], + [ + 11, + 18, + 25 + ], + [ + 11, + 19, + 24 + ], + [ + 11, + 32, + 43 + ], + [ + 11, + 33, + 42 + ], + [ + 11, + 34, + 41 + ], + [ + 11, + 35, + 40 + ], + [ + 11, + 52, + 63 + ], + [ + 11, + 53, + 62 + ], + [ + 11, + 54, + 61 + ], + [ + 11, + 55, + 60 + ], + [ + 12, + 20, + 24 + ], + [ + 12, + 21, + 25 + ], + [ + 12, + 22, + 26 + ], + [ + 12, + 23, + 27 + ], + [ + 12, + 36, + 40 + ], + [ + 12, + 37, + 41 + ], + [ + 12, + 38, + 42 + ], + [ + 12, + 39, + 43 + ], + [ + 12, + 52, + 56 + ], + [ + 12, + 53, + 57 + ], + [ + 12, + 54, + 58 + ], + [ + 12, + 55, + 59 + ], + [ + 13, + 16, + 29 + ], + [ + 13, + 17, + 28 + ], + [ + 13, + 20, + 25 + ], + [ + 13, + 21, + 24 + ], + [ + 13, + 32, + 45 + ], + [ + 13, + 33, + 44 + ], + [ + 13, + 36, + 41 + ], + [ + 13, + 37, + 40 + ], + [ + 13, + 50, + 63 + ], + [ + 13, + 51, + 62 + ], + [ + 13, + 54, + 59 + ], + [ + 13, + 55, + 58 + ], + [ + 14, + 16, + 30 + ], + [ + 14, + 18, + 28 + ], + [ + 14, + 20, + 26 + ], + [ + 14, + 22, + 24 + ], + [ + 14, + 32, + 46 + ], + [ + 14, + 34, + 44 + ], + [ + 14, + 36, + 42 + ], + [ + 14, + 38, + 40 + ], + [ + 14, + 49, + 63 + ], + [ + 14, + 51, + 61 + ], + [ + 14, + 53, + 59 + ], + [ + 14, + 55, + 57 + ], + [ + 15, + 17, + 30 + ], + [ + 15, + 18, + 29 + ], + [ + 15, + 20, + 27 + ], + [ + 15, + 23, + 24 + ], + [ + 15, + 33, + 46 + ], + [ + 15, + 34, + 45 + ], + [ + 15, + 36, + 43 + ], + [ + 15, + 39, + 40 + ], + [ + 15, + 49, + 62 + ], + [ + 15, + 50, + 61 + ], + [ + 15, + 52, + 59 + ], + [ + 15, + 55, + 56 + ], + [ + 16, + 32, + 48 + ], + [ + 16, + 35, + 51 + ], + [ + 16, + 37, + 53 + ], + [ + 16, + 38, + 54 + ], + [ + 16, + 41, + 57 + ], + [ + 16, + 42, + 58 + ], + [ + 16, + 44, + 60 + ], + [ + 16, + 47, + 63 + ], + [ + 17, + 33, + 48 + ], + [ + 17, + 35, + 50 + ], + [ + 17, + 37, + 52 + ], + [ + 17, + 39, + 54 + ], + [ + 17, + 41, + 56 + ], + [ + 17, + 43, + 58 + ], + [ + 17, + 45, + 60 + ], + [ + 17, + 47, + 62 + ], + [ + 18, + 34, + 48 + ], + [ + 18, + 35, + 49 + ], + [ + 18, + 38, + 52 + ], + [ + 18, + 39, + 53 + ], + [ + 18, + 42, + 56 + ], + [ + 18, + 43, + 57 + ], + [ + 18, + 46, + 60 + ], + [ + 18, + 47, + 61 + ], + [ + 19, + 32, + 51 + ], + [ + 19, + 33, + 50 + ], + [ + 19, + 34, + 49 + ], + [ + 19, + 35, + 48 + ], + [ + 19, + 44, + 63 + ], + [ + 19, + 45, + 62 + ], + [ + 19, + 46, + 61 + ], + [ + 19, + 47, + 60 + ], + [ + 20, + 36, + 48 + ], + [ + 20, + 37, + 49 + ], + [ + 20, + 38, + 50 + ], + [ + 20, + 39, + 51 + ], + [ + 20, + 44, + 56 + ], + [ + 20, + 45, + 57 + ], + [ + 20, + 46, + 58 + ], + [ + 20, + 47, + 59 + ], + [ + 21, + 32, + 53 + ], + [ + 21, + 33, + 52 + ], + [ + 21, + 36, + 49 + ], + [ + 21, + 37, + 48 + ], + [ + 21, + 42, + 63 + ], + [ + 21, + 43, + 62 + ], + [ + 21, + 46, + 59 + ], + [ + 21, + 47, + 58 + ], + [ + 22, + 32, + 54 + ], + [ + 22, + 34, + 52 + ], + [ + 22, + 36, + 50 + ], + [ + 22, + 38, + 48 + ], + [ + 22, + 41, + 63 + ], + [ + 22, + 43, + 61 + ], + [ + 22, + 45, + 59 + ], + [ + 22, + 47, + 57 + ], + [ + 23, + 33, + 54 + ], + [ + 23, + 34, + 53 + ], + [ + 23, + 36, + 51 + ], + [ + 23, + 39, + 48 + ], + [ + 23, + 41, + 62 + ], + [ + 23, + 42, + 61 + ], + [ + 23, + 44, + 59 + ], + [ + 23, + 47, + 56 + ], + [ + 24, + 40, + 48 + ], + [ + 24, + 41, + 49 + ], + [ + 24, + 42, + 50 + ], + [ + 24, + 43, + 51 + ], + [ + 24, + 44, + 52 + ], + [ + 24, + 45, + 53 + ], + [ + 24, + 46, + 54 + ], + [ + 24, + 47, + 55 + ], + [ + 25, + 32, + 57 + ], + [ + 25, + 33, + 56 + ], + [ + 25, + 38, + 63 + ], + [ + 25, + 39, + 62 + ], + [ + 25, + 40, + 49 + ], + [ + 25, + 41, + 48 + ], + [ + 25, + 46, + 55 + ], + [ + 25, + 47, + 54 + ], + [ + 26, + 32, + 58 + ], + [ + 26, + 34, + 56 + ], + [ + 26, + 37, + 63 + ], + [ + 26, + 39, + 61 + ], + [ + 26, + 40, + 50 + ], + [ + 26, + 42, + 48 + ], + [ + 26, + 45, + 55 + ], + [ + 26, + 47, + 53 + ], + [ + 27, + 33, + 58 + ], + [ + 27, + 34, + 57 + ], + [ + 27, + 37, + 62 + ], + [ + 27, + 38, + 61 + ], + [ + 27, + 40, + 51 + ], + [ + 27, + 43, + 48 + ], + [ + 27, + 44, + 55 + ], + [ + 27, + 47, + 52 + ], + [ + 28, + 32, + 60 + ], + [ + 28, + 35, + 63 + ], + [ + 28, + 36, + 56 + ], + [ + 28, + 39, + 59 + ], + [ + 28, + 40, + 52 + ], + [ + 28, + 43, + 55 + ], + [ + 28, + 44, + 48 + ], + [ + 28, + 47, + 51 + ], + [ + 29, + 33, + 60 + ], + [ + 29, + 35, + 62 + ], + [ + 29, + 36, + 57 + ], + [ + 29, + 38, + 59 + ], + [ + 29, + 40, + 53 + ], + [ + 29, + 42, + 55 + ], + [ + 29, + 45, + 48 + ], + [ + 29, + 47, + 50 + ], + [ + 30, + 34, + 60 + ], + [ + 30, + 35, + 61 + ], + [ + 30, + 36, + 58 + ], + [ + 30, + 37, + 59 + ], + [ + 30, + 40, + 54 + ], + [ + 30, + 41, + 55 + ], + [ + 30, + 46, + 48 + ], + [ + 30, + 47, + 49 + ], + [ + 31, + 32, + 63 + ], + [ + 31, + 33, + 62 + ], + [ + 31, + 34, + 61 + ], + [ + 31, + 35, + 60 + ], + [ + 31, + 36, + 59 + ], + [ + 31, + 37, + 58 + ], + [ + 31, + 38, + 57 + ], + [ + 31, + 39, + 56 + ], + [ + 31, + 40, + 55 + ], + [ + 31, + 41, + 54 + ], + [ + 31, + 42, + 53 + ], + [ + 31, + 43, + 52 + ], + [ + 31, + 44, + 51 + ], + [ + 31, + 45, + 50 + ], + [ + 31, + 46, + 49 + ], + [ + 31, + 47, + 48 + ] + ], + "vertices": 336 + }, + { + "adjacency_bitmasks": [ + 554073785691985571619418448471349622974282293056383916914255835178294984082937891663571320832, + 1076337217383629169650345502364958359814482123885043724056649920563772417597354809755922906218496, + 1076337217319650101567061587082879641703182404030128052717325494413940391796841925373127276101632, + 554073849671053662984892204846449079805446740974143816481968639229870472751775095787295342592, + 1108147571383971143238836896942699245948564586107058843057687810549947220636406182565709348864, + 550684157733327670677589729698597481966301103013188761732260212949819739786663712824910506098688, + 550684157698617641332429140355576177606142470953911479101947041457829955772729108967700473839616, + 1108147606094000493707034822558218710157980700095716985966131482526458672629096881113863815168, + 542340458372318946778209938539611570748036748215839516795160216930018819780613319075521223458816, + 1075554995755030817699776471821223622640250726157935629400355916469989866684313396525001605120, + 1075555028529979821445439498361471393200522139016789223226518088898810728553634855072227655680, + 542340458339543997770057758934356530792844167786134047676634426803551562908943915930136566824960, + 1084680916744637893556419877079223141496073496427283110696786061808922723963535099678303084085248, + 586666361320925903853062428871695709609767100683966624757290584289124608231306134897934991360, + 586666427235074328551904027431470410507847602018067000024440411995121413171187478790506807296, + 1084680916678723745122738385002487562530225496295082161773379981101048886283959045640173073203200, + 275542327650209067430480789323399966206023099829106988345071241498448519508790137366871040875036672, + 275542327633797529635356053263829211131978510780462673838482871572836065598130089254060585983672320, + 554090197229782780553011490715630490792070667134185390442678772187640708618823275812128555008, + 2216295142767942286477673793885398491897129172208408695344551761293251693743342764369985404928, + 140975144379731883693447712311587732063222049688831804922887296331708639255801957045343619909681152, + 140975144370780581460190682601898807978050576849955352752012941434765760268280815219907033068208128, + 2216304094070176932772163129793814211242384252212911026726200354087790132556496174050223063040, + 138839157343313650375221744266140562111497407542486280618140374345157664907459349971439311734702080, + 2118517415881121882096323172831075110186483049464006931859751699465007972080530646640466329600, + 2118525869882884496206949341526406839029334561596295743121459158361909033395732867456851509248, + 138839157334859648611449942437932805588832813455059237180440573466577681150814445829103563768332288, + 277678314686627300750443488532281124222994815084962490576561015401616412008276715691195551126126592, + 651851512578807712731932503513738252385594834177751335929646415396853316990558572203999232000, + 651868421417073480387075594497565739604630842812137757862748816824236316616032915079911440384, + 277678314669718462482360062278110728049072246128935451712685436221361604456226193329836101707235328, + 70538835878453521262203074407508358422191491514257660559734033557672816034157415885550373859160489984, + 70538835874252134690285337922510886715916812751470605295614298089883893965873752342168066539632197632, + 558275172264436877991548673004031432164264732048719211138757952567479732550602012198711590912, + 4432590285535884572955347587770796983794258344411108399918279662779860639957215927978537517056, + 36089636961211362225522583834783954744860908061995162039861186470303539675100642596950801239727144960, + 36089636958919697784366992391427839140374062481164094988441615885801239586450208408537318123399806976, + 4434881949977395877216258337107544122398822583412569862467118861295256253425613169857090551808, + 35542824279888294496056766532131983900543336330874973859563439511330519012806758508966621762497282048, + 4204442256133450492406555743397330071497237382554251694315041403582671335529309978130288476160, + 4206606605879234673753711362968362477002671226625212539151058875045144390050756766623552503808, + 35542824277723944749976157892430591552823692451229555303142345417303766085265662364946597435144142848, + 71085648559776588992113533064263967801086672661749926298993506891539043502024786448255139786690396160, + 782221815094864293522313931379396715160835945273126646978507305054452685725030732813702266880, + 786550516362153440103511899119125833999020223508572953036082465782131506354046349226220191744, + 71085648555447887724231531070924386279377368746848666870749999370923135394488122880396362082469019648, + 20786434841352219617133216519304617645788634072898027937011229212021009, + 267827102405912676264947612627158328349379133549451640713413264069240065691230754, + 266789044418494643758549138599576047887879315320849705483471736658176260223074304, + 1046199639478334365407684792018149373676992438064566848805550749110326859399168, + 83145739654657726435151115674771647204563804745588650628938229527093777, + 178551401603942837187062764225176545458592245940078031515322365807997172899123490, + 177859362945932695273565504579150896565283831340479144057688390385805812380532736, + 697466495336353173399137943078880248578550203847142462147981072024884538769408, + 89277084243222508146503293163641458660069051097100128484066006487765740682223905, + 1701536081738225228818560558021326807147615118030863458971360685647091208722, + 347667859594301951425185300706770327857303594792188033333737429467809085718528, + 88928510053444227146286495505742175635787839818974729565305718957258867642204160, + 357108655005361692695192497648115968365609053335501951547676487840147755280372257, + 5533806579123660466541451148864084975842178314927236227092599663713639735570, + 1389664128494734354165908384608044438733919026841592258902921998738807694360576, + 355713563164257460652612418623202553961710986822068080469055261014452266680188928, + 4217798367991400512119797167411397036659923806338521838609045121024924795987608830298047556, + 70814378201885931961642154624639161650349484730108901571338261718067524884030125707886285090226997384, + 76895533358799430172312678259414591347935788391573919456628577422466744106568334141066492489236480, + 19685256539852654124112030315846069448049283560515885007465905900228949888368507132822380384922632192, + 16871193471965602048479188728941601979796436392848306151253255262514561317235547080725923908, + 19762152056340260082318740825480697433065796301160383968401331883153403656746269292621964263179699336, + 18044818495883450935269975890851849731168729334431707968563265799491871077708406066819510816892518400, + 70487572249544730215972824761656295308495013236659451059590355950742455174780175310088980796538880, + 18115306051645238408792202163279790424866497082388834345149236946047643412794647995180588493908771972, + 16487757256693744753683402604092846779695120378524622824924293769255488019218385131236509768, + 72179273922422724451045244082169768063984632332228904726380120305147198351422231482103311203288743936, + 281950288759463767386935892488348187159121235872637280452734812522443027125312753791729136624992256, + 72461224206580953635168808716725656031487824194554047401971799179756366962414889379972257018453969028, + 4601234583263373236801170665200263774400488036885270008123403028791105445045525928034206792, + 4201450809263321001988090458549065168736266819933089015868154166290684582848933964760088576, + 70539912211469454082109403690949994479178395806473844405045623635064703470309635153999411225855000576, + 300373177182810274110716310391923224377857420434015753246680856896852324715741188984143653896192, + 13123504357864733439740200871059334208987628236729412132203849215445352059330175059142213652417871872, + 9166918325798961184445690552122645573293781483141874872649313279205040142855791138507456512, + 13123804721874997924215350162633481808987882462785189776618111566135807938036725320673911451255308288, + 9295815588603259332451826518300758088258408147499961283729685686357099246500693833564166264679563264, + 275342079099784121511547041251501391704964844389592272796345643530833538265454485648066591326208, + 9296090922406649858404348603902040171436766854327918480573184867564706240845483254324631610054541312, + 8275709258168526310751221201749012861218111156446663493749743313014578941039449347599892480, + 74366524647714995369520975592840853995719884626871660208398350943717145413825479225523006001431707648, + 1101368315466655351776347345424832992945634600960303328519733106889481676446973000720839966982144, + 74367626010937802147949932382618547783454007517494135381004654944701539733463669242934760066343108608, + 5092659876923283008619671475648479220019115636381336416986325552604972876290338220815941632, + 16475774874966408271173197954861233589678495701349543836430357421615597680820318707384320, + 276618664851116921725164666523202002200941464238485191521173669781113612162178883119795846644760576, + 200248784757457480465026069260434820425168731249130990812792080298901573125781322966973116579840, + 51263688897909114998985399474457596682637196089698920820880956587592415311563095407747700680032256, + 35947145181744890811114719008857613379967777894819016137797414617280249760020422744604672, + 51463937646719427297705054315843605122351696316598645977461576856896574518758086358578996807991296, + 36311779642981484286987362583491376228646784226331368231503540759111137258821312653610102498000896, + 141842889230401304211566218529913269645145641671923731483655742930440209639520111224490028957696, + 36453622499759595847655946399081538223958059250357675181024352676996371118612606874816793511198720, + 32452289624971914758157669703609522771455923102139247391868598505833187608683580332441600, + 290494236905136705701386141402292665813555554121708630858509167029182076626574751633768993595064320, + 1134743112910692904811120541021959064136861344552263376967930345774835125056140872822497665351680, + 291628979998076760734121630076039980034765082906564155206467394811400394933260066871207104553680896, + 19970637990647239960206158195539619655096405494851132471398774753629408526484795115438080, + 332582963246612473206496456259937414760803514246299224610177539967042577, + 2300617291631673006610803336170604971571684069336394376301365756260801337511033141150617924, + 2291700441416356910176572029287846562327462978752489568671140406055474168174814400774012928, + 8986786295436223013357259138939542497263591928778112582615491653592929629548864530808832, + 383442157106877582140325220894140441214732555563797972276461554970238572048459745734967617, + 7307773996927482925805503699384882583051933257612764376319762786049054509642341684244, + 1493221820038802518667492553586262238979640469037681210912059251994868698544767100387328, + 381945042360503968135415964432947159281461919154926701523094222077706102277202498868477952, + 6135074513710041314245203534306247059435720889020767556423384879523817152775074516914148417, + 93703419848450525371844202650800359892192039229905648240427082612960586873761068761364, + 23872198317202182055568172897854200171373680492230221135520563810581004338006803526320128, + 6111109067286012297318951731761604258105679110579310721761031077344253843917372398000668672, + 51263688862102100004866830527885068070293715887952584664266714425396859313417750298299560385052672, + 13123504348698071808514285189079794678961564832719512762758354801414109001196390197550874195929333760, + 4285233638494602895443862273355278148953892058357619811641140126465767900285274146, + 13174768037560173388212493883653802499402996393799472028935397259356706248751569235792805680843334280, + 4921314130761941960517887152958808054283677829891549872177612546567888109570240824741839813402951680, + 19223883323585419097002911414992226221918404392728509901320600942812549536336930629373856384548864, + 4940538014085094183378719673076500382842102133582649680205798166127878187539578047062620170801414786, + 378847038490232423835671787736755900842782900304006105131146455637579234518010104391720, + 78741026092188759531833185146450499746538596570995208898557593506955006034220573315493090098709266432, + 307582133172809204094669160195348458926178023175115106857459590799597015536814976601838511498199040, + 79048608225361506934059514769224006125473634137322394883292770658045969885851323543564404871781165186, + 116925098156442484222258486256602616438280393585722685477095464555044829971834449461800, + 200248784618101341714163794433903366504975673781534855431088440995812559777209950950059585568768, + 19685256523047107838219650926614159584757881751103684397923800837143655495071263735140737482760388608, + 2845771518147772954406692506462474665966786330272205235539709557096034692613865472, + 19685456771831724904672744577344839763444137366555609414484207505366023950141995005865031011353755648, + 2734063406021037382487240013389634008725504311455133294370838054571075873928858766162126131125288960, + 75093370322049665839904589556567740686178266540156109132583063208618208345422851583696451928064, + 2734138499280456386449610584794985880125933470195740134227625499692678481880098728255069063240286208, + 96978070969498909770479187997510942652593579704945275866477066042186007498420325832720384, + 87490028991405021926275463807662304075635786786835845871694229711212654631017417564214462305148076032, + 1201492758432482035156292718851998956260636380252579403138721728221505539483349457097292743966720, + 87491230484147540670643813899072201389078324140996090876157420123281834584237421980767829782054371328, + 29840002454337868368141436751597201653944134549098726451863431132540645112655121927634944, + 300373176927410023229216879463042538319415418517857129225116696025847867180215740192197533761536, + 76895533293153795020185816907455173369821325213608885095176585499860820543646783135351078037487616, + 11159462931530216174388345158739185076597158620255096149750144984099416933662720, + 77195906470079140946557581680817797894411944808626756130701692867694466380841352874520018017058816, + 10679946001358174696458927749720720845806701624677213687856556035830329795058268798168775258013696, + 41737975951853973599378162198119690100911075555581871531668528606384838482044092590928783474688, + 10721655586121176797555834486001867033876544434573722933078906593675591957069750043970122341679104, + 24826376029881058304843052942019405579714578615323726228845688163484314052602855623397212160, + 341757947390852861741749823393515801293897692970730884066416023053475704848157554288552619653726208, + 1335004883554917933863781276299940127826768184755479578369131530091660969200417306822710294216704, + 343092948200336919753243532552772026746054417904948242515634284627031488089020305886844422469976064, + 7638886004010224476562709702204968526620368840445186344504727422056244179760753771848663040, + 1330331927034154972280257722013362874123986781208310851951766574478166033, + 36230612103290476817584358180047963207616626281557461642827026146808219851017343791942824026087362952, + 36090187643077395111776904213979550708668202564584924879504584179929109773250484427873953482799316992, + 141525828528478425068688900465947635049918473502047102654493327050159039830586651285178675797950464, + 1646871524681733191968250506544309073048286839533015132478517049198480920265797299149994432405733761, + 31386650323361761617225104970123554958621896504630908582111020024929651579450852828157854095384, + 6413338882740253290452814705464921123874642062285729846713121779039085477334762112188581206032384, + 1640441465807699185216001601330463970175875343734865452925161348557505010426869671305086492072738816, + 105399754112976476912688318606341450199053942417197073447039483820364802334538453871958516918323779713, + 1603945831477963668439084444782652457309590244002880565367948815266794748662251922312094877253912, + 410112444228620657479808394601867525007906053834887750008113417182689397993182531029421128302723072, + 104988039678470915572646713945917264026551001324079615802006380194060340084274555863634788485320146944, + 1108183378398993051608836424387992901046012614639250765872854776228530966796220537952853295104, + 1117314233022311324703338742926189200791115881944192636622078896102794229907615232178025136128, + 2856822425663085418132912064932284695141730064753957579220672376992987262320919586, + 9202469166526692026443213359723359980550885256414160278946919729996597034551129639936336452, + 709215591353352342155215453731373068113032397932617078900043926164373031668346623561001435398144, + 876088437177844907491551845907825340762701810080616980749822511624416657010320745696546422521856, + 125254418421500696308977493888055807963335840944807882444385443753341424506936429475778785198658, + 425626445039233842841982937597662497788261870728284776187225953323406790109149090409475016238116, + 1418441113257089492786750534653153302549632895100696050728534389365320648832449338871283701514240, + 1251554951602938955079881102975874432658846185620483520631532048297505023064559120859806157504512, + 2004064559764566789815622273413479788231489975889849883028724754327614274245008849965017905243202, + 1703679112879302249839606335691440361509224294740340578501481641944707340245541189312557655015972, + 2216295282124081145534595479214065212210102176729139380582215904902517445310926604661430419456, + 2233100689060948931649428010174084004809425724088994342826212433154322894978737859184044277760, + 4268602999683064568451750093047361308451904067588158846736426352928434784417415168, + 16805686676919750464212959473561955278382027858154880297812688537081210112587784964496556032, + 181558898689851100112030919345853686385906278073374409796920376408811963580745290892781044658864128, + 224278638771713042671522237035196891514626497801551620729161094650790549873469461852270347792941056, + 32039969138282984619369160588725907254385538951564939506262222588064740247391728781667177766912000, + 108935501794844521464975107175105560869188061212756838605499277282269468411011041673359504488660992, + 363117816476914481383431931623186196510018376551103518757139583199196462367183171868194076079685632, + 320398055388323008572939492444843873780153198681387881004670854930830274780413552024423454140792832, + 512639516397614387475510165766438823945531899574862164901602311892555784071154420350591010441592832, + 435743962733915368982224797080568450430008161842312951664309033664213220636341187726205546010902528, + 4432590540936135562649425375392555854841956421715481148269909375097707382803544059701350105088, + 4432655931171064489617752502021246428655439294997298709324873748835306750678477035765342666752, + 16739195225504882791129127253018152047571574929483524206563552627370321581703168, + 65903099499865634327007183703299418388690719196853916855243926260415886700261227490181120, + 46479077901641490009099689725425878812859171863609679431813341495552510543653221789156120191349817344, + 57415331525554072728122652280249954865900220671235345332236945212036922023375336113960725346215002112, + 8202190511271971638089389836203390759575108779056030817279641864926357033606179164655629344715046912, + 27887447034316582627917375973241311830054168488555778179938992477326744908548559651305750079008145408, + 92958155803357578503672658240277271214873571093705304661001531684739364992103564239898663325383262208, + 82021902179363257990991651149006782663960537485972839318720650440704781581070502020612965751949623296, + 131235048180391487481854398368952356290006032013617060961085181827378649790941391728613939497939238912, + 111549791657264497617669365584181238055025348464183980684950734716976577607335116051743343371955994624, + 3714046805283432169145303055, + 70220586481133475621705794612530564273403477360880, + 287342971002262890027888896834682024703880366185250816, + 1176956575419260769233878400201702076732466287460806033408, + 59424748884534914674111611075, + 3924146394329730599302415107245608548038105727515303608380, + 3530869959995282446772103404116772813396781214622631723008, + 862239197972841196135784643739548766553601437834674176, + 16729643284526251600455028933990132426604709, + 2354487836597829994761551625982092081051212263563722752090, + 1961594432612494927569599947578068447646765391504107962368, + 479021776672483689094244741655507335027093422875869184, + 4708975953889609218616328715647097583657790119923349192809, + 350777528296550315537998556545741795307706363412630, + 1436714598113693642203149304504888597113803442175541248, + 5884782876976394134735294358328662325897754593641568927744, + 1123529383698135609947292713800281499337032917323520, + 17976470139170169759156683420804296460355103956725760, + 100515503239651970751862013950105248637688235745509703240595957628023018480205715777381170463488, + 406755344128919610682592513481310913738990478102538068754324417648369699928305554391980010650624, + 400888680142626861799362330375739749348803539132594151869875539337906077641730362967065582675200, + 106382166828092201456466609195915961441710117267468425998277968054378138229272825804207442385408, + 373083489998528331759500523066631222271212540288683883438953948665527270225322409224448, + 24769028397928297022657375745199437109615997365420845818180508176911366540914981901824, + 4597487536036206240446222349351512291389142058596827136, + 73559800576579299847139557589620796558353329137182048256, + 25632170362775089228935105698751190644980807878135584317749924159824150050149708306400276029374464, + 102532592631790375798078565491603545816903474830811350211624795030786760235581385795280845227950080, + 102527703649959897478292882799310472165610288421454346513420633490767796309736590897287619690889216, + 25637059243150337295353471524092027446143108476635815211221917516188401906208194142502978672656384, + 95486137298414736663410581740839267294510879217531289545592099341880306588307378797543424, + 5969093010533383765455453563277830097697822953321102760799669324713802349022911125258240, + 18831305206708172307742054403171525925951608987221971959808, + 301300883307330756923872870450688707513457892183400626782208, + 6561752371432266529010337689365509549341733815585428770888054358560967799079481305259769971863453696, + 26247011850727835186755322853613783636753641537211212622881127906217175922777339334921179916289441792, + 26247008892951596822003544210331466269573482872946057045281247799051039920202085171308830876393013248, + 6561755303236295428579548129495325349048620362878678099366657930496105840812893046173008524734365696, + 24444431767236547977555521386717116945572174670127687986211075775469413450015081462199484416, + 1527777712174552511515195489195290592101109069304443854776802575639606557490957476819894272, + 950795982152558634753572539395, + 2380685355273517481385236605956977215652354491375549685978685698042086254832566320, + 4742880160740506158587115999458388223065519448605519745172643076479615473630576640, + 18599104335909134606616625225529689848107755375395964353503808646838773056798720, + 15212735714440938156024947392515, + 4761370710547034962770473211913954431304708982751099371957420919647258911682071600, + 2371494358740305270350030679982991387626131039354083236572503643605912450307194880, + 9299552171202398378366616250528636897818273820427450784772729549957176345231360, + 62786342309275689588838641715929736768609678973870905754380, + 43915893468758877034626859641560650498130241452118159410504644527400776926973346675991651463955755200, + 5489486683594859629328357455195081312266280181514769926313080565925097115871723675600935239685243840, + 1004581476948411033421418267454875788297754850915560540090380, + 21359880544388982496380881627751678909714360322709269436632087878631788723901366253890457227493376, + 5468126811997315669844038626379487822248341262477232405568900988001108351953247795485417280819429376, + 43745014495665211719814142641997803790271588758428637783512071367395196466448370068302933443831922688, + 170878964146820291800655667624341498448755921804997198517772828796158481751492422803132339284082688, + 56493919359924519148353654465868365014348488878650475020288, + 52494684909074490669862554729847775506148829017576081863749653431228280613921681614557887190490152960, + 3280959524932016464923201435853205623931815860068590283080598581311500241832054708312679990524116992, + 903902709758792306373658471453893840229575811503095967776768, + 83455326914447560468561645409097323971503396496496626351370045685589214648277807117172345929728, + 3280876087174673300070131469679870428437742903318540494617275212434905712356392969033889512958197760, + 52494017394792305611628975937806328539165143883935108055719775759350964076598470455345062529321664512, + 667496712613775526180797310315864205656056872771616815707867940661466867504669354638745777733632, + 13795827167565459138172554299832780264851289625105268736, + 205855750658771999554309998388678031292560436039144603003287714356358253421477458824491326190387200, + 12865984414675452256238337785613471825624094175425242014796282576402395857014501617475923868647424, + 220733234681047346210760868797324484237614300621434781696, + 50062267768942373065527397371141922035154117094008582335653882815375359017451830635275988500480, + 12815922215805204814850699823575521161875864249518898047844211951661654530001016079414711570923520, + 205054755448419023923275555441176444438560451405067232682968009449158910812385595902572556529434624, + 800995141454280699356917261807856845587149082976783729879178080174500953267276080794757396168704, + 267674292552420025607280462943842054399199749, + 8691220879497431358778612196568965582647172446995203791905278512705229827208663934710095952, + 17314937900327803083327936787706970167657391886886300251365807182084192584538042836642693120, + 67900163121073682488617470176495338219698219562140537163164775704015551604950140450766848, + 4282788680838720409716487407101472805960720389, + 17382441758994862717557224393137931165294344893990407806764538945359373756249008685925272144, + 8657667102390908566733191048194368781908561754532826965198121901796400343486539519553437696, + 33950081560536841247069391502047227201948337108799307115088613109696948366890115696427008, + 37671805385565279916184826015694903062862159624181225882890, + 37328509439753824601958981888530430586019190766716693685238245470072743116567206464777435736788979872, + 72623559221311946505786981344531195900102809697084131851116830172642254690984427879390299476197376, + 18591631160655601903549768731054234204111904543293235092642046073714034932450299595732570876921511936, + 18664254719876912300979490944265215293009595383358346842619122954374202669997461014334843253115848096, + 602748886169044478658957216251099878771837317394061275975690, + 37183262321311203716025122345925191736980827728650885960556524123775225555137697990249744673837940736, + 145247118442622432986341759227438487344013323904329957947435496593711834252233082308622763673255936, + 31385510921799918841113599161230526061689790269665824800768, + 39371080417650631134358553302538978401505211210923049556459437616041304031288854250346779365212160000, + 283685778209236294711201709342058642880149076309650542612382462562387995626796834832452039999488, + 9842628261523553963218305189576725850329658650692529428260579041413389487228717464142459916683051008, + 9842911947301761906080163436692051647298502902655311802613667853078395145830470317019778044625158144, + 502168174748798701457817586579669847886378188320253294215168, + 39370513046094215625216602300134021349863538854018809446935512641886517909507978907054129990617530368, + 567371556416795816220535118362763118720320876245604379293554702263835694781528232181395020054528, + 7664348426759739025507915866486983923302315613690527744, + 154391812940158281908459423774406667742803385066883717904897793441987344855814018084661781749301248, + 150186588463689849776733599847398629096654183018319600846878215436107410980548291629729477296128, + 38447766646576654670983066161246045051799027192403440673430972689116514430119369305042819448045568, + 38597953235039570475371189912313175008521681629187762065458756833952166677290163908354990137147392, + 122629574828155824408126653863790609335705870666725064704, + 153791066586306026776773481918184084439078891108498359770255036592636276691369080135316600099176448, + 600746353853029150570827201208213068107651687170843924670312469266698214869333982758563540369408, + 75343615262233747497861259450353561338524641918644734133769, + 10978973364633477823510411569850071994927055533462361392234752153352815416931324502391526249746948240, + 21872674121817300564825209382385045182972292310792667029400107795361508029149382148885601139066142720, + 85773229411199045496175090388912382281267739592921252731784188320226186769898617583029170103910400, + 1205497844195739959965780151205656981416394270698186893189129, + 21957946729266955647020823139700143989854111066987478751337969946198973183276465749970190957931398800, + 10936587371889422264062885358005769885647043415359033541446070574290058508696894581192868723669073920, + 42886614705599522748087545195268148910566575106980095508330744820924629947058454997418112387645440, + 5612440452744805048607939764263954251737625138301190, + 2556241435741474679358469999951813981083449469153023907079357393412806571505842892308516960, + 4302284634039760741959332556324676946361279243764625961460049813383722084628407945158834782208, + 2363216362045047986673965304381080810577649786747773897182788870945340240665327826700702056448, + 4304766276988867774778393704664018463115478478256605351569618921943117981925167542158655225856, + 2346675391205909727843910426203758020374588885949441516896414026756182618785506519358212407296, + 16615569332319585415830054999686790876969465614265497343636509561260158207659167404544493920, + 89799047243916880777726999087755353554616325536518150, + 22987433569819098275250388834940016236908866275010347008, + 3055592818946722584652164644203601468228339966916723509787109961637973423513983614435983360, + 4237035083323754188677558328036658109918246562352352450307561686003085404332718868746324672512, + 1312105798256450859363920521270098493106667222016240449946900889063414622424596646858674143232, + 4240090384740232847368440663287471142537039389939254931164906617282631560118157655477057486848, + 1303703063709405362866141000447836826659304366373514914415849906818843188688085365669033410560, + 8403025951292226391060568257243716165479424085624541954217249634875583710581952407747428352, + 367798937117105572404006221321902058473629871600367239168, + 94156526031622306155764709733258594947489811140185941868544, + 11982381731433095384523621666894085850374033997478953047958939909555894401971068684206080, + 2151110119225368362513058333896309932996192764888130812279376772270569642095439381528307564544, + 1173365545702267047892517983618254894242370150917425495474038191605943474870419674177359314944, + 2151121926766891171831704024542164127036488256953373911914068077844621827909126582267312865280, + 1173332768992725041386177723372109078685164746513225566232913584464775474500693765912526848000, + 32951549757604947038605277344352886938028049591190212722153603292009590335283293495230464, + 1506504416505956898492235355732137516892962715884895908921344 + ], + "adjacent_overlap_counts": { + "3": 3360 + }, + "closed_row_overlap_counts": { + "0": 15120, + "1": 30240, + "3": 3360, + "4": 7560 + }, + "degree": 20, + "edges": 3360, + "form": "alternating_H_plus_H_plus_H", + "matrix_rows": [ + 2, + 1, + 8, + 4, + 32, + 16 + ], + "overlap_four_witness": [ + 1, + 0 + ], + "planes": [ + [ + 1, + 2, + 3 + ], + [ + 1, + 6, + 7 + ], + [ + 1, + 10, + 11 + ], + [ + 1, + 14, + 15 + ], + [ + 1, + 18, + 19 + ], + [ + 1, + 22, + 23 + ], + [ + 1, + 26, + 27 + ], + [ + 1, + 30, + 31 + ], + [ + 1, + 34, + 35 + ], + [ + 1, + 38, + 39 + ], + [ + 1, + 42, + 43 + ], + [ + 1, + 46, + 47 + ], + [ + 1, + 50, + 51 + ], + [ + 1, + 54, + 55 + ], + [ + 1, + 58, + 59 + ], + [ + 1, + 62, + 63 + ], + [ + 2, + 5, + 7 + ], + [ + 2, + 9, + 11 + ], + [ + 2, + 13, + 15 + ], + [ + 2, + 17, + 19 + ], + [ + 2, + 21, + 23 + ], + [ + 2, + 25, + 27 + ], + [ + 2, + 29, + 31 + ], + [ + 2, + 33, + 35 + ], + [ + 2, + 37, + 39 + ], + [ + 2, + 41, + 43 + ], + [ + 2, + 45, + 47 + ], + [ + 2, + 49, + 51 + ], + [ + 2, + 53, + 55 + ], + [ + 2, + 57, + 59 + ], + [ + 2, + 61, + 63 + ], + [ + 3, + 5, + 6 + ], + [ + 3, + 9, + 10 + ], + [ + 3, + 13, + 14 + ], + [ + 3, + 17, + 18 + ], + [ + 3, + 21, + 22 + ], + [ + 3, + 25, + 26 + ], + [ + 3, + 29, + 30 + ], + [ + 3, + 33, + 34 + ], + [ + 3, + 37, + 38 + ], + [ + 3, + 41, + 42 + ], + [ + 3, + 45, + 46 + ], + [ + 3, + 49, + 50 + ], + [ + 3, + 53, + 54 + ], + [ + 3, + 57, + 58 + ], + [ + 3, + 61, + 62 + ], + [ + 4, + 8, + 12 + ], + [ + 4, + 9, + 13 + ], + [ + 4, + 10, + 14 + ], + [ + 4, + 11, + 15 + ], + [ + 4, + 24, + 28 + ], + [ + 4, + 25, + 29 + ], + [ + 4, + 26, + 30 + ], + [ + 4, + 27, + 31 + ], + [ + 4, + 40, + 44 + ], + [ + 4, + 41, + 45 + ], + [ + 4, + 42, + 46 + ], + [ + 4, + 43, + 47 + ], + [ + 4, + 56, + 60 + ], + [ + 4, + 57, + 61 + ], + [ + 4, + 58, + 62 + ], + [ + 4, + 59, + 63 + ], + [ + 5, + 8, + 13 + ], + [ + 5, + 9, + 12 + ], + [ + 5, + 18, + 23 + ], + [ + 5, + 19, + 22 + ], + [ + 5, + 24, + 29 + ], + [ + 5, + 25, + 28 + ], + [ + 5, + 34, + 39 + ], + [ + 5, + 35, + 38 + ], + [ + 5, + 40, + 45 + ], + [ + 5, + 41, + 44 + ], + [ + 5, + 50, + 55 + ], + [ + 5, + 51, + 54 + ], + [ + 5, + 56, + 61 + ], + [ + 5, + 57, + 60 + ], + [ + 6, + 8, + 14 + ], + [ + 6, + 10, + 12 + ], + [ + 6, + 17, + 23 + ], + [ + 6, + 19, + 21 + ], + [ + 6, + 24, + 30 + ], + [ + 6, + 26, + 28 + ], + [ + 6, + 33, + 39 + ], + [ + 6, + 35, + 37 + ], + [ + 6, + 40, + 46 + ], + [ + 6, + 42, + 44 + ], + [ + 6, + 49, + 55 + ], + [ + 6, + 51, + 53 + ], + [ + 6, + 56, + 62 + ], + [ + 6, + 58, + 60 + ], + [ + 7, + 8, + 15 + ], + [ + 7, + 11, + 12 + ], + [ + 7, + 17, + 22 + ], + [ + 7, + 18, + 21 + ], + [ + 7, + 24, + 31 + ], + [ + 7, + 27, + 28 + ], + [ + 7, + 33, + 38 + ], + [ + 7, + 34, + 37 + ], + [ + 7, + 40, + 47 + ], + [ + 7, + 43, + 44 + ], + [ + 7, + 49, + 54 + ], + [ + 7, + 50, + 53 + ], + [ + 7, + 56, + 63 + ], + [ + 7, + 59, + 60 + ], + [ + 8, + 20, + 28 + ], + [ + 8, + 21, + 29 + ], + [ + 8, + 22, + 30 + ], + [ + 8, + 23, + 31 + ], + [ + 8, + 36, + 44 + ], + [ + 8, + 37, + 45 + ], + [ + 8, + 38, + 46 + ], + [ + 8, + 39, + 47 + ], + [ + 8, + 52, + 60 + ], + [ + 8, + 53, + 61 + ], + [ + 8, + 54, + 62 + ], + [ + 8, + 55, + 63 + ], + [ + 9, + 18, + 27 + ], + [ + 9, + 19, + 26 + ], + [ + 9, + 20, + 29 + ], + [ + 9, + 21, + 28 + ], + [ + 9, + 34, + 43 + ], + [ + 9, + 35, + 42 + ], + [ + 9, + 36, + 45 + ], + [ + 9, + 37, + 44 + ], + [ + 9, + 50, + 59 + ], + [ + 9, + 51, + 58 + ], + [ + 9, + 52, + 61 + ], + [ + 9, + 53, + 60 + ], + [ + 10, + 17, + 27 + ], + [ + 10, + 19, + 25 + ], + [ + 10, + 20, + 30 + ], + [ + 10, + 22, + 28 + ], + [ + 10, + 33, + 43 + ], + [ + 10, + 35, + 41 + ], + [ + 10, + 36, + 46 + ], + [ + 10, + 38, + 44 + ], + [ + 10, + 49, + 59 + ], + [ + 10, + 51, + 57 + ], + [ + 10, + 52, + 62 + ], + [ + 10, + 54, + 60 + ], + [ + 11, + 17, + 26 + ], + [ + 11, + 18, + 25 + ], + [ + 11, + 20, + 31 + ], + [ + 11, + 23, + 28 + ], + [ + 11, + 33, + 42 + ], + [ + 11, + 34, + 41 + ], + [ + 11, + 36, + 47 + ], + [ + 11, + 39, + 44 + ], + [ + 11, + 49, + 58 + ], + [ + 11, + 50, + 57 + ], + [ + 11, + 52, + 63 + ], + [ + 11, + 55, + 60 + ], + [ + 12, + 20, + 24 + ], + [ + 12, + 21, + 25 + ], + [ + 12, + 22, + 26 + ], + [ + 12, + 23, + 27 + ], + [ + 12, + 36, + 40 + ], + [ + 12, + 37, + 41 + ], + [ + 12, + 38, + 42 + ], + [ + 12, + 39, + 43 + ], + [ + 12, + 52, + 56 + ], + [ + 12, + 53, + 57 + ], + [ + 12, + 54, + 58 + ], + [ + 12, + 55, + 59 + ], + [ + 13, + 18, + 31 + ], + [ + 13, + 19, + 30 + ], + [ + 13, + 20, + 25 + ], + [ + 13, + 21, + 24 + ], + [ + 13, + 34, + 47 + ], + [ + 13, + 35, + 46 + ], + [ + 13, + 36, + 41 + ], + [ + 13, + 37, + 40 + ], + [ + 13, + 50, + 63 + ], + [ + 13, + 51, + 62 + ], + [ + 13, + 52, + 57 + ], + [ + 13, + 53, + 56 + ], + [ + 14, + 17, + 31 + ], + [ + 14, + 19, + 29 + ], + [ + 14, + 20, + 26 + ], + [ + 14, + 22, + 24 + ], + [ + 14, + 33, + 47 + ], + [ + 14, + 35, + 45 + ], + [ + 14, + 36, + 42 + ], + [ + 14, + 38, + 40 + ], + [ + 14, + 49, + 63 + ], + [ + 14, + 51, + 61 + ], + [ + 14, + 52, + 58 + ], + [ + 14, + 54, + 56 + ], + [ + 15, + 17, + 30 + ], + [ + 15, + 18, + 29 + ], + [ + 15, + 20, + 27 + ], + [ + 15, + 23, + 24 + ], + [ + 15, + 33, + 46 + ], + [ + 15, + 34, + 45 + ], + [ + 15, + 36, + 43 + ], + [ + 15, + 39, + 40 + ], + [ + 15, + 49, + 62 + ], + [ + 15, + 50, + 61 + ], + [ + 15, + 52, + 59 + ], + [ + 15, + 55, + 56 + ], + [ + 16, + 32, + 48 + ], + [ + 16, + 33, + 49 + ], + [ + 16, + 34, + 50 + ], + [ + 16, + 35, + 51 + ], + [ + 16, + 36, + 52 + ], + [ + 16, + 37, + 53 + ], + [ + 16, + 38, + 54 + ], + [ + 16, + 39, + 55 + ], + [ + 16, + 40, + 56 + ], + [ + 16, + 41, + 57 + ], + [ + 16, + 42, + 58 + ], + [ + 16, + 43, + 59 + ], + [ + 16, + 44, + 60 + ], + [ + 16, + 45, + 61 + ], + [ + 16, + 46, + 62 + ], + [ + 16, + 47, + 63 + ], + [ + 17, + 32, + 49 + ], + [ + 17, + 33, + 48 + ], + [ + 17, + 36, + 53 + ], + [ + 17, + 37, + 52 + ], + [ + 17, + 40, + 57 + ], + [ + 17, + 41, + 56 + ], + [ + 17, + 44, + 61 + ], + [ + 17, + 45, + 60 + ], + [ + 18, + 32, + 50 + ], + [ + 18, + 34, + 48 + ], + [ + 18, + 36, + 54 + ], + [ + 18, + 38, + 52 + ], + [ + 18, + 40, + 58 + ], + [ + 18, + 42, + 56 + ], + [ + 18, + 44, + 62 + ], + [ + 18, + 46, + 60 + ], + [ + 19, + 32, + 51 + ], + [ + 19, + 35, + 48 + ], + [ + 19, + 36, + 55 + ], + [ + 19, + 39, + 52 + ], + [ + 19, + 40, + 59 + ], + [ + 19, + 43, + 56 + ], + [ + 19, + 44, + 63 + ], + [ + 19, + 47, + 60 + ], + [ + 20, + 32, + 52 + ], + [ + 20, + 33, + 53 + ], + [ + 20, + 34, + 54 + ], + [ + 20, + 35, + 55 + ], + [ + 20, + 36, + 48 + ], + [ + 20, + 37, + 49 + ], + [ + 20, + 38, + 50 + ], + [ + 20, + 39, + 51 + ], + [ + 21, + 32, + 53 + ], + [ + 21, + 33, + 52 + ], + [ + 21, + 36, + 49 + ], + [ + 21, + 37, + 48 + ], + [ + 21, + 42, + 63 + ], + [ + 21, + 43, + 62 + ], + [ + 21, + 46, + 59 + ], + [ + 21, + 47, + 58 + ], + [ + 22, + 32, + 54 + ], + [ + 22, + 34, + 52 + ], + [ + 22, + 36, + 50 + ], + [ + 22, + 38, + 48 + ], + [ + 22, + 41, + 63 + ], + [ + 22, + 43, + 61 + ], + [ + 22, + 45, + 59 + ], + [ + 22, + 47, + 57 + ], + [ + 23, + 32, + 55 + ], + [ + 23, + 35, + 52 + ], + [ + 23, + 36, + 51 + ], + [ + 23, + 39, + 48 + ], + [ + 23, + 41, + 62 + ], + [ + 23, + 42, + 61 + ], + [ + 23, + 45, + 58 + ], + [ + 23, + 46, + 57 + ], + [ + 24, + 32, + 56 + ], + [ + 24, + 33, + 57 + ], + [ + 24, + 34, + 58 + ], + [ + 24, + 35, + 59 + ], + [ + 24, + 40, + 48 + ], + [ + 24, + 41, + 49 + ], + [ + 24, + 42, + 50 + ], + [ + 24, + 43, + 51 + ], + [ + 25, + 32, + 57 + ], + [ + 25, + 33, + 56 + ], + [ + 25, + 38, + 63 + ], + [ + 25, + 39, + 62 + ], + [ + 25, + 40, + 49 + ], + [ + 25, + 41, + 48 + ], + [ + 25, + 46, + 55 + ], + [ + 25, + 47, + 54 + ], + [ + 26, + 32, + 58 + ], + [ + 26, + 34, + 56 + ], + [ + 26, + 37, + 63 + ], + [ + 26, + 39, + 61 + ], + [ + 26, + 40, + 50 + ], + [ + 26, + 42, + 48 + ], + [ + 26, + 45, + 55 + ], + [ + 26, + 47, + 53 + ], + [ + 27, + 32, + 59 + ], + [ + 27, + 35, + 56 + ], + [ + 27, + 37, + 62 + ], + [ + 27, + 38, + 61 + ], + [ + 27, + 40, + 51 + ], + [ + 27, + 43, + 48 + ], + [ + 27, + 45, + 54 + ], + [ + 27, + 46, + 53 + ], + [ + 28, + 32, + 60 + ], + [ + 28, + 33, + 61 + ], + [ + 28, + 34, + 62 + ], + [ + 28, + 35, + 63 + ], + [ + 28, + 44, + 48 + ], + [ + 28, + 45, + 49 + ], + [ + 28, + 46, + 50 + ], + [ + 28, + 47, + 51 + ], + [ + 29, + 32, + 61 + ], + [ + 29, + 33, + 60 + ], + [ + 29, + 38, + 59 + ], + [ + 29, + 39, + 58 + ], + [ + 29, + 42, + 55 + ], + [ + 29, + 43, + 54 + ], + [ + 29, + 44, + 49 + ], + [ + 29, + 45, + 48 + ], + [ + 30, + 32, + 62 + ], + [ + 30, + 34, + 60 + ], + [ + 30, + 37, + 59 + ], + [ + 30, + 39, + 57 + ], + [ + 30, + 41, + 55 + ], + [ + 30, + 43, + 53 + ], + [ + 30, + 44, + 50 + ], + [ + 30, + 46, + 48 + ], + [ + 31, + 32, + 63 + ], + [ + 31, + 35, + 60 + ], + [ + 31, + 37, + 58 + ], + [ + 31, + 38, + 57 + ], + [ + 31, + 41, + 54 + ], + [ + 31, + 42, + 53 + ], + [ + 31, + 44, + 51 + ], + [ + 31, + 47, + 48 + ] + ], + "vertices": 336 + } + ], + "h": 6, + "k": 2, + "m": 14, + "positive_query_minimum_rank": 1, + "scope": "distinct ports or induced subsets; scalar query factors; complete support pairing tariff; separate public legs", + "source_manifest": { + "local_files": [ + { + "path": "research/kappa01-fieldline-repair/verify.py", + "sha256": "095278e31b07b634a9078c434a63f02cf186a47ae1e4385bfcb8be5d131e6d96" + }, + { + "path": "research/kappa01-fieldline-repair/README.md", + "sha256": "07b951fe26431882f8ecb5f1529036940dde027b462250c382385a665f391621" + }, + { + "path": "research/kappa01-fieldline-repair/SOURCES.json", + "sha256": "b8e3b4beda7e08cad863c71f32fc42a1f5caef89c15e38a2ad3e3bff5668eaf3" + }, + { + "path": "research/kappa01-bit-repair/PROOF.md", + "sha256": "85f5dfd939e6f4fcb5baa5aae4a317a96aa01a68967483e507bdd903d657e952" + } + ], + "primary_theorem": "Sinkhorn and Knopp total-support scaling; provenance and original source attribution inherited from pinned fieldline SOURCES.json", + "repository_pin": "997e6a9ca7b4f95d50e366f61412fd640d72a88a" + }, + "stage_count": 3, + "status": "DISTINCT_BINARY_PLANES6_SCALAR_QUERY_TARGET_OBSTRUCTION", + "strict_complex_fitting_rank_ratio": "1/5", + "strict_target_floor": { + "lower": "12673585175111952508277785486251461160063/12500000000000000000000000000000000000000", + "lower_decimal": "1.013886814008956200", + "upper": "101388681400895620066222283890011689280537/100000000000000000000000000000000000000000", + "upper_decimal": "1.013886814008956200" + }, + "trace_fixtures": [ + { + "fourth_sum": "1", + "gram_trace_square": "16", + "name": "rank_one_K4", + "order": 4, + "overlap_cap": 4, + "rank": 1 + }, + { + "fourth_sum": "337/125", + "gram_trace_square": "913/125", + "name": "asymmetric_complex_cycle", + "order": 5, + "overlap_cap": 4, + "rank": 5 + } + ], + "weaker_V_over_7_control_floor": { + "lower": "2199920942606262038003379068046992028129/2187500000000000000000000000000000000000", + "lower_decimal": "1.005678145191434074", + "upper": "140794940326800770432216260355007489800301/140000000000000000000000000000000000000000", + "upper_decimal": "1.005678145191434074" + } +} diff --git a/research/kappa01-fieldline-repair/PLANES6-SOURCES.json b/research/kappa01-fieldline-repair/PLANES6-SOURCES.json new file mode 100644 index 0000000000..1500dc7214 --- /dev/null +++ b/research/kappa01-fieldline-repair/PLANES6-SOURCES.json @@ -0,0 +1,22 @@ +{ + "repository_pin": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "local_files": [ + { + "path": "research/kappa01-fieldline-repair/verify.py", + "sha256": "095278e31b07b634a9078c434a63f02cf186a47ae1e4385bfcb8be5d131e6d96" + }, + { + "path": "research/kappa01-fieldline-repair/README.md", + "sha256": "07b951fe26431882f8ecb5f1529036940dde027b462250c382385a665f391621" + }, + { + "path": "research/kappa01-fieldline-repair/SOURCES.json", + "sha256": "b8e3b4beda7e08cad863c71f32fc42a1f5caef89c15e38a2ad3e3bff5668eaf3" + }, + { + "path": "research/kappa01-bit-repair/PROOF.md", + "sha256": "85f5dfd939e6f4fcb5baa5aae4a317a96aa01a68967483e507bdd903d657e952" + } + ], + "primary_theorem": "Sinkhorn and Knopp total-support scaling; provenance and original source attribution inherited from pinned fieldline SOURCES.json" +} diff --git a/research/kappa01-fieldline-repair/PLANES6.md b/research/kappa01-fieldline-repair/PLANES6.md new file mode 100644 index 0000000000..570221b306 --- /dev/null +++ b/research/kappa01-fieldline-repair/PLANES6.md @@ -0,0 +1,132 @@ +# Rank-two binary planes in dimension six + +**No nonempty subset of the 336 distinct nondegenerate planes in binary +dimension six passes the three-stage κ = 0.1 target in the scalar +full-support query model below.** This statement is checked for both the +standard dot form and the explicit alternating form `H direct-sum H +direct-sum H`, where `H=[[0,1],[1,0]]`. + +This extends the field-line rejection to intersecting binary planes, which +can have several common orthogonal neighbors. It does not cover repeated +ports, arbitrary two-sided block representations, matrix-valued queries, +fused public legs, or a different permission mask. No classification of +binary bilinear forms is needed: the two forms are explicitly reconstructed. + +## The exact finite masks + +For either displayed form, enumerate every two-dimensional subspace as its +three nonzero vectors `{a,b,a+b}`. Keep it exactly when its two-by-two Gram +determinant is one. This gives 336 planes. Two ports are adjacent precisely +when their complete subspaces are orthogonal. + +Each graph is 20-regular, with 3,360 edges. Include the diagonal in each +row support by writing `S_i={i} union N(i)`. The exact unordered-pair census +is the same for the two forms: + +| Size of `S_i intersect S_j` | Number of pairs | +|---:|---:| +| 0 | 15,120 | +| 1 | 30,240 | +| 3 | 3,360 | +| 4 | 7,560 | + +Every adjacent pair has overlap three; every nonadjacent pair has overlap +zero, one, or four. In particular, **distinct closed row supports overlap +in at most four places**. Passing to an induced subgraph can only reduce +these overlaps. + +The geometry explains this small number. Distinct planes span dimension +at least three, so their common orthogonal complement has dimension at +most three. A three-dimensional binary space with the restricted symmetric +form has at most four nondegenerate planes: a form of rank at most one has +none; a form of rank two has a one-dimensional radical and exactly four +complementary planes; for rank three, the form is nonalternating and its +four vectors with nonzero self-pairing give the four nondegenerate planes +by taking perpendicular complements. For an adjacent pair, the sum +is a nondegenerate four-dimensional space, whose perpendicular complement +is one nondegenerate plane; the two diagonal positions add two more +overlaps. The finite census directly verifies the needed bound, so the +exclusion does not depend on a classification proof for these restrictions. + +## The bounded-overlap fitting-rank lemma + +Suppose a simple undirected graph has closed row-support intersections of +size at most `mu>=1` for distinct vertices. Every complex fitting matrix `M` +with nonzero diagonal and off-diagonal support contained in its edges has + +``` +rank_C(M) > V/(mu+1). +``` + +This is the matrix-scaling proof in [the field-line audit](README.md), +with its overlap constant three replaced by `mu`. In detail, decompose the +directed nonzero support into strongly connected components. Each diagonal +block has total support, since every internal edge belongs to a directed +cycle and the remaining diagonal entries complete a permutation. The full +rank is at least the sum of the block ranks. + +For a block of size `v`, apply the Sinkhorn–Knopp total-support theorem to +the squared moduli, then square-root its positive scalings. This produces +a same-rank matrix `B` whose rows and columns have squared norm one. For +`A=B B*`, the overlap bound and Cauchy–Schwarz give + +``` +tr(A)=v, +tr(A^2) <= v + mu*(v-sum_ij |B_ij|^4) < (mu+1)*v. +``` + +Spectral Cauchy–Schwarz yields `rank(A)>=v^2/tr(A^2)>v/(mu+1)`. +Summing the block bounds proves the assertion, including asymmetric and +arbitrary complex fitting coefficients. The primary scaling theorem and +the source of this rank method are cited and pinned in the parent package; +this is a specialization of the same proof, not a new optimality claim. + +For the exact masks here, `mu=4`, hence every induced fitting has rank +strictly greater than `V/5`. + +## The scalar-query invoice and target gate + +Require the scalar fitting decoder to have diagonal one and permit +off-diagonal entries only at full-orthogonality edges. Express it as +`M=sum_l f_l*g_l^T`. Price each query separately by the binary pairing rank +between the complete sums of reader and source port spaces in its supports. + +A zero-tariff term has entries only at free positions and no diagonal, +because each port is nondegenerate. Deleting all such terms preserves the +fitting conditions. If `L` positive-tariff terms remain, rank subadditivity +and the preceding lemma imply `L>V/5`. Each tariff is a positive integer, +so its lower bound is **one**, not the port rank two. + +For `h=6,k=2`, the three-stage window has `m=14`, `W=2V`, and `6V` separate +public children of rank four. Its ideal data-only moment is +`3*(2/7)^(8/9)<1`. With three decoder invocations, even granting every +positive query rank one and every other expense free gives + +``` +M(1/9) > 3*(2/7)^(8/9) + (3/10)*(1/14)^(8/9) + = 1.013886814008956200... > 1. +``` + +Splitting a query's tariff into smaller children with the same total rank +cannot reduce this moment, by concavity. Combining independent queries or +public climbs into a new primitive changes the model. The conclusion is +only for the separate-query and separate-public-leg contract just stated. + +Under the additional compressed-window coverage hypotheses of +[the bit target proof](../kappa01-bit-repair/PROOF.md), every odd stage count +at least five already fails at `h/k=3` using the data alone. Together, these +results exclude every allowed odd stage in that same model. Failure at +`a=1/9` suffices, since strict κ = 0.1 outer transfer needs `a>1/9`. + +## Replay + +```sh +python3 -I -O -B research/kappa01-fieldline-repair/planes6.py +``` + +`PLANES6-RESULT.json` retains both exact plane lists, adjacency masks, +intersection histograms, source pins, and rational target enclosures. +The verifier checks an attaining four-column overlap and rejects applying +the lemma with `mu=4` to `K5`, whose all-ones fitting has rank one. Exact +Gaussian-rational fixtures include asymmetric phases. No numerical spectral +calculation, optimizer, or minimum-rank enumeration is used for acceptance. diff --git a/research/kappa01-fieldline-repair/README.md b/research/kappa01-fieldline-repair/README.md new file mode 100644 index 0000000000..b0a2e082cc --- /dev/null +++ b/research/kappa01-fieldline-repair/README.md @@ -0,0 +1,244 @@ +# The C4-free fitting-rank gate for the field-line repair + +**The proposed `F_(2^k)^3` line family cannot reach κ = 0.1 through its scalar +one-array-per-query decoder contract.** A source-derived rank argument gives +more than `V/4` paid scalar queries, each of native rank at least `k`. With +three stages this forces target moment greater than + +``` +3*(2/7)^(8/9) + (3/8)*(1/7)^(8/9) + = 1.051658213344872... > 1. +``` + +This applies to every `q=2^k`, including large fields not excluded by a +particular independent-set bound. It does not exclude matrix-valued payload +coding, a multi-array native primitive, changed endpoint masks, fused public +data legs, another coverage law, or another multiplication framework. + +## 1. The geometric family and its exact permission graph + +Let `F=GF(q)`, `q=2^k`, with the symmetric nondegenerate bilinear form + +``` +B((z,x,y),(z',x',y')) = z*z' + x*y' + y*x' +``` + +on `F^3`. For each `a=(x,y)` in `F^2`, define the `F`-line +`E_a = F*(1,x,y)`. Regard it as a binary subspace of dimension `k` under +the trace form `Tr_(F/F2) B`; the ambient binary dimension is `h=3k`. +Each `E_a` is nondegenerate because its restricted form is `Tr(s*t)`. +There are `V=q^2` such ports, with + +``` +E_a orthogonal to E_b iff det(a,b)=1. +``` + +This defines a simple undirected graph `G` on `F^2`: the determinant is +symmetric in characteristic two and `det(a,a)=0`. The zero vector is +isolated. Two distinct vertices have at most one common neighbor. If they +are linearly independent, the equations `det(a,c)=det(b,c)=1` have one +solution. If `b=t*a` with `t!=1`, they have none; zero vertices have none. +Thus `G` has no four-cycle, even as a non-induced subgraph. + +The [finite field reconstruction](../kappa01-repair/field_geometry.py) and +its receipt check representative fields, trace pairing ranks and exact +coclique controls. The argument here covers all field sizes algebraically. + +## 2. A rank bound for arbitrary complex fitting matrices + +**Lemma.** Let `G` be any simple undirected C4-free graph on `n>0` vertices. +Every complex matrix `M` with nonzero diagonal and `M_ij=0` whenever distinct +`i,j` are nonadjacent has + +``` +rank_C(M) > n/4. +``` + +No symmetry, positivity, integrality, normality or common eigenbasis of `M` +is assumed. Allowed off-diagonal entries may vanish or have arbitrary +complex values. + +The proof uses the matrix-scaling method of Codenotti, Pudlak and Resta, +*Some structural properties of low rank matrices related to computational +complexity*, revised ECCC TR97-043 (1998), Section 4, particularly Lemma 11 +and Corollary 13, pages 10. Their real-matrix consequence is rank greater +than `n/6` for this mask; Haviv's *On Minrank and Forbidden Subgraphs* +(APPROX/RANDOM 2018), Section 1.2, explicitly records it. The argument below +specializes their method to undirected masks using a three-column overlap +bound. No claim of novelty or optimality is made. + +**Reduction to total support.** Make the directed support graph of `M`, +with arc `i -> j` when `M_ij!=0`. Simultaneously permuting rows and columns +by strongly connected components makes `M` block triangular. Each diagonal +block has total support: every nonzero off-diagonal entry belongs to a +directed cycle, which extends to a nonzero permutation diagonal by fixing +all other vertices. Diagonal entries already have that property. For such +blocks, the rank of the full matrix is at least the sum of their ranks, +as seen by combining nonsingular minors into a block triangular minor. +It therefore suffices to treat a block with total support. + +**Scaling.** Apply positive row and column scaling to `|M_ij|^2`. The +total-support scaling theorem of Sinkhorn and Knopp (1967, pages 343--346) +gives diagonal scalings making this matrix +doubly stochastic. Taking square roots of those scalings gives a matrix +`B` with the same complex rank and support as `M`, and + +``` +sum_j |B_ij|^2 = 1, sum_i |B_ij|^2 = 1. +``` + +This is the complex version of the scaling step in CPR Lemma 11; it uses +the same nonnegative scaling theorem on squared moduli. The scalings may +be real rather than rational, which is harmless for a complex-rank bound. + +**Overlap and trace.** Write `A=B B*`, which is positive semidefinite and +has `tr(A)=n`. The supports of two distinct rows `i,j` of `B` have at most +three common columns: possibly `i` and `j`, and at most one common graph +neighbor. Cauchy--Schwarz therefore gives + +``` +|A_ij|^2 <= 3 * sum_t |B_it|^2 |B_jt|^2, i!=j. +``` + +Put `S4=sum_it |B_it|^4>0`. The doubly stochastic identities yield + +``` +tr(A^2) = sum_ij |A_ij|^2 + <= n + 3*sum_t[(sum_i |B_it|^2)^2 - sum_i |B_it|^4] + = 4n - 3S4 < 4n. +``` + +The spectral Cauchy--Schwarz inequality for the positive semidefinite `A` +gives `rank(A) >= tr(A)^2/tr(A^2) > n/4`. Also `rank(A)=rank(B)`. +Applying this bound to every total-support diagonal block proves the lemma. + +A conservative alternative, requiring only the published real rank bound, +already suffices below: normalize the diagonal of a complex fitting matrix +to one and take its real part. This remains a real fitting matrix and has +real rank at most twice the original complex rank. Thus CPR's bound implies +`rank_C(M)>n/12`, without using the stronger overlap calculation. + +## 3. Turning query rank into native cost + +Fix the scalar decoder contract: a fitting matrix is a sum of outer +products `M=sum_l u_l v_l^T` over `Q(i)` (or `C`). Its diagonal is one and +its other forced entries vanish; free entries are exactly the graph edges +above. Each term is one scalar total carried by one native array. Its tariff +is the binary pairing rank between the complete sums of source port spaces +and reader port spaces in that term's supports. + +Each support span is an `F`-linear subspace of `F^3`. For any two such spans +`U,T`, + +``` +rank_F2(Tr B restricted to U x T) = k * rank_F(B restricted to U x T). +``` + +Indeed the trace-annihilator of `T` in `U` is exactly its `B`-annihilator: +if `B(u,t)` is nonzero for some `t`, varying `t` through its scalar +multiples makes `Tr B(u,t)` nonzero somewhere, by nondegeneracy of the +finite-field trace pairing. Both kernels are the same `F`-subspace, so +converting dimensions to binary dimensions multiplies rank by `k`. +Every nonzero tariff is consequently at least `k`. + +If a term has tariff zero, every source line in its support is orthogonal +to every reader line in its support. Such a term has entries only in free +positions and has zero diagonal, since each `E_a` is nondegenerate. Remove +all zero-tariff terms. The remaining sum is still a fitting matrix. +With `L` paid scalar terms its rank is at most `L`, so Section 2 gives + +``` +L > V/4, total copy rank C >= kL > Vk/4. +``` + +This argument allows arbitrary cancellations among paid terms and arbitrary +complex scalar weights. It does not sum separate per-plane decoder floors. +Its limit is the explicitly stated scalar-total and complete-support tariff. + +## 4. The strict target gate + +For the candidate three-stage compressed window, `h=3k`, `m=7k` and +`W=2V`. Keeping its separate public data legs forces `6V` rank-`2k` +children, giving normalized data moment + +``` +D = 3*(2/7)^(8/9) = 0.985156473147628... . +``` + +There are three invocations of the paid decoder. Each of its `L>V/4` +terms costs at least one rank-`k` child. Since `x^(8/9)` is increasing, + +``` +M(1/9) >= D + (3L/(2V))*(1/7)^(8/9) + > D + (3/8)*(1/7)^(8/9) + = 1.051658213344872... > 1. +``` + +The conclusion does not need a maximum copy rank. If a descent is split +into smaller children with the same or greater total rank, concavity only +increases its moment. It does require separate scalar-query lifetimes; +a new fused primitive serving several independent totals changes that +contract and needs its own invoice. + +The mass-only relaxation also fails: granting every copy-rank unit the +maximum local rank `h` gives + +``` +M(1/9) > D + (1/8)*(3/7)^(8/9) + = 1.044016375488343... > 1. +``` + +Even the conservative published-real-theorem route `L>V/12` gives a +count-based lower bound `1.007323719880043...` and a mass-only bound +`1.004776440594533...`, both above one. These checks show that closing the +candidate does not depend on the improvement from twelve to four. + +Under the retained strict outer transfer, κ = 0.1 needs primitive saving +strictly above `1/9`. Failure already at that boundary is decisive for the +stated scalar-decoder family. All other helper, tape, precision, phase, +frame, routing and restoration costs were granted free in these bounds. + +## Replay and controls + +``` +python3 -I -B research/kappa01-fieldline-repair/verify.py +``` + +`RESULT.json` contains outward rational gate intervals. The verifier checks +exact Gaussian-rational matrix fixtures for the overlap/trace bound, +including nonsymmetric phases, the rank-one triangle attainer, and a K4 +control which violates the C4-free hypothesis and defeats the claimed +bound. It checks a reducible support block, exclusive receipt output, and +the contrast between the passing data-only relaxation and each failing +fully charged lower bound. These finite controls corroborate the formulas; +the all-size result rests on the proof and the cited total-support scaling +theorem, not exhaustive fitting-matrix enumeration. + +External references and hashes of the source PDF inspected in this session +are in `SOURCES.json`. The original PDF's text encoding was unreadable, so +the relevant pages were rendered and visually inspected. No paper or +production supplier is altered. No selected result is changed, and no new +κ or complete supplier is claimed. + +## Sources, attribution and next question + +- Codenotti, Pudlak and Resta, revised ECCC TR97-043 (1998), Section 4: + . +- Haviv, *On Minrank and Forbidden Subgraphs* (2018), Section 1.2: + . +- Sinkhorn and Knopp, *Concerning nonnegative matrices and doubly stochastic + matrices*, Pacific Journal of Mathematics 21 (1967), 343--348: + . +- The geometric construction and finite trace/coclique checks are in + [the local field repair](../kappa01-repair/field_geometry.py); the related + compressed-window pressure accounting is credited in + [the bit repair analysis](../kappa01-bit-repair/PROOF.md). + +The remaining repair question is precise: can an operator-valued decoder or +a genuinely joint native consumer break the scalar-query rank tariff while +preserving arbitrary payloads, all dirty inputs and the complete endpoint? +The scalar fitting-matrix family analyzed here cannot supply the target. + +Prepared with substantial OpenAI Codex assistance and a separate AI review +of the core argument. No independent human or formal-kernel verification is +claimed. New material is Apache-2.0; external sources retain their rights. diff --git a/research/kappa01-fieldline-repair/RESULT.json b/research/kappa01-fieldline-repair/RESULT.json new file mode 100644 index 0000000000..54ee041d5e --- /dev/null +++ b/research/kappa01-fieldline-repair/RESULT.json @@ -0,0 +1,81 @@ +{ + "complex_fitting_rank_bound": "rank_C M > n/4 for undirected C4-free masks", + "controls": { + "K4_hypothesis_violation_rejected": true, + "K4_rank_conclusion_fails": true, + "asymmetric_complex_allowed": true, + "conservative_published_theorem_alone_suffices": true, + "data_only_relaxation_passes": true, + "reducible_support_allowed": true + }, + "data_only_moment": { + "lower": "4925782365738143795749247058124475064969/5000000000000000000000000000000000000000", + "lower_decimal": "0.985156473147628759", + "upper": "9851564731476287591498494116248950129941/10000000000000000000000000000000000000000", + "upper_decimal": "0.985156473147628759" + }, + "exact_matrix_fixtures": [ + { + "gram_trace_square": "9", + "name": "rank_one_triangle", + "rank": 1, + "size": 3, + "squared_modulus_fourth_sum": "1", + "trace_upper_bound": "9" + }, + { + "gram_trace_square": "913/125", + "name": "asymmetric_complex_cycle", + "rank": 5, + "size": 5, + "squared_modulus_fourth_sum": "337/125", + "trace_upper_bound": "1489/125" + }, + { + "gram_trace_square": "18", + "name": "two_triangle_blocks", + "rank": 2, + "size": 6, + "squared_modulus_fourth_sum": "2", + "trace_upper_bound": "18" + } + ], + "independent_rational_count_gate": "8397/8000", + "necessary_moment_lower_bounds": { + "complex_n_over_4_mass_only": { + "lower": "83521310039067455755402736986255338235649/80000000000000000000000000000000000000000", + "lower_decimal": "1.044016375488343196", + "upper": "41760655019533727877701368493127669117837/40000000000000000000000000000000000000000", + "upper_decimal": "1.044016375488343196" + }, + "complex_n_over_4_query_count": { + "lower": "84132657067589766493030637464113430852221/80000000000000000000000000000000000000000", + "lower_decimal": "1.051658213344872081", + "upper": "10516582133448720811628829683014178856531/10000000000000000000000000000000000000000", + "upper_decimal": "1.051658213344872081" + }, + "published_real_n_over_6_via_complex_n_over_12_mass_only": { + "lower": "241146345742688057219378642846238540314657/240000000000000000000000000000000000000000", + "lower_decimal": "1.004776440594533571", + "upper": "8038211524756268573979288094874618010491/8000000000000000000000000000000000000000", + "upper_decimal": "1.004776440594533571" + }, + "published_real_n_over_6_via_complex_n_over_12_query_count": { + "lower": "80585897590403455985668847774698877643743/80000000000000000000000000000000000000000", + "lower_decimal": "1.007323719880043199", + "upper": "10073237198800431998208605971837359705471/10000000000000000000000000000000000000000", + "upper_decimal": "1.007323719880043199" + } + }, + "proof_dependencies": [ + "positive diagonal scaling for nonnegative total-support matrices (Sinkhorn-Knopp)", + "spectral and scalar Cauchy-Schwarz", + "finite-field trace pairing nondegeneracy" + ], + "scalar_total_query_bound": "paid_queries > V/4; each nonzero complete-support tariff >= k", + "scope": "Scalar outer-product totals, complete plane-support tariff and separate public data legs; no universal supplier or kappa theorem.", + "source_base": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "status": "PASS_KAPPA01_FIELDLINE_SCALAR_DECODER_OBSTRUCTION", + "target_kappa": "1/10", + "target_primitive_saving": "1/9" +} diff --git a/research/kappa01-fieldline-repair/SOURCES.json b/research/kappa01-fieldline-repair/SOURCES.json new file mode 100644 index 0000000000..430fc78a31 --- /dev/null +++ b/research/kappa01-fieldline-repair/SOURCES.json @@ -0,0 +1,40 @@ +{ + "base": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "local_files": [ + { + "path": "research/kappa01-repair/field_geometry.py", + "sha256": "0610fc42073d1e03ddd39e51eb54d52a75ac2fe8a56bf2c20252102f6dced97c" + }, + { + "path": "research/kappa01-repair/FIELD-RESULT.json", + "sha256": "84fd00e79089f396c21891f657adaad6f23adf30276e450f87bd8b02f4c47b96" + } + ], + "external_sources": [ + { + "authors": "Codenotti, Pudlak, Resta", + "title": "Some structural properties of low rank matrices related to computational complexity", + "edition": "ECCC TR97-043 Revision 1, August 1998", + "url": "https://eccc.weizmann.ac.il/report/1997/043/revision/1/download", + "sha256_of_download_inspected": "32a1826e5d0c61d8b443feace9408de621ab6dced0a7faf56967d0b70795e356", + "relevant_pages": "6,8,9,10", + "verification": "Relevant pages rendered and visually inspected; Corollary 13 is stated for nonsymmetric matrices with support." + }, + { + "authors": "Ishay Haviv", + "title": "On Minrank and Forbidden Subgraphs", + "edition": "APPROX/RANDOM 2018", + "url": "https://drops.dagstuhl.de/storage/00lipics/lipics-vol116-approx-random2018/LIPIcs.APPROX-RANDOM.2018.42/LIPIcs.APPROX-RANDOM.2018.42.pdf", + "relevant_section": "1.2, The Odd Alternating Cycle Conjecture; real C4-free bound n/6 recorded explicitly." + }, + { + "authors": "Richard Sinkhorn and Paul Knopp", + "title": "Concerning nonnegative matrices and doubly stochastic matrices", + "edition": "Pacific Journal of Mathematics 21 (1967), 343-348", + "doi": "10.2140/pjm.1967.21.343", + "url": "https://msp.org/pjm/1967/21-2/pjm-v21-n2-p14-p.pdf", + "relevant_statement": "A nonnegative square matrix has a positive diagonal scaling to a doubly stochastic matrix iff it has total support." + } + ], + "dependency_scope": "External theorems are proof dependencies, not re-proved by finite replay. No network is needed for replay." +} diff --git a/research/kappa01-fieldline-repair/planes6.py b/research/kappa01-fieldline-repair/planes6.py new file mode 100644 index 0000000000..1c6451d676 --- /dev/null +++ b/research/kappa01-fieldline-repair/planes6.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact overlap gate for distinct nondegenerate binary planes in dimension six.""" +from __future__ import annotations + +from collections import Counter +from fractions import Fraction as Q +import hashlib +import importlib.util +from itertools import combinations +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(ok, what): + if not ok: + raise ValueError(what) + + +def geometry(name, rows): + def pairing(a, b): + out = sum(((row & b).bit_count() & 1) << i for i, row in enumerate(rows)) + return (a & out).bit_count() & 1 + + require(len(rows) == 6, "six-dimensional form") + require(all(pairing(1 << i, 1 << j) == pairing(1 << j, 1 << i) + for i in range(6) for j in range(6)), "symmetric form") + require(all(any(pairing(a, 1 << i) for i in range(6)) for a in range(1, 64)), + "nondegenerate ambient form") + planes = sorted({tuple(sorted((a, b, a ^ b))) + for a, b in combinations(range(1, 64), 2) + if (pairing(a, a)*pairing(b, b)) ^ pairing(a, b)}) + require(len(planes) == 336, "exact nondegenerate plane count") + for plane in planes: + require(plane[0] ^ plane[1] ^ plane[2] == 0, "closed binary plane") + require(all((pairing(a, a)*pairing(b, b)) ^ pairing(a, b) + for a, b in combinations(plane, 2)), "every plane basis nondegenerate") + adjacency = [sum(1 << j for j, V in enumerate(planes) + if all(pairing(a, b) == 0 for a in U for b in V)) for U in planes] + require(all(x.bit_count() == 20 for x in adjacency), "degree twenty") + require(all(not (adjacency[i] >> i & 1) for i in range(336)), "zero diagonal") + require(all((adjacency[i] >> j & 1) == (adjacency[j] >> i & 1) + for i in range(336) for j in range(i)), "undirected permission mask") + closed = [mask | (1 << i) for i, mask in enumerate(adjacency)] + overlaps, adjacent_overlaps = Counter(), Counter() + witness = None + for i in range(336): + for j in range(i): + overlap = (closed[i] & closed[j]).bit_count() + overlaps[overlap] += 1 + if adjacency[i] >> j & 1: + adjacent_overlaps[overlap] += 1 + if overlap == 4 and witness is None: + witness = [i, j] + require(overlaps == Counter({0:15120, 1:30240, 3:3360, 4:7560}), "closed-overlap census") + require(adjacent_overlaps == Counter({3:3360}), "adjacent overlap census") + require(sum(overlaps.values()) == 336*335//2, "complete pair census") + require(witness is not None and max(overlaps) == 4, "attaining overlap bound") + return dict(form=name, matrix_rows=rows, planes=planes, adjacency_bitmasks=adjacency, + vertices=336, degree=20, edges=3360, + closed_row_overlap_counts=dict(sorted(overlaps.items())), + adjacent_overlap_counts=dict(sorted(adjacent_overlaps.items())), + overlap_four_witness=witness) + + +def trace_fixture(exact, name, A, rho, mu): + n = len(A) + require(mu > 0, "positive overlap cap") + require(all(A[i][i] != exact.ZERO for i in range(n)), "nonzero fixture diagonal") + supports = [{j for j, x in enumerate(row) if x != exact.ZERO} for row in A] + require(all(len(supports[i] & supports[j]) <= mu for i in range(n) for j in range(i)), + "fixture overlap hypothesis") + require(all(sum(exact.norm(x) for x in row) == rho for row in A), "fixture row norms") + require(all(sum(exact.norm(A[i][j]) for i in range(n)) == rho for j in range(n)), + "fixture column norms") + gram = [] + for i in range(n): + row = [] + for j in range(n): + value = exact.ZERO + for t in range(n): + value = exact.add(value, exact.mul(A[i][t], exact.conjugate(A[j][t]))) + row.append((value[0]/rho, value[1]/rho)) + gram.append(row) + trace_square = sum(exact.norm(x) for row in gram for x in row) + fourth = sum(exact.norm(x)**2 for row in A for x in row)/rho**2 + require(trace_square <= (mu+1)*n-mu*fourth < (mu+1)*n, "strict overlap trace gate") + rank = exact.rank_gaussian(A) + require(rank >= Q(n*n)/trace_square > Q(n, mu+1), "fixture fitting rank") + return dict(name=name, order=n, rank=rank, overlap_cap=mu, + gram_trace_square=str(trace_square), fourth_sum=str(fourth)) + + +def main(): + manifest = json.loads((HERE / "PLANES6-SOURCES.json").read_text()) + for source in manifest["local_files"]: + require(hashlib.sha256((ROOT / source["path"]).read_bytes()).hexdigest() == source["sha256"], + "pinned proof or exact arithmetic dependency") + spec = importlib.util.spec_from_file_location("fieldline_exact", HERE / "verify.py") + exact = importlib.util.module_from_spec(spec) + spec.loader.exec_module(exact) + geometries = [geometry("standard_dot", [1, 2, 4, 8, 16, 32]), + geometry("alternating_H_plus_H_plus_H", [2, 1, 8, 4, 32, 16])] + fixtures = [trace_fixture(exact, "rank_one_K4", [[exact.ONE]*4 for _ in range(4)], Q(4), 4)] + phased = [[exact.ZERO for _ in range(5)] for _ in range(5)] + for i in range(5): + phased[i][i] = (Q(3, 5), Q(0)) + phased[i][(i+1) % 5] = (Q(0), Q(4, 5)) + fixtures.append(trace_fixture(exact, "asymmetric_complex_cycle", phased, Q(1), 4)) + rejected = False + try: + trace_fixture(exact, "invalid_K5", [[exact.ONE]*5 for _ in range(5)], Q(5), 4) + except ValueError as err: + require(str(err) == "fixture overlap hypothesis", "K5 rejects at the intended hypothesis") + rejected = True + require(rejected, "invalid overlap-cap negative control") + data = tuple(3*x for x in exact.power89(Q(2, 7))) + unit = exact.power89(Q(1, 14)) + floor = exact.combine(data, Q(3, 10), unit) + conservative = exact.combine(data, Q(3, 14), unit) + require(data[1] < 1 < floor[0], "data-only passes but complete query floor fails") + require(conservative[0] > 1, "even a weaker V/7 rank bound would suffice") + result = dict(status="DISTINCT_BINARY_PLANES6_SCALAR_QUERY_TARGET_OBSTRUCTION", + source_manifest=manifest, + geometries=geometries, trace_fixtures=fixtures, + strict_complex_fitting_rank_ratio="1/5", positive_query_minimum_rank=1, + h=6, k=2, m=14, stage_count=3, + data_only_moment=exact.interval_record(data), + strict_target_floor=exact.interval_record(floor), + weaker_V_over_7_control_floor=exact.interval_record(conservative), + controls=["reject_K5_for_overlap_cap4", "do_not_price_every_query_rank2", + "data_only_pass_does_not_admit_query_decoder"], + scope="distinct ports or induced subsets; scalar query factors; complete support pairing tariff; separate public legs") + encoded = json.dumps(result, indent=2, sort_keys=True)+"\n" + out = HERE / "PLANES6-RESULT.json" + if out.exists(): + require(out.read_text() == encoded, "existing plane receipt differs; inspect before replacing") + else: + with out.open("x") as handle: + handle.write(encoded) + print("PASS_KAPPA01_PLANES6 forms=2 planes_each=336 max_closed_overlap=4 moment>" + +exact.show(floor[0])+" distinct_ports_scalar_contract_only") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-fieldline-repair/verify.py b/research/kappa01-fieldline-repair/verify.py new file mode 100644 index 0000000000..50a5a89ed5 --- /dev/null +++ b/research/kappa01-fieldline-repair/verify.py @@ -0,0 +1,227 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact controls for the source-derived C4-free field-line decoder bound.""" +from __future__ import annotations + +import argparse +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +SCALE = 10**40 +ZERO = (Q(0), Q(0)) +ONE = (Q(1), Q(0)) + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def neg(a): + return -a[0], -a[1] + + +def mul(a, b): + return a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0] + + +def conjugate(a): + return a[0], -a[1] + + +def norm(a): + return a[0]**2+a[1]**2 + + +def divide(a, b): + t = mul(a, conjugate(b)) + q = norm(b) + require(q > 0, "nonzero Gaussian divisor") + return t[0]/q, t[1]/q + + +def rank_gaussian(A): + rows = [list(row) for row in A] + pivot = 0 + for col in range(len(rows[0])): + index = next((i for i in range(pivot, len(rows)) if rows[i][col] != ZERO), None) + if index is None: + continue + rows[pivot], rows[index] = rows[index], rows[pivot] + p = rows[pivot][col] + rows[pivot] = [divide(x, p) for x in rows[pivot]] + for i in range(len(rows)): + if i != pivot and rows[i][col] != ZERO: + c = rows[i][col] + rows[i] = [add(x, neg(mul(c, y))) for x, y in zip(rows[i], rows[pivot])] + pivot += 1 + if pivot == len(rows): + break + return pivot + + +def graph_from_support(A): + n = len(A) + require(all(A[i][i] != ZERO for i in range(n)), "nonzero fitting diagonal") + return [{j for j in range(n) if j != i and (A[i][j] != ZERO or A[j][i] != ZERO)} + for i in range(n)] + + +def c4_free(graph): + return all(len(graph[i] & graph[j]) <= 1 + for i in range(len(graph)) for j in range(i)) + + +def trace_fixture(name, A, rho): + """B=A/sqrt(rho), evaluated without introducing irrational coefficients.""" + n = len(A) + graph = graph_from_support(A) + require(c4_free(graph), "C4-free fixture required") + require(all(sum(norm(x) for x in row) == rho for row in A), "scaled row norms") + require(all(sum(norm(A[i][j]) for i in range(n)) == rho for j in range(n)), "scaled column norms") + supports = [{j for j, x in enumerate(row) if x != ZERO} for row in A] + require(all(len(supports[i] & supports[j]) <= 3 + for i in range(n) for j in range(i)), "three-column overlap") + C = [] + for i in range(n): + row = [] + for j in range(n): + value = ZERO + for k in range(n): + value = add(value, mul(A[i][k], conjugate(A[j][k]))) + row.append((value[0]/rho, value[1]/rho)) + C.append(row) + require(sum(C[i][i][0] for i in range(n)) == n + and all(C[i][i][1] == 0 for i in range(n)), "trace n") + frobenius = sum(norm(x) for row in C for x in row) + fourth = sum(norm(x)**2 for row in A for x in row)/rho**2 + require(frobenius <= 4*n-3*fourth < 4*n, "strict trace inequality") + rank = rank_gaussian(A) + require(rank == rank_gaussian(C), "Gram rank") + require(rank >= Q(n*n)/frobenius > Q(n, 4), "rank consequence") + return dict(name=name, size=n, rank=rank, squared_modulus_fourth_sum=str(fourth), + gram_trace_square=str(frobenius), trace_upper_bound=str(4*n-3*fourth)) + + +def matrix_controls(): + tri = [[ONE for _ in range(3)] for _ in range(3)] + fixtures = [trace_fixture("rank_one_triangle", tri, Q(3))] + directed = [[ZERO for _ in range(5)] for _ in range(5)] + for i in range(5): + directed[i][i] = (Q(3, 5), Q(0)) + directed[i][(i+1) % 5] = (Q(0), Q(4, 5)) + fixtures.append(trace_fixture("asymmetric_complex_cycle", directed, Q(1))) + double = [[ONE if i//3 == j//3 else ZERO for j in range(6)] for i in range(6)] + fixtures.append(trace_fixture("two_triangle_blocks", double, Q(3))) + + # Reducible support: three singleton SCC blocks, positive off-diagonal + # edges that cannot belong to any full permutation diagonal. + triangular = [[ONE, ONE, ZERO], [ZERO, ONE, ONE], [ZERO, ZERO, ONE]] + require(c4_free(graph_from_support(triangular)), "reducible support graph") + require(rank_gaussian(triangular) >= sum(rank_gaussian([[triangular[i][i]]]) for i in range(3)), + "block triangular rank inequality") + + # Removing the graph hypothesis really breaks the alleged n/4 bound. + K4 = [[ONE for _ in range(4)] for _ in range(4)] + require(not c4_free(graph_from_support(K4)), "K4 hypothesis control") + require(rank_gaussian(K4) == Q(len(K4), 4), "K4 defeats strict n/4 conclusion") + rejected = False + try: + trace_fixture("invalid_K4", K4, Q(4)) + except ValueError: + rejected = True + require(rejected, "invalid C4 fixture accepted") + return fixtures + + +def power89(x): + a, b = x.numerator**8*SCALE**9, x.denominator**8 + lo, hi = 0, 1 + while hi**9*b <= a: + hi *= 2 + while hi-lo > 1: + mid = (lo+hi)//2 + if mid**9*b <= a: + lo = mid + else: + hi = mid + require(lo**9*b <= a < hi**9*b, "outward ninth-root witnesses") + return Q(lo, SCALE), Q(hi, SCALE) + + +def combine(x, multiplier, y): + return x[0]+multiplier*y[0], x[1]+multiplier*y[1] + + +def show(value): + n = value.numerator*10**18//value.denominator + return f"{n//10**18}.{n%10**18:018d}" + + +def interval_record(x): + return dict(lower=str(x[0]), upper=str(x[1]), lower_decimal=show(x[0]), upper_decimal=show(x[1])) + + +def build(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + for source in manifest["local_files"]: + require(hashlib.sha256((ROOT/source["path"]).read_bytes()).hexdigest() == source["sha256"], + "source hash: "+source["path"]) + data = tuple(3*x for x in power89(Q(2, 7))) + min_child, max_child = power89(Q(1, 7)), power89(Q(3, 7)) + gates = { + "complex_n_over_4_query_count": combine(data, Q(3, 8), min_child), + "complex_n_over_4_mass_only": combine(data, Q(1, 8), max_child), + "published_real_n_over_6_via_complex_n_over_12_query_count": combine(data, Q(1, 8), min_child), + "published_real_n_over_6_via_complex_n_over_12_mass_only": combine(data, Q(1, 24), max_child), + } + require(data[1] < 1, "data-only relaxation passes") + require(all(bounds[0] > 1 for bounds in gates.values()), "each fully charged gate fails") + # Simple rational corroboration of the stronger count gate. + require(Q(41, 125)**9 < Q(2, 7)**8, "data rational lower bound") + require(Q(7, 40)**9 < Q(1, 7)**8, "copy rational lower bound") + rational_gate = 3*Q(41, 125)+Q(3, 8)*Q(7, 40) + require(rational_gate > 1, "independent rational gate") + return dict( + status="PASS_KAPPA01_FIELDLINE_SCALAR_DECODER_OBSTRUCTION", + source_base=manifest["base"], + target_primitive_saving="1/9", target_kappa="1/10", + complex_fitting_rank_bound="rank_C M > n/4 for undirected C4-free masks", + scalar_total_query_bound="paid_queries > V/4; each nonzero complete-support tariff >= k", + data_only_moment=interval_record(data), + necessary_moment_lower_bounds={key: interval_record(value) for key,value in gates.items()}, + independent_rational_count_gate=str(rational_gate), + exact_matrix_fixtures=matrix_controls(), + controls={"asymmetric_complex_allowed":True, "reducible_support_allowed":True, + "K4_hypothesis_violation_rejected":True, "K4_rank_conclusion_fails":True, + "data_only_relaxation_passes":True, "conservative_published_theorem_alone_suffices":True}, + proof_dependencies=["positive diagonal scaling for nonnegative total-support matrices (Sinkhorn-Knopp)", + "spectral and scalar Cauchy-Schwarz", "finite-field trace pairing nondegeneracy"], + scope="Scalar outer-product totals, complete plane-support tariff and separate public data legs; no universal supplier or kappa theorem." + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = build() + if args.output: + with args.output.open("x") as output: + output.write(json.dumps(result, indent=2, sort_keys=True)+"\n") + else: + require(result == json.loads((HERE / "RESULT.json").read_text()), "receipt mismatch") + print(result["status"], "moment>" + result["necessary_moment_lower_bounds"]["complex_n_over_4_query_count"]["lower_decimal"], + "scalar_contract_only") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-haemers-repair/README.md b/research/kappa01-haemers-repair/README.md new file mode 100644 index 0000000000..b70a152cde --- /dev/null +++ b/research/kappa01-haemers-repair/README.md @@ -0,0 +1,131 @@ +# A concrete cross-characteristic decoder, and its density limit + +The fractional-Haemers literature does not, by itself, repair the target. +The following explicit construction does produce a scalar decoder with a +small, fully priced copy ratio. Its binary geometry has insufficient label +density, and the same graph cannot acquire a dense block representation. +This is a completed local construction and rejection, not a supplier or a +claim that all cross-characteristic constructions fail. + +## Primary-source route + +[Bukh and Cox, *On a fractional version of Haemers' bound*, arXiv:1802.00476v2](https://arxiv.org/pdf/1802.00476), +Section 2, defines block representations with identity diagonal blocks and +prescribed zero blocks. Proposition 5 equivalently uses pairs of matrices +`A_v,B_v` with `A_v^T B_v=I`; these need not be a common symmetric Gram +representation. Their Section 4 constructs characteristic separations. +For characteristic two, the three-subset graph in Lemma 12 and Proposition +17 is particularly explicit. For `4|n`, Lemma 12 gives fractional binary +Haemers bound exactly `n`. The strong-product multiplicativity theorem does +not reduce this parameter. The general separation theorem also does not +assert constant binary fractional rank or provide native query tariffs. + +The calculation below specializes that three-subset construction and prices +its actual scalar factorization. The tariff and target test are additional +calculations for the repository's complete-support pairing model. + +## Geometry and an explicit Gaussian-dyadic decoder + +Let `n>=4` be divisible by four. For each three-subset `X` of `[n]`, take +the binary line generated by its incidence vector `v_X`. Then + +``` +h=n, k=1, V=binomial(n,3). +``` + +Every line is nondegenerate since its self-pairing is `3 mod 2 = 1`. +For distinct labels, their binary pairing is nonzero exactly when +`|X intersect Y|=1`. Thus the permitted scalar fitting entries are the +pairs with intersection size zero or two. Define the rational matrix + +``` +M_XY = (|X intersect Y|-1)/2. +``` + +It has diagonal one and vanishes at every forbidden off-diagonal entry. +Writing `a_i(X)=1[i in X]` gives the concrete scalar-query decomposition + +``` +M = (1/2)*sum_(i=1)^n a_i*a_i^T - (1/2)*1*1^T. +``` + +These are `n+1` actual outer products with Gaussian-dyadic coefficients; +there is no inference from low matrix rank to low native cost. + +For the query indexed by `i`, the complete source and reader spans coincide +with + +``` +U_i = span(e_i) direct-sum {x on [n]\{i}: sum_j x_j=0}. +``` + +To see the equality, three triples containing `i` and using a triangle on +three other coordinates sum to `e_i`; their differences generate the +even-weight subspace on the other coordinates. Since `n-1` is odd, that +even-weight subspace is nondegenerate for the dot product. The tariff of +each coordinate query is therefore `n-1`. All triples span the full ambient +space, so the final all-ones query has tariff `n`. The total invoice is + +``` +C = n*(n-1)+n = n^2, +C/(V*k) = 6*n/((n-1)*(n-2)). +``` + +For example, `n=100` gives `V=161700`, `C=10000`, and copy ratio +`100/1617 = 0.061842918985...`. This is below the approximately `0.063046` +allowance of a **different**, density-one-third geometry. Transferring that +allowance to this construction would be invalid: here the density is `1/100`. + +## Why the concrete family still misses the target + +Under the three-stage, separate-public-leg law, its data-only moment is + +``` +3*((n-1)/(3*n-2))^(8/9). +``` + +It already exceeds one for every `n>=4`: the ratio inside the power is +increasing, and at `n=4` the required strict comparison is `3^17>10^8`. +The exact verifier also includes every query tariff in the attempted bill. +Every other expense was granted free. Large `n` reduces the copy ratio but +cannot correct this data failure. + +This is not repairable by a block representation of the same graph. +Partition `[n]` into four-element sets, and retain all four triples inside +each part. These `n` labels are pairwise binary-orthogonal: within a part +they intersect in two points, and between parts they are disjoint. In the +complementary binary fitting pattern, their principal block submatrix is +therefore the identity. For a representation with diagonal block rank `d`, +that principal submatrix has rank at least `n*d`. Hence every such binary +representation satisfies + +``` +h/d >= n. +``` + +This applies to arbitrary two-sided block representations as well as +symmetric nondegenerate port spaces. Payload replication does not change +the ratio. Tensor powers of this particular binary representation multiply +the ratio, rather than lower it. Changing the graph or its free mask, +possibly through a noncommuting block construction, would require a new +explicit representation and a new scalar-query invoice. Noncommutativity +alone cannot evade the same-mask identity witness. + +## Replay and remaining construction problem + +```sh +python3 -I -O -B research/kappa01-haemers-repair/verify.py +``` + +The verifier reconstructs every pairing, scalar fitting entry, query support +rank and independent-set witness for `n=4,8,12`. It checks exact rational +moment enclosures for those cases and `n=100`, and detects the two invalid +promotions: pricing each query at one and reusing the density-one-third data +bill. It does not enumerate all possible decoders or graphs. + +A viable escape still needs a binary block representation at +`h/k<3.264451...` and an actual scalar/query program with the appropriate +complete-support invoice. General cross-characteristic separation alone +supplies neither condition. Noncommuting block geometries with a different +mask remain outside the failed construction above; no successful instance +is asserted here. diff --git a/research/kappa01-haemers-repair/RESULT.json b/research/kappa01-haemers-repair/RESULT.json new file mode 100644 index 0000000000..f661d84512 --- /dev/null +++ b/research/kappa01-haemers-repair/RESULT.json @@ -0,0 +1,171 @@ +{ + "controls": [ + "reject_unit_query_tariff", + "reject_reused_h_over_k_equals_three", + "same_graph_block_rank_at_least_n_times_block_size" + ], + "exact_moment_checks": [ + { + "V": 4, + "attempted_fully_charged_moment": { + "lower": "136744691228864936722917795830268222557919/80000000000000000000000000000000000000000", + "lower_decimal": "1.709308640360811709", + "upper": "68372345614432468361458897915134111278979/40000000000000000000000000000000000000000", + "upper_decimal": "1.709308640360811709" + }, + "copy_rank": 16, + "copy_rank_per_port": "4", + "data_moment": { + "lower": "10288217756848833655325408665074038863917/10000000000000000000000000000000000000000", + "lower_decimal": "1.028821775684883365", + "upper": "128602721960610420691567608313425485799/125000000000000000000000000000000000000", + "upper_decimal": "1.028821775684883365" + }, + "h": 4, + "k": 1, + "n": 4 + }, + { + "V": 56, + "attempted_fully_charged_moment": { + "lower": "65654179810299242963239810062575376213003/56000000000000000000000000000000000000000", + "lower_decimal": "1.172396068041057910", + "upper": "1313083596205984859264796201251507524260423/1120000000000000000000000000000000000000000", + "upper_decimal": "1.172396068041057910" + }, + "copy_rank": 64, + "copy_rank_per_port": "8/7", + "data_moment": { + "lower": "10840639622750151564282729666869519283957/10000000000000000000000000000000000000000", + "lower_decimal": "1.084063962275015156", + "upper": "271015990568753789107068241671737982099/250000000000000000000000000000000000000", + "upper_decimal": "1.084063962275015156" + }, + "h": 8, + "k": 1, + "n": 8 + }, + { + "V": 220, + "attempted_fully_charged_moment": { + "lower": "996998103177234006239889407970081664813911/880000000000000000000000000000000000000000", + "lower_decimal": "1.132952389974129552", + "upper": "2492495257943085015599723519925204162035457/2200000000000000000000000000000000000000000", + "upper_decimal": "1.132952389974129552" + }, + "copy_rank": 144, + "copy_rank_per_port": "36/55", + "data_moment": { + "lower": "11002441006084567898428455892026550525407/10000000000000000000000000000000000000000", + "lower_decimal": "1.100244100608456789", + "upper": "1100244100608456789842845589202655052541/1000000000000000000000000000000000000000", + "upper_decimal": "1.100244100608456789" + }, + "h": 12, + "k": 1, + "n": 12 + }, + { + "V": 161700, + "attempted_fully_charged_moment": { + "lower": "110427581143875690385333084614442494528837713/98000000000000000000000000000000000000000000", + "lower_decimal": "1.126812052488527452", + "upper": "151837924072829074279832991344858429977192293/134750000000000000000000000000000000000000000", + "upper_decimal": "1.126812052488527452" + }, + "copy_rank": 10000, + "copy_rank_per_port": "100/1617", + "data_moment": { + "lower": "1126460220111602210554796542384469557389/1000000000000000000000000000000000000000", + "lower_decimal": "1.126460220111602210", + "upper": "11264602201116022105547965423844695573893/10000000000000000000000000000000000000000", + "upper_decimal": "1.126460220111602210" + }, + "h": 100, + "k": 1, + "n": 100 + } + ], + "finite_geometry_checks": [ + { + "copy_rank": 16, + "independent_witness": [ + 7, + 11, + 13, + 14 + ], + "n": 4, + "native_query_tariffs": [ + 3, + 3, + 3, + 3, + 4 + ], + "ports": 4 + }, + { + "copy_rank": 64, + "independent_witness": [ + 7, + 11, + 13, + 14, + 112, + 176, + 208, + 224 + ], + "n": 8, + "native_query_tariffs": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8 + ], + "ports": 56 + }, + { + "copy_rank": 144, + "independent_witness": [ + 7, + 11, + 13, + 14, + 112, + 176, + 208, + 224, + 1792, + 2816, + 3328, + 3584 + ], + "n": 12, + "native_query_tariffs": [ + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 11, + 12 + ], + "ports": 220 + } + ], + "status": "CONCRETE_CROSS_CHARACTERISTIC_DECODER_FAILS_DENSITY", + "theorem_scope": "three-subset family, complete support scalar query tariff" +} diff --git a/research/kappa01-haemers-repair/SOURCES.json b/research/kappa01-haemers-repair/SOURCES.json new file mode 100644 index 0000000000..cb611a2f3b --- /dev/null +++ b/research/kappa01-haemers-repair/SOURCES.json @@ -0,0 +1,19 @@ +{ + "repository_pin": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "local_files": [ + { + "path": "research/kappa01-fieldline-repair/verify.py", + "sha256": "095278e31b07b634a9078c434a63f02cf186a47ae1e4385bfcb8be5d131e6d96" + } + ], + "external_primary_sources": [ + { + "title": "Bukh and Cox, On a fractional version of Haemers’ bound", + "url": "https://arxiv.org/pdf/1802.00476", + "version": "arXiv:1802.00476v2 (2018-12-13)", + "sha256_inspected_pdf": "791c6edea53dc5ee22682d3155eaa2a250aa494706c9766d77a0f782a0c1f454", + "sections": "Section 2; Lemma 12; Proposition 17; Theorems 3 and 19", + "scope": "block representations and characteristic separation; native tariffs independently derived here" + } + ] +} diff --git a/research/kappa01-haemers-repair/verify.py b/research/kappa01-haemers-repair/verify.py new file mode 100644 index 0000000000..2b1d868d10 --- /dev/null +++ b/research/kappa01-haemers-repair/verify.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact three-subset scalar decoder and full-support native tariff.""" +from __future__ import annotations + +from fractions import Fraction as Q +import hashlib +import importlib.util +from itertools import combinations +import json +from math import comb +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def rank2(rows): + pivots = {} + for row in rows: + while row: + p = row.bit_length()-1 + if p not in pivots: + pivots[p] = row + break + row ^= pivots[p] + return len(pivots) + + +def basis2(rows): + pivots = {} + for row in rows: + while row: + p = row.bit_length()-1 + if p not in pivots: + pivots[p] = row + break + row ^= pivots[p] + return list(pivots.values()) + + +def pairing_rank(rows): + basis = basis2(rows) + return rank2([sum(((a & b).bit_count() % 2) << j + for j, b in enumerate(basis)) for a in basis]) + + +def geometry(n): + require(n >= 4 and n % 4 == 0, "divisibility hypothesis") + ports = [sum(1 << i for i in subset) for subset in combinations(range(n), 3)] + V = len(ports) + require(V == comb(n, 3), "port count") + for i, x in enumerate(ports): + require(x.bit_count() % 2 == 1, "nondegenerate line") + for j, y in enumerate(ports): + intersection = (x & y).bit_count() + fitting = Q(intersection-1, 2) + factor_sum = sum(Q(1, 2) * ((x >> t) & 1) * ((y >> t) & 1) + for t in range(n)) - Q(1, 2) + require(fitting == factor_sum, "explicit fitting factorization") + require(i != j or fitting == 1, "fitting diagonal") + require(i == j or intersection % 2 == 0 or fitting == 0, + "forced off-diagonal zero") + tariffs = [pairing_rank([x for x in ports if (x >> i) & 1]) for i in range(n)] + tariffs.append(pairing_rank(ports)) + require(tariffs == [n-1]*n+[n], "full support tariff") + require(sum(tariffs) == n*n, "full copy rank") + independent = [sum(1 << i for i in subset) + for j in range(0, n, 4) for subset in combinations(range(j, j+4), 3)] + require(len(independent) == n and len(set(independent)) == n, "independent count") + require(all((x & y).bit_count() % 2 == int(i == j) + for i, x in enumerate(independent) for j, y in enumerate(independent)), + "independent identity Gram witness") + require(sum(tariffs) > len(tariffs), "unit query tariff negative control") + return dict(n=n, ports=V, native_query_tariffs=tariffs, + copy_rank=sum(tariffs), independent_witness=independent) + + +def main(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + for item in manifest["local_files"]: + require(hashlib.sha256((ROOT / item["path"]).read_bytes()).hexdigest() == item["sha256"], + "pinned exact interval dependency") + path = ROOT / "research/kappa01-fieldline-repair/verify.py" + spec = importlib.util.spec_from_file_location("fieldline_exact_interval", path) + interval = importlib.util.module_from_spec(spec) + spec.loader.exec_module(interval) + finite = [geometry(n) for n in (4, 8, 12)] + records = [] + for n in (4, 8, 12, 100): + V, m = comb(n, 3), 3*n-2 + data = tuple(3*x for x in interval.power89(Q(n-1, m))) + copies_a = interval.power89(Q(n-1, m)) + copies_b = interval.power89(Q(n, m)) + full = tuple(data[t]+Q(3, 2*V)*(n*copies_a[t]+copies_b[t]) for t in (0, 1)) + require(data[0] > 1 and full[0] > data[0], "actual density rejects target") + records.append(dict(n=n, h=n, k=1, V=V, copy_rank=n*n, + copy_rank_per_port=str(Q(n*n, V)), + data_moment=interval.interval_record(data), + attempted_fully_charged_moment=interval.interval_record(full))) + wrong_density = tuple(3*x for x in interval.power89(Q(2, 7))) + require(wrong_density[1] < 1 < Q(records[-1]["data_moment"]["lower"]), + "wrong density has passing data but actual density rejects") + require(Q(10000, comb(100, 3)) < Q(63, 1000), "small concrete copy ratio") + require(3**17 > 10**8, "all n>=4 integer data gate") + result = dict(status="CONCRETE_CROSS_CHARACTERISTIC_DECODER_FAILS_DENSITY", + finite_geometry_checks=finite, exact_moment_checks=records, + controls=["reject_unit_query_tariff", "reject_reused_h_over_k_equals_three", + "same_graph_block_rank_at_least_n_times_block_size"], + theorem_scope="three-subset family, complete support scalar query tariff") + encoded = json.dumps(result, indent=2, sort_keys=True)+"\n" + out = HERE / "RESULT.json" + if out.exists(): + require(out.read_text() == encoded, "existing receipt differs; inspect before replacing") + else: + with out.open("x") as handle: + handle.write(encoded) + print("PASS_KAPPA01_HAEMERS_ATTEMPT exact_tariff=n^2 density_obstruction=h/k>=n no_new_supplier") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-outer-repair/ADAPTER-FUSION.md b/research/kappa01-outer-repair/ADAPTER-FUSION.md new file mode 100644 index 0000000000..05fd567896 --- /dev/null +++ b/research/kappa01-outer-repair/ADAPTER-FUSION.md @@ -0,0 +1,176 @@ +# A source-bound adapter fusion attempt + +This attempts the single-complex-supplier repair on actual emitted source +operators. The result is negative for the concrete compilers below. It is +not a lower bound on arbitrary supplier constructions or globally fused +Clifford programs. + +## Exact segment and inherited source + +At commit `997e6a9ca7b4f95d50e366f61412fd640d72a88a`, the file +`research/involutive-walsh-lift/evidence/WALSH-RETARGET-NATIVE.json.gz` +contains 2,896 native recipes and two literal 24,767-event local programs. +It is the emitted retarget of the selected historical local word, with the +same native ranks and scalar gates. Its exact operator and arbitrary-input +proofs are in that package's `NATIVE-PROOF.md` and `review_native.py`. + +We select the entire canonical-frame interior between the `A` and +`exit_adapters` phase markers, source events 8107 through 17217 inclusive. +Each orientation has 9,111 events: 3,486 persistent climbs, eight centre +children, 5,613 scalar gates and four phase markers. There are no external +adapter or helper-normalizer events inside this chosen segment. +The exact native child inventory is + + {1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}, + +with rank mass 5,586. Every child occurrence is resolved by its exact +`(old frame, new frame, rank)` key to an emitted left/right monomial recipe. +The program uses 704 persistent and eight private scalar registers. + +This scope includes the literal scalar chronology, rather than adding a +generic adapter allowance to a rank histogram. Initial and final canonical +layouts are preserved. External endpoint normalization, helper hosting, +global charts, idle work, scalar guards and the complete supplier are not +part of this segment. + +## A concrete Fourier-only address compiler + +A monomial factor is `P_A D`, where A is an affine binary address map and +D is its exact quadratic diagonal phase. These diagonal phases can be +evaluated on the indicated current addresses. Conjugating them through a +known affine map changes their exact quadratic formula; it does not make +them commute unchanged. The phase completion is proved algebraically +below; the executable synthesizes and replays affine maps and does not +materialize the completed phase program. These phases add no recursive +Fourier children. Their scalar scan and precision invoice remains an +explicit whole-supplier obligation. + +For each actual 9-by-9 invertible linear matrix, the compiler constructs +four exact alternatives: column elimination, row-grouped LU elimination, +and reversals of those algorithms applied to the inverse matrix. A dense +rectangular block shear also receives its direct two-transform candidate. +It chooses the least target-weighted cost among these valid finite words; +this choice uses floating-point scores only to select a valid program, +never to certify its endpoint or a strict moment. + +Each resulting binary row operation is checked on the complete matrix. +Consecutive shears are merged whenever their combined target set is +disjoint from every participating control. The merged rectangular shear +costs two Fourier children of rank equal to the number of targets, using +the exact identity in the main README. Each coordinate swap costs three +rank-two children using `(H_2 D)^3`. A translation on t selected coordinate +slots costs two rank-t native C children, since `C_t^2=X_all`. + +These operations are generalized children on the specified selected axis +subsets. The count is favorable to this attempted repair: an all-size +physical compiler accepting those subsets without an additional gather +has not been supplied here. Every such child still has rank at most nine, +strictly below the selected ambient parent rank 73. + +## Fusion through the actual scalar word + +Three legal implementations of the segment are compared. + +1. **Literal:** implement each emitted left and right adapter independently. +2. **Deferred, then flush:** maintain a pending affine address map per + register; compose successive adapters, commute translations through + native C children, and flush layouts before an incompatible scalar ADD. +3. **Deferred, relative alignment:** retain the same pending maps, but align + one ADD operand to the other's current physical layout using a single + relative affine map. Evaluate both directions with the concrete compiler + and choose the cheaper one. Common-layout ADDs need no address operation. + +The invariant is `desired register value = P_pending(stored value)`. +For an edge `P_L C_r P_R`, first implement the linear part of +`P_R P_pending`. Its translation commutes with every coordinate C factor, +so it is pushed into the new pending left map. Diagonal phases are +conjugated at their proper positions. For scalar ADD, the relative map +`P_target^-1 P_source` transforms the stored source into the target layout; +the opposite choice transforms the target instead. Both identities are +checked as exact affine maps at every occurrence. + +Here is the phase placement explicitly. Write the full edge as +`(P_L D_l) C_r (P_R D_q)`, with constant phases included in the +quadratic Z4 functions `l,q`. For incoming pending affine map T, write +`R T(x)=M x+b`. In execution order on the stored array, apply + + D_(q composed with T), P_M, C_r, D_(l composed with X_b), + +then leave pending map `L composed with X_b`. This follows exactly from +`D_q P_T=P_T D_(q composed with T)`, +`P_(RT)=X_b P_M`, and `C_r X_b=X_b C_r`. +It retains both constant phases as well as linear and quadratic terms. +The phase formulas are a proved completion of the affine replay, not an +independently emitted or verified scalar/phase ledger. + +Scalar multiplication commutes with pending maps. COPY makes the target +inherit the source's pending map. CLEAR resets the private value and its +pending map. All remaining pending maps are actually returned at the end. +With that phase completion, fusion preserves the complete segment on +arbitrary values, including dirty helpers. It does not depend on values +being zero or tensor-separable. + +## Result and its limits + +The initial run gave these exact rank masses and diagnostic target moments +at `a=1/9`, normalized by `m=73` and `W/N=896/9`: + +| Orientation | Literal | Deferred, flush | Deferred, relative alignment | +|---|---:|---:|---:| +| Forward rank mass | 294,446 | 259,814 | 239,648 | +| Backward rank mass | 294,574 | 259,942 | 232,198 | +| Forward target moment | 60.5071 | 54.0229 | 49.1179 | +| Backward target moment | 60.5311 | 54.0454 | 47.6197 | + +`ADAPTER-RESULT.json` is authoritative for the current direct-block-shear +compiler as well. It records the complete combined child profile, exact +rank masses, operation counts, source hash and address-charge-schedule +digest (`program_sha256`) for every orientation and strategy. That digest +covers charged affine maps and their chosen words, not scalar coefficients +or diagonal phases; the source hash separately binds those original inputs. +The bare source interior itself already +fails at the 0.1 target; this compiler adds much more work than the +available budget. External/global work has not been charged. + +Failure of each concrete compiled profile is exact: for `0=t`, so its target moment is at least + + rank_mass / (73 * 896/9). + +Every reported rational floor exceeds one by a large margin. The decimal +moments are only descriptive, and no floating calculation determines the +failure conclusion. + +There is a more informative **restricted boundary obstruction**. After +relative-layout fusion, the backward word still has 5,619 nonidentity +linear adapter boundaries before final layout returns. If each of these +maps is independently synthesized on one array from nonzero diagonal +phases and native Fourier calls, it needs at least two nonzero-rank calls: +zero calls give a diagonal operator, while one Fourier call, with any +nonzero diagonal wrappers, has at least two nonzero entries in every row +and cannot be a permutation. Thus even granting every call the minimum +rank one and waiving every translation and endpoint return, these +adapter boundaries alone exceed the entire rank budget. + +This last exclusion is deliberately narrow. It does not allow auxiliary +arrays, linear combinations of saved transforms, crossing a native child +boundary during fusion, or a changed physical frame assignment throughout +the scalar network. Those possibilities require a new program and are +not ruled out. It does establish that replacing Gaussian elimination by +a better independent diagonal-plus-Fourier synthesizer at the same +boundaries cannot repair this attempted recursion. + +The next meaningful single-supplier attempt must therefore change the +global frame/compiler structure or provide a new finite word with far +fewer such boundaries. Merely compressing each existing address map is +insufficient in this restricted implementation model. + +## Replay + + python3 -I -B research/kappa01-outer-repair/adapter_fusion.py + +The verifier uses explicit requirements, also under `-O`, and authenticates +its exact source object. No predecessor or selected record is modified. +The inherited native recipes and Walsh-retarget proof are credited to the +`involutive-walsh-lift` package. This new finite compiler investigation used +OpenAI assistance, is Apache-2.0, and has no independent human review. diff --git a/research/kappa01-outer-repair/ADAPTER-RESULT.json b/research/kappa01-outer-repair/ADAPTER-RESULT.json new file mode 100644 index 0000000000..c69786fe79 --- /dev/null +++ b/research/kappa01-outer-repair/ADAPTER-RESULT.json @@ -0,0 +1,468 @@ +{ + "status": "EXACT CONCRETE ADAPTER COMPILER; NO OPTIMALITY OR SUPPLIER CLAIM", + "source_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "source_path": "research/involutive-walsh-lift/evidence/WALSH-RETARGET-NATIVE.json.gz", + "source_sha256": "5bfd2c228533e0d20d62b867ef9c1b57c235399478232e1beee875d6838051db", + "source_recipe_count": 2896, + "orientation_results": { + "backward": [ + { + "policy": "literal", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 63128, + "2": 83885, + "3": 2494, + "4": 686, + "5": 158, + "6": 44 + }, + "added_translation_profile": { + "1": 1162, + "2": 1398, + "3": 2424, + "4": 2388, + "5": 706, + "6": 1936, + "7": 1176, + "8": 302, + "9": 26 + }, + "augmented_profile": { + "1": 66702, + "2": 85701, + "3": 5350, + "4": 3216, + "5": 946, + "6": 1980, + "7": 1176, + "8": 310, + "9": 26 + }, + "rank_mass": 294574, + "exact_normalized_linear_rank_floor": "189369/4672", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "60.5311309635970593851530962821252437930908542243727351683976", + "augmented_even_if_boundary_layouts_free": "60.5311309635970593851530962821252437930908542243727351683976" + }, + "nonidentity_linear_jobs_by_reason": { + "left_adapter": 3494, + "right_adapter": 3494 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 6988, + "minimum_fourier_calls": 13976, + "exact_adapter_only_normalized_rank_floor": "15723/8176", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "left_adapter": 3494, + "nonidentity_linear_jobs": 6988, + "right_adapter": 3494, + "scalar_add": 5052, + "scalar_clear": 16, + "scalar_scale": 545, + "translation_jobs": 5759 + }, + "program_sha256": "9182f60e667c141a82ceb8b19b1490f6b3d08e210f906a69ade2a6dc2b3d3339" + }, + { + "policy": "flush", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 63128, + "2": 83885, + "3": 2494, + "4": 686, + "5": 158, + "6": 44 + }, + "added_translation_profile": { + "1": 30, + "2": 360, + "3": 698, + "4": 940, + "5": 162, + "6": 410, + "7": 256, + "8": 64 + }, + "augmented_profile": { + "1": 65570, + "2": 84663, + "3": 3624, + "4": 1768, + "5": 402, + "6": 454, + "7": 256, + "8": 72 + }, + "rank_mass": 259942, + "exact_normalized_linear_rank_floor": "1169739/32704", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "54.0454266506470121454365114759781360886658216890252101335240", + "augmented_even_if_boundary_layouts_free": "50.2260265520880545636161397501245320861246843509365649435174" + }, + "nonidentity_linear_jobs_by_reason": { + "fused_child_entrance": 3494, + "returned_layout": 514, + "scalar_flush": 2980 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 6474, + "minimum_fourier_calls": 12948, + "exact_adapter_only_normalized_rank_floor": "29133/16352", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "already_common_layout_adds": 3021, + "fused_child_entrance": 3494, + "nonidentity_linear_jobs": 6988, + "returned_layout": 514, + "scalar_add": 5052, + "scalar_clear": 16, + "scalar_flush": 4062, + "scalar_scale": 545, + "translation_jobs": 1460 + }, + "program_sha256": "ea1a5ca1ec3ea45defc6e8279c61f181513c5ce643baecdee31d1a4439e61dd8" + }, + { + "policy": "relative", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 38210, + "2": 69780, + "3": 5540, + "4": 2358, + "5": 764, + "6": 286, + "7": 14 + }, + "added_translation_profile": { + "1": 978, + "2": 444, + "3": 814, + "4": 1256, + "5": 902, + "6": 364, + "7": 134, + "8": 24 + }, + "augmented_profile": { + "1": 41600, + "2": 70642, + "3": 6786, + "4": 3756, + "5": 1748, + "6": 650, + "7": 148, + "8": 32 + }, + "rank_mass": 232198, + "exact_normalized_linear_rank_floor": "1044891/32704", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "47.6196622967930226014474375420611179732321799771866873136275", + "augmented_even_if_boundary_layouts_free": "41.4919342324835520708360989807809301990739555535638781886867" + }, + "nonidentity_linear_jobs_by_reason": { + "fused_child_entrance": 3494, + "relative_alignment": 2125, + "returned_layout": 704 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 5619, + "minimum_fourier_calls": 11238, + "exact_adapter_only_normalized_rank_floor": "50571/32704", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "already_common_layout_adds": 2927, + "fused_child_entrance": 3494, + "nonidentity_linear_jobs": 6323, + "relative_alignment": 2125, + "returned_layout": 704, + "scalar_add": 5052, + "scalar_clear": 16, + "scalar_scale": 545, + "translation_jobs": 2458 + }, + "program_sha256": "6ff2be1f261b2186297428ceab5c01946797e0d63d5f0975909a37b8f6be8904" + } + ], + "forward": [ + { + "policy": "literal", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 63128, + "2": 83885, + "3": 2494, + "4": 686, + "5": 158, + "6": 44 + }, + "added_translation_profile": { + "1": 1162, + "2": 1382, + "3": 2424, + "4": 2388, + "5": 706, + "6": 1920, + "7": 1176, + "8": 302, + "9": 26 + }, + "augmented_profile": { + "1": 66702, + "2": 85685, + "3": 5350, + "4": 3216, + "5": 946, + "6": 1964, + "7": 1176, + "8": 310, + "9": 26 + }, + "rank_mass": 294446, + "exact_normalized_linear_rank_floor": "1325007/32704", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "60.5071277982164927364433866466974476534742327020035019375455", + "augmented_even_if_boundary_layouts_free": "60.5071277982164927364433866466974476534742327020035019375455" + }, + "nonidentity_linear_jobs_by_reason": { + "left_adapter": 3494, + "right_adapter": 3494 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 6988, + "minimum_fourier_calls": 13976, + "exact_adapter_only_normalized_rank_floor": "15723/8176", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "left_adapter": 3494, + "nonidentity_linear_jobs": 6988, + "right_adapter": 3494, + "scalar_add": 5044, + "scalar_clear": 16, + "scalar_copy": 8, + "scalar_scale": 545, + "translation_jobs": 5743 + }, + "program_sha256": "7865fe714ae5560a391345372ca3b970e8c2ee81921113721e558d0513dd6e26" + }, + { + "policy": "flush", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 63128, + "2": 83885, + "3": 2494, + "4": 686, + "5": 158, + "6": 44 + }, + "added_translation_profile": { + "1": 30, + "2": 360, + "3": 698, + "4": 940, + "5": 162, + "6": 410, + "7": 256, + "8": 48 + }, + "augmented_profile": { + "1": 65570, + "2": 84663, + "3": 3624, + "4": 1768, + "5": 402, + "6": 454, + "7": 256, + "8": 56 + }, + "rank_mass": 259814, + "exact_normalized_linear_rank_floor": "1169163/32704", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "54.0229094628064055889667552640167077520333302860659748849175", + "augmented_even_if_boundary_layouts_free": "50.2035093642474480071463835381631037494921929479773296949109" + }, + "nonidentity_linear_jobs_by_reason": { + "fused_child_entrance": 3494, + "returned_layout": 514, + "scalar_flush": 2980 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 6474, + "minimum_fourier_calls": 12948, + "exact_adapter_only_normalized_rank_floor": "29133/16352", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "already_common_layout_adds": 3013, + "fused_child_entrance": 3494, + "nonidentity_linear_jobs": 6988, + "returned_layout": 514, + "scalar_add": 5044, + "scalar_clear": 16, + "scalar_copy": 8, + "scalar_flush": 4062, + "scalar_scale": 545, + "translation_jobs": 1452 + }, + "program_sha256": "f72a82ff0cf78962e26702fb6ccf3b22b793c0a76f7d365af0165a2de762727d" + }, + { + "policy": "relative", + "start_event_inclusive": 8107, + "end_event_exclusive": 17218, + "event_count": 9111, + "native_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + }, + "added_linear_profile": { + "1": 38862, + "2": 71807, + "3": 5482, + "4": 2546, + "5": 832, + "6": 242, + "7": 12 + }, + "added_translation_profile": { + "1": 842, + "2": 550, + "3": 1192, + "4": 1330, + "5": 890, + "6": 490, + "7": 104, + "8": 38 + }, + "augmented_profile": { + "1": 42116, + "2": 72775, + "3": 7106, + "4": 4018, + "5": 1804, + "6": 732, + "7": 116, + "8": 46 + }, + "rank_mass": 239648, + "exact_normalized_linear_rank_floor": "67401/2044", + "target_moment_exceeds_one_from_exact_floor": true, + "diagnostic_decimal_moments": { + "native_only": "1.15555832818566343043464571606695612785920928412814784898916", + "augmented_interior_only": "49.1178668951032109932084615986071676805785601241179129520195", + "augmented_even_if_boundary_layouts_free": "42.9919429417270011741326274157074069752714155120334072791101" + }, + "nonidentity_linear_jobs_by_reason": { + "fused_child_entrance": 3494, + "relative_alignment": 2294, + "returned_layout": 704 + }, + "independent_single_array_boundary_floor": { + "interior_nonidentity_maps": 5788, + "minimum_fourier_calls": 11576, + "exact_adapter_only_normalized_rank_floor": "13023/8176", + "exceeds_one": true, + "scope": "Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion" + }, + "events": { + "already_common_layout_adds": 2676, + "fused_child_entrance": 3494, + "nonidentity_linear_jobs": 6492, + "relative_alignment": 2368, + "returned_layout": 704, + "scalar_add": 5044, + "scalar_clear": 16, + "scalar_copy": 8, + "scalar_scale": 545, + "translation_jobs": 2718 + }, + "program_sha256": "ea9615618f42269578b5cb56feaf587cccd0db273fc168c2dc70143bc5f1c61c" + } + ] + }, + "distinct_linear_maps_compiled": 8542, + "scope": [ + "Canonical-frame local interior only; external normalization and global jobs omitted", + "Recursive Fourier calls may target arbitrary subsets; uniform physical shape theorem still required", + "Monomial phases retained by algebraic conjugation, scalar/guard costs not replayed", + "Compiler choice uses floats only to choose among exact validated programs", + "Failure is proved by exact rank mass, not the diagnostic decimal moments" + ] +} diff --git a/research/kappa01-outer-repair/CONVOLUTION-FRAMES.md b/research/kappa01-outer-repair/CONVOLUTION-FRAMES.md new file mode 100644 index 0000000000..548885c8c7 --- /dev/null +++ b/research/kappa01-outer-repair/CONVOLUTION-FRAMES.md @@ -0,0 +1,218 @@ +# Exact audit of a common convolution-frame repair + +The existing local word cannot be put in one common Walsh basis merely by +replacing its canonical frame representatives with convolution frames while +retaining the pointwise source-carry and target-read requirements below. +An actual helper has the same nonzero binary vector in both required +eigenspaces. This is a scoped obstruction to that repair, **not** an +obstruction to arbitrary complex circuits or to kappa 0.1. + +The positive control matters: degenerate carried spaces do sometimes admit +a symmetric convolution frame. Degeneracy alone is not a rejection rule. + +## Frozen inputs and replay + +All inputs are Git blobs at +`997e6a9ca7b4f95d50e366f61412fd640d72a88a`, authenticated by SHA256 in the +verifier. The scalar word comes from +`research/involutive-walsh-lift/evidence/WALSH-RETARGET-NATIVE.json.gz`. +Its binary frame bases and 112 port labels come from +`slots/local/CANONICAL-WORD.json.gz` inside +`research/community-frontier1042-audit/selected-replay.tar.gz`. +The exact original frame conjugation is checked with pinned +`research/involutive-walsh-lift/native.py`. + +Run from the repository root: + +```sh +python3 -I -B research/kappa01-outer-repair/convolution_frames.py +``` + +The command writes `CONVOLUTION-RESULT.json`. Both normal and optimized +Python must preserve its checks; the script uses explicit exceptions and +compiles the imported checker with `optimize=0`. + +## The precise replacement model + +Work over `H=F2^9`, with standard dot product. A convolution Clifford has +binary symplectic action + + F_A = [[I,A],[0,I]], A=A^T, + +and preimage of the coordinate Z-Lagrangian + + L(F_A) = {(A z,z): z in H}. + +Its exact lift can be taken as a full Walsh conjugate of a quadratic +Gaussian phase. It then commutes with every translation and is diagonal +in one common full Walsh basis. This statement gives an operator lift, +not a cheap physical implementation of the Walsh entry and exit. + +At a specified scalar cut, let C be the binary span of source port labels +having **nonzero exact rational coefficients** in the helper's current +scalar value. Let R be the binary span of target port labels whose final +scalar output has nonzero derivative with respect to that helper at that +cut. Coefficients are not reduced modulo two: their supports select the +binary labels, and those labels alone are then spanned over F2. + +The replacement scheme under investigation retains the conditions + + (c,c) in L(F_A) for c in C, + (0,r) in L(F_A) for r in R. (1) + +They are exactly + + A c=c for c in C, A r=0 for r in R. (2) + +These are the explicit source-carry and target-read requirements of this +scheme. We do **not** derive (1) as necessary for every complex circuit +with the same final input/output map. A changed representation, scalar +schedule, or global circuit could use different invariants. + +For the actual canonical label + + L_U={(u,u+v): u in U, v in Uperp}, + +(1) is satisfied if and only if `C subset U` and `R subset Uperp`. +The reported negative and positive examples pass both conditions. +This checks that their source/read requirements agree with the original +frame geometry; it does not claim every future scalar dependency always +imposes a frame requirement. Indeed some other probed cuts fail the +canonical reader-containment test and are reported separately. + +**Symmetric extension criterion.** There is a symmetric A satisfying +(2) if and only if `C intersect R=0` and `C perpendicular R`. + +Necessity follows from applying A to an intersection vector and from +`c dot r=(Ac) dot r=c dot (Ar)=0`. For sufficiency define +`B(c+r)=c` on `W=C directsum R`. This is well defined. Its bilinear form +on W is symmetric because the cross pairings vanish. Extend a basis of +W to a basis of H, with change-of-basis matrix T. The first `dim W` +columns of `S=T^T A T` are prescribed by `T^T B w_j`. Their leading +square block is symmetric. Fill the remaining columns by symmetry and +choose the remaining diagonal block arbitrarily symmetric. Then +`A=T^-T S T^-1` works. No nondegeneracy of C or R is required. + +The verifier independently solves the 45-entry symmetric linear system +and checks this criterion at every reported checkpoint. It also tests +all 256 pairs of the 16 subspaces of F2^3, embedded in F2^9. + +## An actual incompatible helper + +Use the forward program's **zero-based event 13759**, immediately after + + ["climb","B",445,493,451,4] + +and before event 13760, + + ["scalar",["add",["L",137],["L",445],1,1],451]. + +Helper L445's dependence on original source variables is exactly + + +(1/2) x_46 -(1/2) x_20. + +The corresponding port labels are `140` and `161`. This describes its +source dependence, not the entire dirty helper value. Its exact suffix +derivatives into final target outputs are `+1` for target port 2, label +`35`, and `-1` for target port 25, label `14`; all other target derivatives +vanish. Therefore + + C=span(140,161), R=span(14,35), + 140 xor 161 = 14 xor 35 = 45 != 0. + +All source/read dot products are zero. The two spaces nevertheless meet +in the line spanned by 45. Equation (2) would require both `A45=45` and +`A45=0`. **No linear A exists**, even without the symmetry condition. + +The actual frame 451 has basis + + [256,128,64,33,16,11,7]. + +It contains C and is orthogonal to R. Its radical, and the radical of C, +both have dimension one. Thus this obstruction is not an artifact of +choosing the original Clifford representative for that frame. + +Any repair which keeps (1) must alter this cut's carried/read spaces or +leave the convolution-only frame class. Merely allowing general symmetric +A, instead of an orthogonal projector onto the old U, is insufficient. + +## Positive alternative frames + +At forward event **15459**, helper L283 has just changed to frame 775 and +is about to be read into L139 with coefficient `-1/2`. Its carried space +has basis + + C=span(81,51,463,237,30,8), R=span(38). + +C has radical dimension two, yet is disjoint from R and orthogonal to it. +The following symmetric matrix, represented by nine binary row masks, +satisfies (2): + + A=[50,23,34,8,35,53,64,128,256]. + +It is not a projector: its square has row masks +`[1,36,34,8,16,6,64,128,256]`. The receipt gives all sixteen nonzero source +coefficients (each is `+1`) and the single target-read coefficient. + +A second control uses event 9466, helper L228, whose original frame 23 +has basis `[493,30]` and radical dimension one. Here + + C=span(493), + R=span(266,30,148,84,45,12), + A=[460,0,493,493,0,460,493,493,493]. + +This also satisfies (2). Consequently neither a degenerate canonical +frame nor a degenerate carried space alone proves infeasibility. +These pointwise matrices are **not** a replacement native word: common +gate frames, transition ranks, exact phase choices, endpoint conversion, +restoration, guard precision, and hosting remain unconstructed. + +## Why the existing canonical operators cannot share one Walsh basis + +The 1004 original subspace labels comprise 234 with zero radical, 726 +with radical dimension one, and 44 with radical dimension two. +Of 3486 persistent climbs in the chosen local program, 2982 touch a +degenerate label. For the actual canonical frame of `U=span(30)`, the +source exact checker gives + + T_U X_2 T_U^-1 = X_28 Z_14, + +with phase exponent zero. Hence this operator does not commute with all +translations. In particular it is not diagonal in their common Walsh +basis. + +This cannot be cured by choosing a different representative with the +same preimage label L_U when U is degenerate. The z-coordinate projection +of a convolution-frame graph is injective, whereas L_U contains `(u,0)` +for every radical vector `u in U intersect Uperp`. A nonzero radical +therefore prevents L_U from being such a graph. The positive examples +above instead allow a **different** preimage label satisfying only (1). + +## Replay coverage and limits + +The verifier propagates exact Fraction rows forward from all 112 source +inputs, and propagates exact target sensitivities backwards from all 112 +final target outputs, through all 19693 scalar events. It verifies the +whole scalar Jacobians: the final source-to-source and source-to-target +blocks are identity, and source material is cleaned out of all helpers; +the suffix map also cancels all arbitrary helper influence on targets. +This prevents a truncated prefix or omitted cleanup from manufacturing +the reported supports. + +There are 2886 helper checkpoints: all 480 helper entrances and every +persistent helper climb in the local interior. Their classification is: + +| Canonical carry/read conditions | Symmetric A exists | Count | +| --- | --- | ---: | +| Both hold | Yes | 1718 | +| Both hold | No, nonzero intersection | 734 | +| Only carry containment holds | Yes | 168 | +| Only carry containment holds | No | 266 | + +The last two rows are not used as canonical-compatible obstructions. +The count is an audit of these fixed checkpoints, not an enumeration of +all scalar cuts or possible frame assignments. The negative witness alone +settles the stated fixed-content replacement attempt. General complex +circuits, changes to the scalar content schedule, auxiliary saved transforms, +mixed convolution/nonconvolution words, and larger geometric candidates +are outside the exclusion. diff --git a/research/kappa01-outer-repair/CONVOLUTION-RESULT.json b/research/kappa01-outer-repair/CONVOLUTION-RESULT.json new file mode 100644 index 0000000000..8f46e1a80a --- /dev/null +++ b/research/kappa01-outer-repair/CONVOLUTION-RESULT.json @@ -0,0 +1,470 @@ +{ + "status": "POINTWISE CONTENT-CONSTRAINT AUDIT; NO UNIVERSAL COMPLEX-CIRCUIT OBSTRUCTION", + "source_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "checkpoint_count": 2886, + "counts_key": [ + "symmetric_solution_exists", + "orthogonal", + "nonzero_intersection", + "canonical_contains_carry", + "canonical_orthogonal_to_read" + ], + "counts": { + "(True, True, False, True, True)": 1718, + "(True, True, False, True, False)": 168, + "(False, False, True, True, False)": 266, + "(False, True, True, True, True)": 734 + }, + "records": [ + { + "event": 9466, + "role": 228, + "frame": 23, + "frame_basis": [ + 493, + 30 + ], + "event_contents": [ + "climb", + "A", + 228, + 11, + 23, + 1 + ], + "next_event": [ + "climb", + "A", + 232, + 13, + 23, + 1 + ], + "timing": "after event, before next event; zero-based program indices", + "carry_basis": [ + 493 + ], + "read_basis": [ + 266, + 30, + 148, + 84, + 45, + 12 + ], + "carry_ports": [ + 87 + ], + "read_ports": [ + 34, + 50, + 49, + 33, + 48, + 32, + 98, + 85, + 30, + 60, + 59, + 29, + 58, + 28, + 93, + 86 + ], + "carry_coefficients": [ + { + "port": 87, + "label": 493, + "coefficient": "1" + } + ], + "read_coefficients": [ + { + "port": 28, + "label": 70, + "coefficient": "-1/2" + }, + { + "port": 29, + "label": 134, + "coefficient": "-1/2" + }, + { + "port": 30, + "label": 262, + "coefficient": "-1/2" + }, + { + "port": 32, + "label": 74, + "coefficient": "-1/2" + }, + { + "port": 33, + "label": 138, + "coefficient": "-1/2" + }, + { + "port": 34, + "label": 266, + "coefficient": "-1/2" + }, + { + "port": 48, + "label": 84, + "coefficient": "-1/2" + }, + { + "port": 49, + "label": 148, + "coefficient": "-1/2" + }, + { + "port": 50, + "label": 276, + "coefficient": "-1/2" + }, + { + "port": 58, + "label": 88, + "coefficient": "-1/2" + }, + { + "port": 59, + "label": 152, + "coefficient": "-1/2" + }, + { + "port": 60, + "label": 280, + "coefficient": "-1/2" + }, + { + "port": 85, + "label": 505, + "coefficient": "-1/2" + }, + { + "port": 86, + "label": 501, + "coefficient": "-1/2" + }, + { + "port": 93, + "label": 491, + "coefficient": "-1/2" + }, + { + "port": 98, + "label": 487, + "coefficient": "-1/2" + } + ], + "carry_radical_dimension": 0, + "frame_radical_dimension": 1, + "orthogonal": true, + "intersection_dimension": 0, + "canonical_contains_carry": true, + "canonical_orthogonal_to_read": true, + "symmetric_matrix": [ + 460, + 0, + 493, + 493, + 0, + 460, + 493, + 493, + 493 + ] + }, + { + "event": 13759, + "role": 445, + "frame": 451, + "frame_basis": [ + 256, + 128, + 64, + 33, + 16, + 11, + 7 + ], + "event_contents": [ + "climb", + "B", + 445, + 493, + 451, + 4 + ], + "next_event": [ + "scalar", + [ + "add", + [ + "L", + 137 + ], + [ + "L", + 445 + ], + 1, + 1 + ], + 451 + ], + "timing": "after event, before next event; zero-based program indices", + "carry_basis": [ + 140, + 45 + ], + "read_basis": [ + 14, + 35 + ], + "carry_ports": [ + 46, + 20 + ], + "read_ports": [ + 25, + 2 + ], + "carry_coefficients": [ + { + "port": 20, + "label": 161, + "coefficient": "-1/2" + }, + { + "port": 46, + "label": 140, + "coefficient": "1/2" + } + ], + "read_coefficients": [ + { + "port": 2, + "label": 35, + "coefficient": "1" + }, + { + "port": 25, + "label": 14, + "coefficient": "-1" + } + ], + "carry_radical_dimension": 1, + "frame_radical_dimension": 1, + "orthogonal": true, + "intersection_dimension": 1, + "canonical_contains_carry": true, + "canonical_orthogonal_to_read": true, + "symmetric_matrix": null + }, + { + "event": 15459, + "role": 283, + "frame": 775, + "frame_basis": [ + 256, + 128, + 64, + 34, + 16, + 8, + 6, + 1 + ], + "event_contents": [ + "climb", + "B", + 283, + 774, + 775, + 2 + ], + "next_event": [ + "scalar", + [ + "add", + [ + "L", + 139 + ], + [ + "L", + 283 + ], + -1, + 2 + ], + 775 + ], + "timing": "after event, before next event; zero-based program indices", + "carry_basis": [ + 81, + 51, + 463, + 237, + 30, + 8 + ], + "read_basis": [ + 38 + ], + "carry_ports": [ + 17, + 38, + 103, + 77, + 40, + 19, + 18, + 39, + 95, + 66, + 8, + 26, + 64, + 97, + 96, + 65 + ], + "read_ports": [ + 27 + ], + "carry_coefficients": [ + { + "port": 8, + "label": 37, + "coefficient": "1" + }, + { + "port": 17, + "label": 81, + "coefficient": "1" + }, + { + "port": 18, + "label": 145, + "coefficient": "1" + }, + { + "port": 19, + "label": 273, + "coefficient": "1" + }, + { + "port": 26, + "label": 22, + "coefficient": "1" + }, + { + "port": 38, + "label": 98, + "coefficient": "1" + }, + { + "port": 39, + "label": 162, + "coefficient": "1" + }, + { + "port": 40, + "label": 290, + "coefficient": "1" + }, + { + "port": 64, + "label": 200, + "coefficient": "1" + }, + { + "port": 65, + "label": 328, + "coefficient": "1" + }, + { + "port": 66, + "label": 392, + "coefficient": "1" + }, + { + "port": 77, + "label": 508, + "coefficient": "1" + }, + { + "port": 95, + "label": 443, + "coefficient": "1" + }, + { + "port": 96, + "label": 379, + "coefficient": "1" + }, + { + "port": 97, + "label": 251, + "coefficient": "1" + }, + { + "port": 103, + "label": 463, + "coefficient": "1" + } + ], + "read_coefficients": [ + { + "port": 27, + "label": 38, + "coefficient": "-1/2" + } + ], + "carry_radical_dimension": 2, + "frame_radical_dimension": 0, + "orthogonal": true, + "intersection_dimension": 0, + "canonical_contains_carry": true, + "canonical_orthogonal_to_read": true, + "symmetric_matrix": [ + 50, + 23, + 34, + 8, + 35, + 53, + 64, + 128, + 256 + ] + } + ], + "frame_radical_dimensions": { + "0": 234, + "1": 726, + "2": 44 + }, + "degenerate_persistent_climb_occurrences": 2982, + "original_frame30_X2_conjugate": { + "X": 28, + "Z": 14, + "phase_mod4": 0 + }, + "controls": { + "full_prefix_and_suffix_scalar_jacobians": "exact Fraction replay", + "small_subspace_pairs": 256 + }, + "limits": [ + "Scalar Jacobian labels become necessary constraints only within the stated fixed carry/read model.", + "Pointwise feasibility alone gives no common frame at gates, transition budget, exact phase lift, or supplier.", + "Independent changes of scalar schedule, content representation, nonconvolution operations, and arbitrary complex circuits remain open." + ] +} diff --git a/research/kappa01-outer-repair/README.md b/research/kappa01-outer-repair/README.md new file mode 100644 index 0000000000..656c3746a6 --- /dev/null +++ b/research/kappa01-outer-repair/README.md @@ -0,0 +1,247 @@ +# Exact Fourier repairs and the 0.1 outer parameter domain + +This is a local investigation at source commit +`997e6a9ca7b4f95d50e366f61412fd640d72a88a`. It supplies two exact operator +identities, a charged recurrence criterion, and an enlarged **arithmetic** +parameter region. It does not supply a new finite supplier or a multiplication +theorem. In particular, it does not remove the selected bit supplier merely +by renaming its address maps as complex operations. + +The concrete native-adapter attempt is in [ADAPTER-FUSION.md](ADAPTER-FUSION.md). +The subsequent shared-Walsh-frame attempt is audited in +[CONVOLUTION-FRAMES.md](CONVOLUTION-FRAMES.md): alternative symmetric frames +exist at some cuts, but a specific helper has incompatible carried/read +eigenspaces under the stated fixed-content replacement scheme. + +## 1. A genuine Fourier implementation of an address shear + +For binary vectors `x,y` of length `f`, write `W_f[x,z]=(-1)^(x dot z)`. +Let `D_xy` multiply the entry at `(x,y)` by `(-1)^(x dot y)`. If `P_xy` +moves `(x,y)` to `(x xor y,y)`, then + + P_xy = 2^-f W_x D_xy W_x. (1) + +Indeed the matrix coefficient from `(z,y)` to `(x,y)` is +`2^-f sum_t (-1)^(t dot (x+y+z))`, which is one precisely when +`x=z+y`, and otherwise zero. This proof is valid on arbitrary arrays, +with arbitrary spectator fields and arbitrary initial payloads. + +Use the Gaussian-dyadic scaled Walsh operator + + J_f = ((1+i)/2)^f W_f = S_f C_f S_f, + J_f^2 = i^f I, S_f(x)=i^wt(x). + +The native `C_f` and its conversion to `J_f` are the literal operators in +`upstream/build/sections/05-layers.tex`, equations phase-basic-identities. +Equation (1) becomes + + P_xy = (-i)^f J_x D_xy J_x. (2) + +Thus this repair costs **two complete native children of width f**, plus +diagonal phases. All scalar factors and inverse normalizations are explicit. +There is no irrational arithmetic, truncation, free indexed access, or free +general binary permutation in this identity. + +The identity extends to a rectangular block shear `x -> x+B y` by replacing +`D_xy` with `(-1)^(x dot B y)`. The target x can contain t whole slots, +giving two native children of width `t*f`. + +### Fusion is allowed, but must follow the actual operator word + +Consecutive shears with the same target x and unchanged controls combine: + + (J_x D_1 J_x^-1)(J_x D_2 J_x^-1) + = J_x (D_1 D_2) J_x^-1. + +An arbitrary run of these operations costs two children, not two per row +addition. This also groups all source additions to one target into one +bilinear diagonal phase. If a control changes or an intervening scalar gate +needs a different physical frame, this cancellation requires a new proof. +The verifier includes a changing-target counterexample to unconditional +commutation. Full adjacent Clifford recipes should be composed before +charging their Fourier implementation. + +There is a further useful fusion for a complete interchange. On the joint +2f-bit address field let `H_2f=2^-f W_2f`, a real dyadic involution. Then + + SWAP_xy = (H_2f D_xy)^3. (3) + +At f=1, multiplying the four-by-four matrices proves the identity. Tensoring +over corresponding bit pairs proves it for all f, without assuming that +the input payload array is a tensor product. Also +`H_2f=(-i)^f S_2f C_2f S_2f`. Consequently (3) costs three native children +of width 2f. This is cheaper in an exponent moment than six width-f children: +at saving `a=1/9` its price is multiplied by `2^(-1/9)`. + +### Precision and the domain restriction + +If each payload is represented by B-bit integer or Gaussian-dyadic scalar +components and `B >= f`, these exact operations use `O(B+f)=O(B)` bits per +component. A Walsh sum adds at most f integer bits; the displayed dyadic +denominators add at most O(f) fractional bits. Bilinear phase evaluation +costs O(f) per record for a fixed-size block matrix, hence O(V) under this +domain. For a fixed finite supplier whose children have a uniform width +contraction ratio strictly below one, the sums of widths along a recursion +path are O(root width). This observation can support a guard +induction once the actual child and scalar schedule is supplied. + +For one-bit payloads and arbitrary growing address width, this argument +would expand volume by O(f). It therefore does **not** prove the existing +ordinary-interchange contract on all bit payloads. Nor does an already +proved layer on K-spaced selected axes automatically supply whole contiguous +chunks (K=1): the selected-bit layout domain must also be established. + +## 2. The recurrence must include the repair + +Let a complete supplier on m selected slots have W productive streams and +native child inventory `h_r`. With all volumes, guards and restorations +properly accounted for, its pure native moment at saving a is + + M_native(a) = (1/W) sum_r h_r (r/m)^(1-a). + +The source `notes/general-clifford-frames.tex` explicitly lowers a rank-r +edge to `P_L C_r P_R`, with affine binary address maps and quadratic phases +in `P_L,P_R`. Fourier rank zero means monomial; it does not imply linear +time on a fixed number of tapes. Section 05 uses the separate bit supplier +to implement these maps. + +For a self-contained complex supplier using (2), let `g_t` be the number +of **fused, fully scheduled** rectangular shears targeting t slots. Include +every entrance, exit, child adapter, routing and restoration operation. The +additional moment is + + M_adapters(a) = (2/W) sum_t g_t (t/m)^(1-a). (4) + +For each use of (3), add `3/W * (2t/m)^(1-a)` instead. These are genuine +recursive calls and must be proper children. A sufficient scalar recurrence +condition is + + M_native(a) + M_adapters(a) < 1, (5) + +plus the native physical/compiler, complete-volume, scalar, row, guard, +uniform shape and exact endpoint contracts. In the normalized recurrence, +the nonrecursive cost must be O(1) or otherwise strictly lower order than +the desired width exponent. This is a possible repair route: it replaces +the separate bit premise by an explicit augmented native invoice. + +Applying (2) to an existing complex supplier that itself calls the bit +supplier is circular unless (5), its proper recursion and its complete +shape contract are proved. In particular, the unaugmented native moment +cannot be reused unchanged. + +If a self-contained augmented supplier is actually completed on all whole +binary chunk shapes needed by the caller, with cost `O(V e^(1-s))` and +guarded payload width `B=Omega(e)`, equation (3) gives ordinary chunk +interchange on that same restricted domain in `O(V e^(1-s))`. There is +then no separate numerical bit endpoint: one can choose both `a9/80` would support the two hypothetical saving inputs +in section 3, subject to all of that caller's domain and analytic contracts. +This conditional reduction identifies a concrete way the bit cap could be +removed. It is not a reduction from the currently bit-dependent layer. + +For scale, the advertised optimistic d=3 paired-plane screen used +`m=73`, `W/N=896/9` and moment `0.995605075916` with the centre retained +(`0.984346481996` without). If every added fused shear targets one slot, +the allowable number per local invocation is less than approximately +`9.91457` with the centre, or `35.31299` without. These are sensitivities +using the published rounded moments, not new exact admissions. They do +not lower-bound the unknown best fused adapter program. The separate +copy-accounting audit already raises those d=3 moments above one before +these adapter costs are added. + +## 3. An explicit arithmetic extension admitting kappa=0.1 + +The selected outer engine is byte-identical to +`research/adaptive-kernel-demotion/vendor/engines/outer.py`, SHA-256 +`c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c`. +It checks 47 strict inequalities, including `b<1/32`. The prior +`docs/research/assembly-domain-audit.md` correctly distinguishes that +enforced domain from an impossibility result and from the retained +Gaussian restriction `r<1/4`. + +Here is a sufficient **displayed arithmetic region** beyond 1/32. Put + + 1/9 < a < 1/3, a < b < 1, + 0 < beta < 1-a/b, + 0 < eta < min(1/8, (9a-1)/(28a), (1-3a)/(2(1+a))). + +Retain all equations from the selected balanced engine: + + q=a(1-2eta), c=q+eta/4, epsilon=(1-eta)/(1+q), + G=epsilon*q, r=G+eta/2, delta=eta/8, + tau=1-a, sigma=1-b, + lambda=1-a+a*eta, lambdaPrime=1-q. + +Assume positive literal-scalar and row-product bridge slacks. Then **all +46 displayed constraints other than `b<1/32` are strictly positive at +kappa=1/10**. The verification below is an arithmetic lemma, not the +missing analytic domain extension. + +To see the target bound, multiplying `G>1/10` by its positive denominator +gives + + 9a-1-28a*eta+20a*eta^2 > 0, + +which follows from the second eta bound. Moreover `021/32`, giving `epsilon>a`, `epsilon>1/2`, and all elementary +width, fallback, cell and dimension comparisons. Since +`Ga`. Its leaf exponent is +`1-(1-beta)b`, strictly below tau. Hence all internal, leaf, lambda and +lambdaPrime gaps are positive. The reservation gap is `c-q=eta/4`. +The exact identities + + 1-epsilon=G+eta, + 1-epsilon-r=eta/2, + 1-epsilon*(1+c)=eta*(1-epsilon/4) + +give the remaining geometry, guard and phase inequalities. The seven +outer margins are respectively + + G+eta, a, G, a, G+3eta/8, G+7eta/8, epsilon. + +Their minimum is G. This also proves positivity of every margin minus +1/10. The artificial-boundary gap is `8-epsilon+3eta/8>7`. + +An explicit rational example is + + a=14/125, b=9/80, beta=1/1000, eta=1/100000, + q=349993/3125000, epsilon=4166625/4633324, + G=11666316669/115833100000, + r=23333791669/231666200000, + G-1/10=83006669/115833100000 > 0. + +Here G is approximately 0.100716605780. These a and b are hypothetical +supplier inputs, not established exponents. The unchanged strict engine +rejects the example solely at `b<1/32`; the diagnostic explicitly checks +that rejection before inspecting the other 46 inequalities. + +This closes the *displayed parameter-arithmetic* gap. The supplier, +stopping, router, uniform setup, finite row stock, guard, precision, +prime/Gaussian and coefficient-enclosure lemmas must still be checked in +this larger parameter domain. In particular, a moment engine restricted +to arguments below 1/4 must use justified range reduction: at b near .112 +even `b*log(73)` already exceeds that range. No production guard or +selected certificate is changed here. + +## Reproduction and open next questions + +Run `python3 -I -B research/kappa01-outer-repair/verify.py`. It authenticates +the exact source blobs, verifies the Walsh/shear and fused interchange +identities over rational coefficients, checks fusion and a noncommuting +control, and compares the independent outer fractions with an observed +execution of the unchanged source body. Its `RESULT.json` marks assumed +bridge and missing supplier/analytic premises explicitly. + +The remaining productive tasks are a source-bound adapter word minimized +by exact fusion, a strict augmented moment with all native children +included, and a complete dependency audit of the expanded outer region. +Without those, this package establishes no kappa improvement. + +Prepared with OpenAI assistance. Predecessor phase identities and native +frame contracts are retained and attributed to the source repository; +the outer equations credit Zhihao Chen, RaD/hipotures, icekylinx and eumemic +in their original source. New investigation is Apache-2.0. No independent +human review is claimed. diff --git a/research/kappa01-outer-repair/RESULT.json b/research/kappa01-outer-repair/RESULT.json new file mode 100644 index 0000000000..e230d9d595 --- /dev/null +++ b/research/kappa01-outer-repair/RESULT.json @@ -0,0 +1,109 @@ +{ + "status": "LOCAL EXACT IDENTITIES AND ARITHMETIC; NO KAPPA CLAIM", + "source_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "source_sha256": { + "research/adaptive-kernel-demotion/vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "docs/research/assembly-domain-audit.md": "2d01eb56cd206955adc462bb8401cfde427d91155d4ba9e8265ad3347564fc02" + }, + "operators": { + "character_entries": 37448, + "swap_basis_columns": 340, + "same_target_fusion_cases": 4680, + "gaussian_native_conversion": true, + "changing_target_control": true, + "all_f_proof": "Character orthogonality and tensoring of exact one-pair identity" + }, + "outer": { + "slacks": { + "bit_positive": "14/125", + "complex_above_bit": "1/2000", + "complex_below_one_over32": "-13/160", + "beta_positive": "1/1000", + "beta_below_one": "999/1000", + "leaf_saving_above_bit": "31/80000", + "q_positive": "349993/3125000", + "q_below_internal": "7/3125000", + "q_below_leaf": "19487/50000000", + "c_positive": "5600013/50000000", + "c_below_one": "44399987/50000000", + "q_below_reservations": "1/400000", + "lambda_above_tau": "7/6250000", + "lambda_above_sigma": "783/1562500", + "lambda_above_internal": "7/6250000", + "lambda_prime_above_lambda": "7/6250000", + "compact_leaf": "19487/50000000", + "compact_reservations": "1/400000", + "lambda_prime_below_one": "349993/3125000", + "epsilon_positive": "4166625/4633324", + "epsilon_below_one": "466699/4633324", + "guard_width": "466699/4633324", + "K_geometry": "14366671/1853329600000", + "K_dominates_log": "186665233329/1853329600000", + "record_suffix": "466699/4633324", + "phase_local": "93338641669/926664800000", + "phase_boundary": "18666801669/185332960000", + "gamma_sublinear": "1/200000", + "cell_above_band": "208330091669/463332400000", + "prime_interval_packing": "466699/4633324", + "alpha_positive": "23333791669/231666200000", + "alpha_below_one": "208332408331/231666200000", + "alpha_below_one_fourth": "34582758331/231666200000", + "delta_positive": "1/800000", + "delta_below_one_eighth": "99999/800000", + "short_record_fallback": "455961589/579165500", + "small_field_exposure": "1/100000", + "artificial_boundary": "6579996874993/926664800000", + "literal_scalar_guard": "1", + "row_product_gap": "1", + "balanced_prefix_above_kappa": "16833/23166620", + "coordinate_movement_above_kappa": "3/250", + "compact_phase_layer_above_kappa": "83006669/115833100000", + "bulk_exposure_above_kappa": "3/250", + "Gaussian_arithmetic_above_kappa": "133505669/185332960000", + "scalar_work_above_kappa": "672161669/926664800000", + "dimension_above_kappa": "18516463/23166620" + }, + "margins": { + "balanced_prefix": "466699/4633324", + "coordinate_movement": "14/125", + "compact_phase_layer": "11666316669/115833100000", + "bulk_exposure": "14/125", + "Gaussian_arithmetic": "18666801669/185332960000", + "scalar_work": "93338641669/926664800000", + "dimension": "4166625/4633324" + }, + "parameters": { + "a": "14/125", + "b": "9/80", + "beta": "1/1000", + "eta": "1/100000", + "kappa": "1/10", + "q": "349993/3125000", + "epsilon": "4166625/4633324", + "c": "5600013/50000000", + "r": "23333791669/231666200000", + "delta": "1/800000", + "G": "11666316669/115833100000" + }, + "gap": "83006669/115833100000", + "eta_upper_bounds": [ + "1/8", + "1/392", + "83/278" + ], + "original_engine_rejects": true, + "only_failed_original_constraint": { + "complex_below_one_over32": "-13/160" + }, + "controls": { + "endpoint_a_has_no_strict_target_margin": true, + "target_above_G_rejected": true, + "zero_eta_loses_strict_slack": true, + "leaf_ordering_is_required": true + }, + "bridge_status": "Positive scalar and row slacks assumed; no bridge validated", + "theorem_scope": "Displayed arithmetic only; no supplier or analytic domain extension" + } +} diff --git a/research/kappa01-outer-repair/adapter_fusion.py b/research/kappa01-outer-repair/adapter_fusion.py new file mode 100644 index 0000000000..957cd74123 --- /dev/null +++ b/research/kappa01-outer-repair/adapter_fusion.py @@ -0,0 +1,363 @@ +#!/usr/bin/env python3 +"""Compile actual local Walsh-retarget address maps into Fourier calls. + +This prices one concrete generalized-layout implementation, not an optimal +compiler or a whole supplier. Quadratic phases have a proved algebraic +completion in ADAPTER-FUSION.md; this executable does not emit or replay +that scalar phase program. The finite paid profile below records Fourier +children only. See that file for the exact scope and invariant. +""" +from collections import Counter +from decimal import Decimal, localcontext +from functools import lru_cache +from fractions import Fraction +import gzip +import hashlib +import json +from pathlib import Path +import subprocess + +ROOT = Path(__file__).resolve().parents[2] +OUT = Path(__file__).resolve().parent +BASE = "997e6a9ca7b4f95d50e366f61412fd640d72a88a" +SOURCE = "research/involutive-walsh-lift/evidence/WALSH-RETARGET-NATIVE.json.gz" +N = 9 +I = tuple(1 << i for i in range(N)) + + +def require(ok, what): + if not ok: + raise RuntimeError(what) + + +def mv(A, x): + return sum(((row & x).bit_count() & 1) << i for i, row in enumerate(A)) + + +def mm(A, B): + return tuple(xor(B[j] for j in range(N) if row >> j & 1) for row in A) + + +def xor(xs): + out = 0 + for x in xs: + out ^= x + return out + + +@lru_cache(maxsize=None) +def inv(A): + rows = [row | (1 << (N+i)) for i, row in enumerate(A)] + for j in range(N): + p = next(i for i in range(j, N) if rows[i] >> j & 1) + rows[p], rows[j] = rows[j], rows[p] + for i in range(N): + if i != j and rows[i] >> j & 1: + rows[i] ^= rows[j] + require(tuple(r & ((1 << N)-1) for r in rows) == I, "inverse") + return tuple(r >> N for r in rows) + + +def affine_mul(A, B): + # Composition A after B. + return mm(A[0], B[0]), mv(A[0], B[1]) ^ A[1] + + +def affine_inv(A): + return inv(A[0]), mv(inv(A[0]), A[1]) + + +def apply_op(rows, op): + if op[0] == "swap": + _, i, j = op + rows[i], rows[j] = rows[j], rows[i] + else: + require(op[0] == "shear", "op") + old = tuple(rows) + targets = {i for i, _ in op[1]} + require(all(not any(mask >> j & 1 for j in targets) for _,mask in op[1]), + "rectangular shear has unchanged controls") + for i, mask in op[1]: + rows[i] ^= xor(old[j] for j in range(N) if mask >> j & 1) + + +def fuse_ops(ops): + result = [] + for op in ops: + if op[0] != "shear" or not result or result[-1][0] != "shear": + result.append(op) + continue + previous = dict(result[-1][1]) + current = dict(op[1]) + targets = set(previous) | set(current) + controls = xor([]) # OR, not XOR: used only to test dependency. + for mask in list(previous.values())+list(current.values()): + controls |= mask + if any(controls >> j & 1 for j in targets): + result.append(op) + continue + for j, mask in current.items(): + previous[j] = previous.get(j, 0) ^ mask + previous = {j:mask for j,mask in previous.items() if mask} + if previous: + result[-1] = ("shear", tuple(sorted(previous.items()))) + else: + result.pop() + return tuple(result) + + +def reduce_word(A, mode): + rows = list(A) + ops = [] + if mode == "column": + for j in range(N): + p = next(i for i in range(j, N) if rows[i] >> j & 1) + if p != j: + op = ("swap", p, j) + apply_op(rows, op) + ops.append(op) + for i in range(N): + if i != j and rows[i] >> j & 1: + op = ("shear", ((i, 1 << j),)) + apply_op(rows, op) + ops.append(op) + else: + # Determine a row permutation giving a unit-pivot LU decomposition. + work, permutation = list(A), list(range(N)) + for j in range(N): + p = next(i for i in range(j, N) if work[i] >> j & 1) + work[p], work[j] = work[j], work[p] + permutation[p], permutation[j] = permutation[j], permutation[p] + for i in range(j+1, N): + if work[i] >> j & 1: + work[i] ^= work[j] + labels = list(range(N)) + for i, label in enumerate(permutation): + j = labels.index(label) + if j != i: + op = ("swap", i, j) + apply_op(rows, op) + ops.append(op) + labels[i], labels[j] = labels[j], labels[i] + for indices in (range(N), range(N-1, -1, -1)): + forward = isinstance(indices, range) and indices.step == 1 + for i in indices: + mask = 0 + for j in (range(i) if forward else range(i+1, N)): + if rows[i] >> j & 1: + rows[i] ^= rows[j] + mask ^= 1 << j + require(rows[i] >> i & 1, "unit LU pivot") + if mask: + ops.append(("shear", ((i, mask),))) + require(tuple(rows) == I, "word reduces the exact source matrix") + # Every op is involutive; reverse the reduction to implement A. + return fuse_ops(tuple(reversed(ops))) + + +def profile(ops): + result = Counter() + for op in ops: + if op[0] == "swap": + result[2] += 3 + else: + result[len(op[1])] += 2 + return result + + +def score(hist): + # Numerical choice among exact valid programs. It affects optimality only. + return sum(count * rank ** (8/9) for rank, count in hist.items()) + + +@lru_cache(maxsize=None) +def synthesize(A): + candidates = [] + # Exact dense rectangular block shear, without decomposing its rows. + changed = tuple(i for i in range(N) if A[i] != (1 << i)) + controls = tuple((i, A[i] ^ (1 << i)) for i in changed) + if all(not any(mask >> j & 1 for j in changed) for _,mask in controls): + candidates.append((("shear", controls),) if controls else ()) + for mode in ("column", "lu"): + candidates.append(reduce_word(A, mode)) + candidates.append(fuse_ops(tuple(reversed(reduce_word(inv(A), mode))))) + ops = min(candidates, key=lambda word:(score(profile(word)), len(word), word)) + rows = list(I) + for op in ops: + apply_op(rows, op) + require(tuple(rows) == A, "compiled exact address matrix") + return ops + + +def perm(record): + return tuple(record["matrix_rows"]), record["offset"] + + +def normalize(hist): + return dict(sorted(hist.items())) + + +def compile_program(program, recipes, policy): + start = program.index(["phase", "A"])+1 + end = program.index(["phase", "exit_adapters"]) + events = program[start:end] + pending = [(I,0) for _ in range(712)] + native, extra, charged_linear, charged_offsets = Counter(), Counter(), Counter(), Counter() + counts, nonidentity_by_reason = Counter(), Counter() + fingerprint = hashlib.sha256() + + def charge(A, why, offset=True): + word = synthesize(A[0]) + ph = profile(word) + extra.update(ph) + charged_linear.update(ph) + if offset and A[1]: + rank = A[1].bit_count() + extra[rank] += 2 + charged_offsets[rank] += 2 + counts["translation_jobs"] += 1 + if word: + counts["nonidentity_linear_jobs"] += 1 + nonidentity_by_reason[why] += 1 + counts[why] += 1 + fingerprint.update(repr((why,A,word,offset)).encode()) + + def reg(arg): + return arg[1]+(704 if arg[0] == "C" else 0) + + for event in events: + kind = event[0] + if kind in ("climb", "center"): + if kind == "climb": + r, old, new, rank = event[2:] + else: + r, old, new, rank = event[1:] + r += 704 + record = recipes[(old,new,rank)] + left, right = perm(record["left"]), perm(record["right"]) + native[rank] += 1 + if policy == "literal": + charge(right, "right_adapter") + charge(left, "left_adapter") + else: + combined = affine_mul(right, pending[r]) + # All binary translations commute with coordinate C_r. + # Push that translation through the child into its left map. + charge((combined[0],0), "fused_child_entrance") + pending[r] = affine_mul(left, (I,combined[1])) + elif kind == "scalar": + gate = event[1] + tag, target = gate[0], reg(gate[1]) + counts["scalar_"+tag] += 1 + if policy == "literal": + continue + if tag == "scale": + continue # Every address permutation commutes with a scale. + if tag == "clear": + pending[target] = (I,0) + continue + source = reg(gate[2]) + if tag == "copy": + pending[target] = pending[source] + continue + require(tag == "add", "expected interior scalar opcode") + if pending[target] == pending[source]: + counts["already_common_layout_adds"] += 1 + continue + if policy == "flush": + charge(pending[target], "scalar_flush") + charge(pending[source], "scalar_flush") + pending[target] = pending[source] = (I,0) + continue + # One actual relative map suffices; compare both legal choices. + to_target = affine_mul(affine_inv(pending[target]), pending[source]) + to_source = affine_mul(affine_inv(pending[source]), pending[target]) + def cost(A): + ph = profile(synthesize(A[0])) + if A[1]: ph[A[1].bit_count()] += 2 + return score(ph) + if (cost(to_target),repr(to_target)) <= (cost(to_source),repr(to_source)): + charge(to_target, "relative_alignment") + # Check the representation invariant for the changed source. + require(affine_mul(pending[target],to_target) == pending[source], + "source relative alignment") + pending[source] = pending[target] + else: + charge(to_source, "relative_alignment") + require(affine_mul(pending[source],to_source) == pending[target], + "target relative alignment") + pending[target] = pending[source] + else: + require(kind == "phase", "unpriced event in the chosen interior") + before_exit = extra.copy() + if policy != "literal": + for A in pending: + if A != (I,0): + charge(A, "returned_layout") + expected = Counter({1:2412,2:418,3:432,4:142,5:82,8:8}) + require(native == expected, "exact source child inventory") + combined = native+extra + with localcontext() as ctx: + ctx.prec = 60 + m, streams_per_invocation = Decimal(73), Decimal(896)/9 + def moment(hist): + return sum(Decimal(n)*(Decimal(r)/m)**(Decimal(8)/9) + for r,n in hist.items())/streams_per_invocation + numerical = dict(native_only=str(moment(native)), + augmented_interior_only=str(moment(combined)), + augmented_even_if_boundary_layouts_free=str(moment(native+before_exit))) + mass = sum(r*n for r,n in combined.items()) + # This is an exact exclusion for this compiler: t^(8/9) >= t on (0,1]. + linear_floor = Fraction(mass*9,73*896) + boundary_count = sum(nonidentity_by_reason.values()) + interior_boundary_count = boundary_count - nonidentity_by_reason["returned_layout"] + independent_boundary_floor = Fraction(2*interior_boundary_count*9,73*896) + return dict(policy=policy, start_event_inclusive=start, end_event_exclusive=end, + event_count=len(events), native_profile=normalize(native), + added_linear_profile=normalize(charged_linear), + added_translation_profile=normalize(charged_offsets), + augmented_profile=normalize(combined), rank_mass=mass, + exact_normalized_linear_rank_floor=str(linear_floor), + target_moment_exceeds_one_from_exact_floor=linear_floor>1, + diagnostic_decimal_moments=numerical, + nonidentity_linear_jobs_by_reason=dict(sorted(nonidentity_by_reason.items())), + independent_single_array_boundary_floor=dict( + interior_nonidentity_maps=interior_boundary_count, + minimum_fourier_calls=2*interior_boundary_count, + exact_adapter_only_normalized_rank_floor=str(independent_boundary_floor), + exceeds_one=independent_boundary_floor>1, + scope="Only implementations keeping these independent monomial boundaries; no auxiliary arrays or cross-child fusion"), + events=dict(sorted(counts.items())), program_sha256=fingerprint.hexdigest()) + + +def main(): + raw = subprocess.check_output(["git","show",BASE+":"+SOURCE],cwd=ROOT) + data = json.loads(gzip.decompress(raw)) + recipes = {} + for record in data["children"]: + key = record["old"],record["new"],record["rank"] + require(key not in recipes, "unique native recipe") + recipes[key] = record + results = {} + for orientation, program in sorted(data["programs"].items()): + results[orientation] = [compile_program(program,recipes,policy) + for policy in ("literal","flush","relative")] + result = dict(status="EXACT CONCRETE ADAPTER COMPILER; NO OPTIMALITY OR SUPPLIER CLAIM", + source_commit=BASE, source_path=SOURCE, + source_sha256=hashlib.sha256(raw).hexdigest(), + source_recipe_count=len(recipes), orientation_results=results, + distinct_linear_maps_compiled=synthesize.cache_info().currsize, + scope=["Canonical-frame local interior only; external normalization and global jobs omitted", + "Recursive Fourier calls may target arbitrary subsets; uniform physical shape theorem still required", + "Monomial phases retained by algebraic conjugation, scalar/guard costs not replayed", + "Compiler choice uses floats only to choose among exact validated programs", + "Failure is proved by exact rank mass, not the diagnostic decimal moments"]) + (OUT/"ADAPTER-RESULT.json").write_text(json.dumps(result,indent=2)+"\n") + for orientation, rows in results.items(): + print(orientation,[(r["policy"],r["rank_mass"], + r["diagnostic_decimal_moments"]["augmented_interior_only"][:16])for r in rows]) + print("PASS exact matrix compiler and deferred-layout invariants; every concrete profile fails.") + + +if __name__ == "__main__": + main() diff --git a/research/kappa01-outer-repair/convolution_frames.py b/research/kappa01-outer-repair/convolution_frames.py new file mode 100644 index 0000000000..28ae7bc90a --- /dev/null +++ b/research/kappa01-outer-repair/convolution_frames.py @@ -0,0 +1,245 @@ +#!/usr/bin/env python3 +"""Exact source-carry / target-read probes for symmetric convolution frames.""" +from collections import Counter +from fractions import Fraction +import gzip +import hashlib +import io +import json +from pathlib import Path +import subprocess +import tarfile + +ROOT = Path(__file__).resolve().parents[2] +BASE = '997e6a9ca7b4f95d50e366f61412fd640d72a88a' +N = 9 + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def blob(path): + return subprocess.check_output(['git', 'show', BASE+':'+path], cwd=ROOT) + + +def basis(vectors): + pivots = {} + for x in vectors: + while x: + p = x.bit_length()-1 + if p in pivots: + x ^= pivots[p] + else: + pivots[p] = x + break + return list(pivots.values()) + + +def contains(vectors, x): + return len(basis(list(vectors)+[x])) == len(basis(vectors)) + + +def dot(x, y): + return (x & y).bit_count() & 1 + + +def radical_dimension(vectors): + vectors = basis(vectors) + gram = [sum(dot(a,b) << j for j,b in enumerate(vectors)) for a in vectors] + return len(vectors)-len(basis(gram)) + + +def symmetric_solution(carry, read): + positions = [(i,j) for i in range(N) for j in range(i,N)] + index = {pair:k for k,pair in enumerate(positions)} + eq = [] + for vectors, value in ((carry, 1), (read, 0)): + for q in basis(vectors): + for i in range(N): + mask = sum(1 << index[tuple(sorted((i,j)))] for j in range(N) if q >> j & 1) + eq.append(mask | ((value * (q >> i & 1)) << len(positions))) + pivots = {} + varmask = (1 << len(positions))-1 + for row in eq: + while row & varmask: + p = (row & varmask).bit_length()-1 + if p in pivots: + row ^= pivots[p] + else: + pivots[p] = row + break + else: + if row: + return None + solution = 0 + for p in sorted(pivots): + row = pivots[p] + value = ((row >> len(positions)) ^ ((row & solution).bit_count() & 1)) & 1 + solution |= value << p + matrix = [0]*N + for k,(i,j) in enumerate(positions): + if solution >> k & 1: + matrix[i] |= 1 << j + matrix[j] |= 1 << i + def mv(q): + return sum(dot(row,q) << i for i,row in enumerate(matrix)) + require(all(mv(q)==q for q in carry), 'source eigenvalue') + require(all(mv(q)==0 for q in read), 'target eigenvalue') + return matrix + + +def reg(address): + return address[1] + (704 if address[0]=='C' else 0) + + +def add(a,b,c): + result = a.copy() + for key, value in b.items(): + result[key] = result.get(key, 0)+c*value + if not result[key]: + del result[key] + return result + + +def apply(rows, op, reverse=False): + kind = op[0] + d = reg(op[1]) + if kind in ('add','copy'): + s = reg(op[2]) + if kind=='add': + c = Fraction(op[3],op[4]) + if reverse: + rows[s] = add(rows[s],rows[d],c) + else: + rows[d] = add(rows[d],rows[s],c) + elif kind=='scale': + c = Fraction(op[2],op[3]) + rows[d] = {key:c*value for key,value in rows[d].items() if c*value} + elif kind=='copy': + if reverse: + rows[s] = add(rows[s],rows[d],1) + rows[d] = {} + else: + rows[d] = rows[s].copy() + elif kind=='clear': + rows[d] = {} + else: + raise RuntimeError(kind) + + +def main(): + archive = blob('research/community-frontier1042-audit/selected-replay.tar.gz') + require(hashlib.sha256(archive).hexdigest()=='22c3f4dce4b897a1d423d1388801933e288b6a6b1906cb15e1b16a5eb68db754','archive pin') + with tarfile.open(fileobj=io.BytesIO(archive)) as t: + raw = t.extractfile('slots/local/CANONICAL-WORD.json.gz').read() + require(hashlib.sha256(raw).hexdigest()=='16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219','word pin') + word = json.loads(gzip.decompress(raw)) + native_raw = blob('research/involutive-walsh-lift/evidence/WALSH-RETARGET-NATIVE.json.gz') + require(hashlib.sha256(native_raw).hexdigest()=='5bfd2c228533e0d20d62b867ef9c1b57c235399478232e1beee875d6838051db','native program pin') + native = json.loads(gzip.decompress(native_raw)) + p = native['programs']['forward'] + frames = word['frames'] + labels = word['ports'] + require(len(set(labels))==112 and all(dot(q,q) for q in labels), 'distinct norm-one source labels') + native_code = blob('research/involutive-walsh-lift/native.py') + require(hashlib.sha256(native_code).hexdigest()=='8134106fb8a9ee8b065c51d950b41ef31ff3486a9d4da71f33c6a406ee054698','native Clifford checker pin') + namespace = {} + exec(compile(native_code, 'pinned-native.py', 'exec', optimize=0), namespace) + native_tableau = namespace['tableau'](namespace['frame']([30],N)) + require(native_tableau[1]==(28,14,0), 'actual frame30 fails translation commutation') + frame_radicals = Counter(radical_dimension(f) for f in frames) + degenerate_climbs = sum(e[0]=='climb' and (radical_dimension(frames[e[3]]) or radical_dimension(frames[e[4]]))>0 for e in p) + start = p.index(['phase','A']) + end = p.index(['phase','exit_adapters']) + # Inspect every helper state immediately after a native frame transition, + # plus the helper entrances. These are scalar-coordinate sensitivities. + checkpoints = {start: [(r,word['start'][r]) for r in range(224,704)]} + for i in range(start+1,end): + e = p[i] + if e[0]=='climb' and e[2]>=224: + checkpoints[i] = [(e[2],e[4])] + rows = [{} for _ in range(712)] + for j in range(112): + rows[112+j] = {j:Fraction(1)} + readers = {} + for i in range(len(p)-1,-1,-1): + if i in checkpoints: + for r,f in checkpoints[i]: + readers[i,r] = rows[r].copy() + if p[i][0]=='scalar': + apply(rows,p[i][1],True) + require(all(rows[j]=={j:Fraction(1)} and rows[112+j]=={j:Fraction(1)} for j in range(112)), 'complete target scalar Jacobian') + require(all(not rows[j] for j in range(224,712)), 'dirty helper sensitivity cancels') + rows = [{} for _ in range(712)] + for j in range(112): + rows[j] = {j:Fraction(1)} + counts = Counter() + records = [] + for i,e in enumerate(p): + if e[0]=='scalar': + apply(rows,e[1]) + if i not in checkpoints: + continue + for r,f in checkpoints[i]: + carry_ports = list(rows[r]) + read_ports = list(readers[i,r]) + carry = basis(labels[j] for j in carry_ports) + read = basis(labels[j] for j in read_ports) + solution = symmetric_solution(carry,read) + orthogonal = all(not dot(c,q) for c in carry for q in read) + intersection = len(carry)+len(read)-len(basis(carry+read)) + fits_source = all(contains(frames[f],q) for q in carry) + fits_target = all(not dot(q,u) for q in read for u in frames[f]) + require((solution is not None)==(orthogonal and intersection==0), 'symmetric feasibility iff compatibility') + key = (solution is not None,orthogonal,intersection>0,fits_source,fits_target) + counts[str(key)] += 1 + if (i,r) in ((13759,445),(9466,228),(15459,283)): + records.append(dict(event=i,role=r,frame=f,frame_basis=frames[f], + event_contents=e,next_event=p[i+1],timing='after event, before next event; zero-based program indices', + carry_basis=carry,read_basis=read,carry_ports=carry_ports,read_ports=read_ports, + carry_coefficients=[dict(port=j,label=labels[j],coefficient=str(rows[r][j])) for j in sorted(rows[r])], + read_coefficients=[dict(port=j,label=labels[j],coefficient=str(readers[i,r][j])) for j in sorted(readers[i,r])], + carry_radical_dimension=radical_dimension(carry),frame_radical_dimension=radical_dimension(frames[f]), + orthogonal=orthogonal,intersection_dimension=intersection, + canonical_contains_carry=fits_source,canonical_orthogonal_to_read=fits_target, + symmetric_matrix=solution)) + require(all(rows[j]=={j:Fraction(1)} and rows[112+j]=={j:Fraction(1)} for j in range(112)), 'complete source scalar Jacobian') + require(all(not rows[j] for j in range(224,712)), 'source material cleaned from helpers') + require(len(records)==3, 'three fixed witnesses') + negative = next(r for r in records if r['role']==445) + require(set(negative['carry_ports'])=={46,20} and set(negative['read_ports'])=={25,2}, 'negative support witness') + require(labels[46]^labels[20]==labels[25]^labels[2]==45, 'shared nonzero carry-reader vector') + positive = next(r for r in records if r['role']==283) + require(positive['carry_radical_dimension']>0 and positive['symmetric_matrix'] is not None, 'degenerate carry still admits a symmetric frame') + # Exhaust all 16 binary subspaces in dimension three and all 256 pairs. + spaces = {} + for subset in range(128): + b = basis(q for q in range(1,8) if subset >> (q-1) & 1) + key = tuple(q for q in range(8) if contains(b,q)) + spaces[key] = b + require(len(spaces)==16, 'complete F2^3 subspace census') + for carry in spaces.values(): + for read in spaces.values(): + expected = all(not dot(c,r) for c in carry for r in read) and len(basis(carry+read))==len(carry)+len(read) + require((symmetric_solution(carry,read) is not None)==expected, 'small exhaustive solver control') + out=dict(status='POINTWISE CONTENT-CONSTRAINT AUDIT; NO UNIVERSAL COMPLEX-CIRCUIT OBSTRUCTION', + source_commit=BASE,checkpoint_count=sum(map(len,checkpoints.values())), + counts_key=['symmetric_solution_exists','orthogonal','nonzero_intersection','canonical_contains_carry','canonical_orthogonal_to_read'], + counts=dict(counts),records=records, + frame_radical_dimensions=dict(frame_radicals),degenerate_persistent_climb_occurrences=degenerate_climbs, + original_frame30_X2_conjugate=dict(X=28,Z=14,phase_mod4=0), + controls=dict(full_prefix_and_suffix_scalar_jacobians='exact Fraction replay',small_subspace_pairs=256), + limits=['Scalar Jacobian labels become necessary constraints only within the stated fixed carry/read model.', + 'Pointwise feasibility alone gives no common frame at gates, transition budget, exact phase lift, or supplier.', + 'Independent changes of scalar schedule, content representation, nonconvolution operations, and arbitrary complex circuits remain open.']) + (Path(__file__).resolve().parent/'CONVOLUTION-RESULT.json').write_text(json.dumps(out,indent=2)+'\n') + print(dict(counts)) + for record in records: + print('witness', record['event'],record['role'],'carry',record['carry_basis'],'read',record['read_basis'],'feasible',record['symmetric_matrix'] is not None) + print('PASS pinned scalar replay, 2886 helper checkpoints, symmetric constraints, and 256 independent small-pair controls') + + +if __name__=='__main__': + main() diff --git a/research/kappa01-outer-repair/verify.py b/research/kappa01-outer-repair/verify.py new file mode 100644 index 0000000000..622d947db8 --- /dev/null +++ b/research/kappa01-outer-repair/verify.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +"""Exact identities and a scoped outer-arithmetic extension; no supplier claim.""" +from __future__ import annotations + +import ast +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path +import subprocess + +BASE = "997e6a9ca7b4f95d50e366f61412fd640d72a88a" +ROOT = Path(__file__).resolve().parents[2] +OUT = Path(__file__).resolve().parent +ENGINE = "research/adaptive-kernel-demotion/vendor/engines/outer.py" +ENGINE_SHA = "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def blob(path): + return subprocess.check_output(["git", "show", BASE + ":" + path], cwd=ROOT) + + +def walsh(values): + out = list(values) + width = 1 + while width < len(out): + for start in range(0, len(out), 2 * width): + for j in range(width): + u, v = out[start+j], out[start+j+width] + out[start+j], out[start+j+width] = u+v, u-v + width *= 2 + return out + + +def parity(x): + return x.bit_count() & 1 + + +def operator_checks(): + # Each checked entry is the exact character sum in the written proof. + character_entries = 0 + for f in range(1, 6): + n = 1 << f + for y in range(n): + for z in range(n): + basis = [int(t == z) for t in range(n)] + stage = walsh(basis) + stage = [v * (-1 if parity(t & y) else 1) + for t, v in enumerate(stage)] + result = walsh(stage) + require(result == [n*int(x == (z ^ y)) for x in range(n)], + "Walsh shear operator entry") + character_entries += n + + # Literal Gaussian dyadic one-qubit C and S, with pairs (real, imag). + def add(x, y): return (x[0]+y[0], x[1]+y[1]) + def mul(x, y): return (x[0]*y[0]-x[1]*y[1], x[0]*y[1]+x[1]*y[0]) + def mm(A, B): + return [[add(mul(A[i][0], B[0][j]), mul(A[i][1], B[1][j])) + for j in range(2)] for i in range(2)] + zero, one, unit_i = (Q(0), Q(0)), (Q(1), Q(0)), (Q(0), Q(1)) + plus, minus = (Q(1,2), Q(1,2)), (Q(1,2), Q(-1,2)) + C = [[plus, minus], [minus, plus]] + S = [[one, zero], [zero, unit_i]] + J = mm(mm(S, C), S) + require(J == [[plus, plus], [plus, (-plus[0], -plus[1])]], "S C S") + require(mm(J, J) == [[unit_i, zero], [zero, unit_i]], "J squared") + + swap_columns = 0 + for f in range(1, 5): + n, dim = 1 << f, 1 << (2*f) + for j in range(dim): + v = [Q(int(k == j)) for k in range(dim)] + # H_2f D, rightmost factor first, repeated three times. + for _ in range(3): + v = [value * (-1 if parity((k // n) & (k % n)) else 1) + for k, value in enumerate(v)] + v = [value / n for value in walsh(v)] + target = (j % n)*n + j // n + require(v == [int(k == target) for k in range(dim)], + "three full Walsh transforms implement SWAP") + swap_columns += 1 + + # Same-target fusion holds for arbitrary independent control values. + fused_cases = 0 + for f in range(1, 5): + for x in range(1 << f): + for y in range(1 << f): + for z in range(1 << f): + require((x ^ y) ^ z == x ^ (y ^ z), "same-target fusion") + require(parity(x & y) ^ parity(x & z) == parity(x & (y ^ z)), + "bilinear diagonal multiplication") + fused_cases += 1 + # Changing-target CNOTs need not commute: (0,1) is a witness. + xy = (0, 1) + first_xy = (xy[0] ^ xy[1], xy[1]) + first_xy = (first_xy[0], first_xy[1] ^ first_xy[0]) + first_yx = (xy[0], xy[1] ^ xy[0]) + first_yx = (first_yx[0] ^ first_yx[1], first_yx[1]) + require(first_xy != first_yx, "changing-target control") + return dict(character_entries=character_entries, swap_basis_columns=swap_columns, + same_target_fusion_cases=fused_cases, + gaussian_native_conversion=True, changing_target_control=True, + all_f_proof="Character orthogonality and tensoring of exact one-pair identity") + + +def independent_outer(a, b, beta, eta, kappa): + tau, sigma = 1-a, 1-b + q = a*(1-2*eta) + eps, c = (1-eta)/(1+q), q+eta/4 + G = eps*q + r, delta = G+eta/2, eta/8 + lam, lp = 1-a+a*eta, 1-q + internal, leaf = tau+(1-beta)*max(sigma-tau, Q(0)), sigma+beta*(1-sigma) + margins = dict(balanced_prefix=G+eta, coordinate_movement=a, + compact_phase_layer=G, bulk_exposure=a, + Gaussian_arithmetic=G+3*eta/8, + scalar_work=G+7*eta/8, dimension=eps) + slacks = dict(bit_positive=a, complex_above_bit=b-a, + complex_below_one_over32=Q(1,32)-b, beta_positive=beta, + beta_below_one=1-beta, leaf_saving_above_bit=(1-beta)*b-a, + q_positive=q, q_below_internal=1-internal-q, q_below_leaf=1-leaf-q, + c_positive=c, c_below_one=1-c, q_below_reservations=c-q, + lambda_above_tau=lam-tau, lambda_above_sigma=lam-sigma, + lambda_above_internal=lam-internal, lambda_prime_above_lambda=lp-lam, + compact_leaf=lp-leaf, compact_reservations=lp-(1-c), + lambda_prime_below_one=q, epsilon_positive=eps, epsilon_below_one=1-eps, + guard_width=1-eps, K_geometry=1-eps*(1+c), K_dominates_log=eps*c, + record_suffix=1-eps, phase_local=1-eps-delta, phase_boundary=r-delta, + gamma_sublinear=1-eps-r, cell_above_band=eps-(1-r)/2, + prime_interval_packing=1-eps, alpha_positive=r, alpha_below_one=1-r, + alpha_below_one_fourth=Q(1,4)-r, delta_positive=delta, + delta_below_one_eighth=Q(1,8)-delta, short_record_fallback=eps-a, + small_field_exposure=1-eps-G, artificial_boundary=8-eps+r-delta-G, + literal_scalar_guard=Q(1), row_product_gap=Q(1)) + slacks.update({key+"_above_kappa": value-kappa for key,value in margins.items()}) + return dict(slacks=slacks, margins=margins, + parameters=dict(a=a,b=b,beta=beta,eta=eta,kappa=kappa,q=q, + epsilon=eps,c=c,r=r,delta=delta,G=G), + gap=G-kappa) + + +def outer_checks(source): + a, b, beta, eta, kappa = Q(14,125), Q(9,80), Q(1,1000), Q(1,100000), Q(1,10) + eta_bounds = [Q(1,8), (9*a-1)/(28*a), (1-3*a)/(2*(1+a))] + require(Q(1,9) 1/9`**. Failure already at `a = 1/9` therefore suffices to +reject the proposed profile. A passing row at that boundary is only a +necessary local screen; its strict margin, complete construction and the +bit side would still need checking. + +## 1. What the existing exact algebra establishes + +The [block fitting theorem](../paired-plane-block-rank/README.md) fixes the +same 56 two-dimensional binary planes and the same forbidden matrix blocks. +Its parameter `d` is the dimension of the arbitrary field-vector payload at +each port. The minimum scalar query rank is `49d`. The theorem explicitly +distinguishes this quantity from native child rank, physical copy cost and +the dimensions of the binary planes. + +The credited rank-49 attainer partitions the 112 ports into 49 supports, +of sizes `{1:2, 2:31, 3:16}`. Within a support all complete binary planes are +pairwise orthogonal and nondegenerate. The full plane-span Gram matrix is +`I_(2s)` for support size `s`, so its inherited one-total copy charge is `2s`. +The resulting occurrence profile is + +``` +{2:2, 4:31, 6:16}, total private rank mass = 224. +``` + +The verifier reconstructs this from the pinned native labels, matching and +supports; it does not accept an asserted copy histogram. This prices this +particular disjoint-support implementation. It is not a lower bound of 224 +for every jointly mixed fractional or nonlinear decoder. + +## 2. The missing total-mass charge + +Write `m=73`, `W=896`, `N=9`, and `w=W/N=896/9`. In the retained coverage +model, with `u` unpaid geometric coordinates per live family and `C` extra +private rank mass per invocation, + +``` +total paid mass per invocation = (m-u)w + C, +idle mass = total paid mass - explicitly listed local mass. +``` + +The original [plane-native invoice](../paired-plane-native-payload/README.md) +already records the relevant distinction: its two-unpaid version has total +mass `(m-2)W + 224N`, not `(m-2)W`. The +[earlier plane screen](../paired-plane-port-matching-seed6c563a/PROOF.md) +also places its proposed copy charge in both the local histogram and the +total paid-mass coverage law. These are two descriptions of the same work, +not two payments. The local histogram tells the moment which ranks carry +that mass; the total charge prevents private work from replacing unrelated +public work in the idle remainder. + +In `block_anchor_case` of the [κ = 0.1 screen](../kappa010-complex-lever-floor/verify.py), +the new `{2:2d,4:31d,6:16d}` profile is included in local mass, but the +coverage-law charge remains only zero or the old 64. Therefore insertion of +each 224-unit private decoder incorrectly *removes* 224 units of idle public +work. A realization could justify that removal only by giving an explicit +replacement of those public operations, with endpoints and their new +coverage law checked. Neither the block-rank theorem nor the native +private-copy receipt supplies such a replacement. + +The accounting repair sets `C=224d+C_old` while keeping the private profile +in local mass. Inserting private work then leaves public idle mass invariant. +For a direct comparison, continue granting the unsupported `u=2d` law, +seven anchor substitutions, all their scalar work outside the child moment, +and fractional rank-51 packing of all 3,982 remaining public local units: + +| d | Granted u | Original, centre free | Repaired, centre free | Original, centre 64 | Repaired, centre 64 | +|---:|---:|---:|---:|---:|---:| +| 1 | 2 | 1.021884022053 | 1.053958936878 | 1.033142615974 | 1.065217530798 | +| 2 | 4 | 1.003115252025 | 1.067265081674 | 1.014373845945 | 1.078523675594 | +| 3 | 6 | 0.984346481996 | 1.080571226470 | 0.995605075916 | 1.091829820390 | +| 4 | 8 | 0.965577711968 | 1.093877371265 | 0.976836305888 | 1.105135965186 | +| 5 | 10 | 0.946808941939 | 1.107183516061 | 0.958067535859 | 1.118442109981 | +| 6 | 12 | 0.928040171910 | 1.120489660857 | 0.939298765830 | 1.131748254777 | +| 7 | 14 | 0.909271401882 | 1.133795805653 | 0.920529995802 | 1.145054399573 | + +Each number is displayed from an outward-rational interval stored in +`RESULT.json`, using the source-pinned exact engine. All repaired lower +endpoints exceed one. + +There is a simpler packing-independent obstruction. Even retaining the +unjustified `u=2d` benefit, the centre-free total moment at zero saving is +exactly + +``` +[(73-2d)W + 224d N] / (73W) = 1 + d/292 > 1. +``` + +For any positive saving and any positive child rank below `m`, +`(r/m)^(1-a) >= r/m`. Thus this *repaired fixed-invoice construction* +cannot support any positive saving, even if its public consumer were much +better than the proposed rank-51 relaxation. Retaining the centre adds the +further positive term `64N/(73W)`. + +## 3. Payload replication and geometric enlargement are different repairs + +There are three different meanings a proposed tensor operation might have: + +1. **Vector payloads in the fitting theorem.** The planes stay two-dimensional. + The theorem gives no implication `u=2d` and no native cost conversion from + its rank `49d`. An array already carries many field-coordinate payloads; + its payload dimension is not its unpaid geometric dimension. +2. **Literal independent copies of the same arrays.** Replicate every public + and private operation, count `W'=dW`, keep `u=2`, and charge `C'=224d`. + The normalized moment is unchanged because both numerator and denominator + scale by `d`. The verifier checks exact interval equality for `d=1,2,3,7`. + Replicating entire invocations instead also changes `N` and leaves the + per-invocation normalized contract unchanged. +3. **True larger geometric subspaces.** Replace each `E_i` by a nondegenerate + subspace of dimension `2d`. This needs a new native chart, ambient dimension, + entry and exit words, public coverage and private-copy invoice. It cannot + retain the current nine-dimensional chart and the same support attainer: + a size-three support requires three pairwise orthogonal nondegenerate + `2d`-spaces, so the ambient dimension is at least `6d`. Already `d=2` + requires twelve dimensions. A full direct-sum lift of the original + nine-dimensional geometry has ambient dimension `9d` and also changes + its native ranks and template parameters. + +This audit implements the first two consistent accounting interpretations. +The third is a separate construction problem, not a repaired use of the +old numerical row. + +## 4. A second necessary gate for the unchanged native data legs + +The [native implementation](../paired-plane-native-payload/README.md) uses, +for each of 112 ports, a source transition `E -> FULL` of rank seven and a +target transition `0 -> E^perp` of rank seven. Thus it retains 224 separate +rank-seven public child occurrences before pricing its private copies. + +Assume those public legs remain separate and grant `u=2`, zero decoder and +centre cost, and arbitrary positive ranks below `m` for all other work. +Charge the other work only its linear rank-mass baseline, which is even +more favorable than rank-51 packing. The full moment is at least + +``` +L = 71/73 + (224/w)[(7/73)^(8/9) - 7/73] + = 1.036807899645622... > 1. +``` + +The interval checker verifies this bound. Independently, elementary exact +rational arithmetic proves `L>1` because it is equivalent to + +``` +(73/7)^(1/9) > 71/63, +``` + +and `(71/63)^9 < 73/7` holds exactly. Factoring a rank-seven leg into smaller +children cannot lower this particular lower bound when the factors' ranks +sum to at least seven: for `0= (sum x_i)^p`. + +This excludes κ = 0.1 for the retained **separate native-leg interface**, even +if a new decoder were free. It does not exclude a genuinely fused consumer +that changes those mandatory occurrences, different geometry, different +coverage, or another outer reduction. The speculative rank-51 public +repacking in the predecessor already grants such a changed consumer; +the present gate must not be imposed on it as if that assumption were proved. + +## Verification, sources and limits + +Run from this worktree: + +```sh +python3 -I -B research/kappa01-plane-audit/verify.py +``` + +The script authenticates every source in `SOURCES.json` before importing +the interval engine. It reconstructs the plane support profile, reproduces +the predecessor's three-copy numerical pass, repairs the charge, checks all +seven rows, proves the exact zero-saving obstruction, checks replication +invariance, and establishes the scoped native-leg gate. Five controls reject +an omitted private charge, replacement of the old centre charge, interpreting +payload copies as unpaid dimensions, omitting replicated families, and the +unchanged-nine-dimensional geometric lift. It uses explicit `require` +checks, so Python optimization cannot disable validation. + +The default run compares the complete recomputed result with `RESULT.json`. +`--output NEW.json` writes an exclusive new receipt. No historical package, +selected record or source archive is modified. Native algebra, full supplier +placement, scalar/tape/precision bills, the bit side and selected cold replay +are not re-executed by this accounting audit. + +Credit remains with the original paired-plane matching and endpoint work by +Cinna Davis; the strict scalar mask by Adam Gall; the native payload audit +by Jeremy Diviney, with ctoth's team and Philippe Van Velzen's preceding +cost observations; thakrarsagar's rank-49 fit; ywz65's block-rank theorem; +and Douglas Colkitt's exact interval engine. The selected supplier and anchor +retain their source attributions. Prepared with substantial OpenAI Codex +assistance. These are executable finite checks and hand arguments, not +formal-kernel or independent human verification. Apache-2.0. + +## Open next questions + +- Can a joint decoder replace identifiable public transform work, rather than + add private descents, and furnish the resulting complete coverage identity? + An answer needs an explicit operation trace and restored dirty endpoint. +- Can a different native consumer fuse the 224 data legs while preserving + arbitrary independent payloads and the dirty target endpoint? Its complete + rank histogram must replace the scoped native-leg premise above. +- Can a genuine higher-dimensional endpoint support more unpaid coordinates + with a favorable private bill after enlarging its chart and recomputing the + entire template? The old payload tensor theorem alone cannot supply this. + +These are repair directions; none is claimed completed here. The bit-side +primitive still needs its own independent repair to reach the target. diff --git a/research/kappa01-plane-audit/RESULT.json b/research/kappa01-plane-audit/RESULT.json new file mode 100644 index 0000000000..4daa386517 --- /dev/null +++ b/research/kappa01-plane-audit/RESULT.json @@ -0,0 +1,515 @@ +{ + "base": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "consistent_replication": [ + { + "families": 896, + "moment_interval": [ + "122040107271436818077933266963017021688545409647019118537155395049406724018205/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "61020053635718409038966633481508510844272704823509559268577697524703362009119/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "payload_batches": 1, + "unpaid": 2 + }, + { + "families": 1792, + "moment_interval": [ + "122040107271436818077933266963017021688545409647019118537155395049406724018205/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "61020053635718409038966633481508510844272704823509559268577697524703362009119/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "payload_batches": 2, + "unpaid": 2 + }, + { + "families": 2688, + "moment_interval": [ + "122040107271436818077933266963017021688545409647019118537155395049406724018205/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "61020053635718409038966633481508510844272704823509559268577697524703362009119/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "payload_batches": 3, + "unpaid": 2 + }, + { + "families": 6272, + "moment_interval": [ + "122040107271436818077933266963017021688545409647019118537155395049406724018205/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "61020053635718409038966633481508510844272704823509559268577697524703362009119/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "payload_batches": 7, + "unpaid": 2 + } + ], + "necessary_primitive_a": "1/9", + "negative_controls": [ + "omitted private total-mass charge", + "old centre silently replaced by decoder charge", + "payload copies misread as unpaid dimensions", + "replicated family normalization omitted", + "dimension lift in unchanged nine-dimensional chart" + ], + "rows": [ + { + "d": 1, + "private_copy_mass": 224, + "unpaid_granted_only_for_comparison": 2, + "variants": { + "0": { + "moment_at_zero": "293/292", + "omitted_charge_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.021884022053", + "idle_mass": "25762/9", + "interval": [ + "118326085871804829284010135056468978453173141228425577274515585865128470917047/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "118326085871804829284010135056468978453173141228425577274515585865128470917079/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4206", + "total_mass": "63616/9" + }, + "repaired_charge": 224, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.053958936878", + "idle_mass": "27778/9", + "interval": [ + "122040107271436818077933266963017021688545409647019118537155395049406724018205/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "61020053635718409038966633481508510844272704823509559268577697524703362009119/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "4206", + "total_mass": "65632/9" + } + }, + "64": { + "moment_at_zero": "2069/2044", + "omitted_charge_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.033142615974", + "idle_mass": "25762/9", + "interval": [ + "59814870991855646029680112280851269400886017353720484097172160786526962265341/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "59814870991855646029680112280851269400886017353720484097172160786526962265357/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "4270", + "total_mass": "64192/9" + }, + "repaired_charge": 288, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.065217530798", + "idle_mass": "27778/9", + "interval": [ + "3854492605729477526665104889632830688660759472688578420530754086166630550995/3618502788666131106986593281521497120414687020801267626233049500247285301248", + "123343763383343280853283356468250582037144303126034509456984130757332177631873/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4270", + "total_mass": "66208/9" + } + } + } + }, + { + "d": 2, + "private_copy_mass": 448, + "unpaid_granted_only_for_comparison": 4, + "variants": { + "0": { + "moment_at_zero": "147/146", + "omitted_charge_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.003115252025", + "idle_mass": "7318/3", + "interval": [ + "29038202694442949980184108730678138539678171218954065062512673993418404749131/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "29038202694442949980184108730678138539678171218954065062512673993418404749139/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "local_mass": "4430", + "total_mass": "20608/3" + }, + "repaired_charge": 448, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.067265081674", + "idle_mass": "8662/3", + "interval": [ + "15447606697129472188572837341976080078682152714125417846916289292778765649855/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "61790426788517888754291349367904320314728610856501671387665157171115062599437/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "4430", + "total_mass": "21952/3" + } + }, + "64": { + "moment_at_zero": "519/511", + "omitted_charge_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.014373845945", + "idle_mass": "7318/3", + "interval": [ + "117456466889678262696086524427946114507311578354831651169879431681599072610159/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "117456466889678262696086524427946114507311578354831651169879431681599072610191/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4494", + "total_mass": "20800/3" + }, + "repaired_charge": 512, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.078523675594", + "idle_mass": "8662/3", + "interval": [ + "124884509688942240283932788241042200978056115192018733695159050050155578812475/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "124884509688942240283932788241042200978056115192018733695159050050155578812509/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4494", + "total_mass": "22144/3" + } + } + } + }, + { + "d": 3, + "private_copy_mass": 672, + "unpaid_granted_only_for_comparison": 6, + "variants": { + "0": { + "moment_at_zero": "295/292", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.984346481996", + "idle_mass": "18146/9", + "interval": [ + "56989767841869385278731367394478064932126114261603471612792903041109383538001/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "1780930245058418289960355231077439529128941070675108487899778220034668235563/1809251394333065553493296640760748560207343510400633813116524750123642650624" + ], + "local_mass": "4654", + "total_mass": "60032/9" + }, + "repaired_charge": 672, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.080571226470", + "idle_mass": "24194/9", + "interval": [ + "31280399970658684234808032627150064892592258444746891753376308408763381594869/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "125121599882634736939232130508600259570369033778987567013505233635053526379509/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4654", + "total_mass": "66080/9" + } + }, + "64": { + "moment_at_zero": "2083/2044", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.995605075916", + "idle_mass": "18146/9", + "interval": [ + "115283191795645233332812824294189690212851122002222334145414541790144220689637/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "115283191795645233332812824294189690212851122002222334145414541790144220689667/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "4718", + "total_mass": "60608/9" + }, + "repaired_charge": 736, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.091829820390", + "idle_mass": "24194/9", + "interval": [ + "126425255994541199714582220013833819918967927258002957933333969342978979993111/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "15803156999317649964322777501729227489870990907250369741666746167872372499143/14474011154664524427946373126085988481658748083205070504932198000989141204992" + ], + "local_mass": "4718", + "total_mass": "66656/9" + } + } + } + }, + { + "d": 4, + "private_copy_mass": 896, + "unpaid_granted_only_for_comparison": 8, + "variants": { + "0": { + "moment_at_zero": "74/73", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.965577711968", + "idle_mass": "14338/9", + "interval": [ + "111806260589705741194189034655199705569791772170597626201120916190763915155479/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "27951565147426435298547258663799926392447943042649406550280229047690978788877/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "local_mass": "4878", + "total_mass": "58240/9" + }, + "repaired_charge": 896, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.093877371265", + "idle_mass": "22402/9", + "interval": [ + "126662346188233696369881562281391878511280845844971791251680152927876927560111/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "7916396636764606023117597642586992406955052865310736953230009557992307972509/7237005577332262213973186563042994240829374041602535252466099000494570602496" + ], + "local_mass": "4878", + "total_mass": "66304/9" + } + }, + "64": { + "moment_at_zero": "1045/1022", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.976836305888", + "idle_mass": "14338/9", + "interval": [ + "56554958350806101984769562080216632959195332824806508560474825949344684384557/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "14138739587701525496192390520054158239798833206201627140118706487336171096143/14474011154664524427946373126085988481658748083205070504932198000989141204992" + ], + "local_mass": "4942", + "total_mass": "58816/9" + }, + "repaired_charge": 960, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.105135965186", + "idle_mass": "22402/9", + "interval": [ + "63983001150070079572615825893312719429939869661993591085754444317901190586873/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "31991500575035039786307912946656359714969934830996795542877222158950595293445/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "local_mass": "4942", + "total_mass": "66880/9" + } + } + } + }, + { + "d": 5, + "private_copy_mass": 1120, + "unpaid_granted_only_for_comparison": 10, + "variants": { + "0": { + "moment_at_zero": "297/292", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.946808941939", + "idle_mass": "1170", + "interval": [ + "27408246373918177957728833630360820318832828954497077294164006574827265808739/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "109632985495672711830915334521443281275331315817988309176656026299309063234985/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5102", + "total_mass": "6272" + }, + "repaired_charge": 1120, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.107183516061", + "idle_mass": "2290", + "interval": [ + "64101546246916327900265497027091748726096328955478007744927536110350164370373/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "32050773123458163950132748513545874363048164477739003872463768055175082185195/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "local_mass": "5102", + "total_mass": "7392" + } + }, + "64": { + "moment_at_zero": "2097/2044", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.958067535859", + "idle_mass": "1170", + "interval": [ + "110936641607579174606265424026676841623930209297003700096484762007234516848591/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "27734160401894793651566356006669210405982552324250925024121190501808629212155/28948022309329048855892746252171976963317496166410141009864396001978282409984" + ], + "local_mass": "5166", + "total_mass": "6336" + }, + "repaired_charge": 1184, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.118442109981", + "idle_mass": "2290", + "interval": [ + "129506748605739118575881083559417057800791551389971406409683807928625782354381/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "129506748605739118575881083559417057800791551389971406409683807928625782354415/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5166", + "total_mass": "7456" + } + } + } + }, + { + "d": 6, + "private_copy_mass": 1344, + "unpaid_granted_only_for_comparison": 12, + "variants": { + "0": { + "moment_at_zero": "149/146", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.928040171910", + "idle_mass": "6722/9", + "interval": [ + "107459710401639682467641634387686856980870859465378992152191136407854211314433/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "107459710401639682467641634387686856980870859465378992152191136407854211314461/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5326", + "total_mass": "54656/9" + }, + "repaired_charge": 1344, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.120489660857", + "idle_mass": "18818/9", + "interval": [ + "129743838799431615231180425826975116393104469976940239728029991513523729921381/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "129743838799431615231180425826975116393104469976940239728029991513523729921415/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5326", + "total_mass": "66752/9" + } + }, + "64": { + "moment_at_zero": "526/511", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.939298765830", + "idle_mass": "6722/9", + "interval": [ + "27190841628386536310747930973230104332367438236098595768004968028944916232017/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "108763366513546145242991723892920417329469752944394383072019872115779664928097/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5390", + "total_mass": "55232/9" + }, + "repaired_charge": 1408, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.131748254777", + "idle_mass": "18818/9", + "interval": [ + "16380936863917259750816314416526084592712920431994453830982340902681147941877/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "65523747455669039003265257666104338370851681727977815323929363610724591767525/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "5390", + "total_mass": "67328/9" + } + } + } + }, + { + "d": 7, + "private_copy_mass": 1568, + "unpaid_granted_only_for_comparison": 14, + "variants": { + "0": { + "moment_at_zero": "299/292", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.909271401882", + "idle_mass": "2914/9", + "interval": [ + "52643217653803326552183967126965216343205201556384837563863123258199679696955/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "52643217653803326552183967126965216343205201556384837563863123258199679696969/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "5550", + "total_mass": "52864/9" + }, + "repaired_charge": 1568, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.133795805653", + "idle_mass": "17026/9", + "interval": [ + "2051321642266102729091091524996355239594004406920694749471951731349173923469/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "131284585105030574661829857599766735334016282042924463966204910806347131102051/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5550", + "total_mass": "66976/9" + } + }, + "64": { + "moment_at_zero": "2111/2044", + "omitted_charge_screen": { + "above_one": false, + "below_one": true, + "decimal": "0.920529995802", + "idle_mass": "2914/9", + "interval": [ + "106590091419513115879718023759163993035009296591785066047554982224324813007545/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "106590091419513115879718023759163993035009296591785066047554982224324813007573/115792089237316195423570985008687907853269984665640564039457584007913129639936" + ], + "local_mass": "5614", + "total_mass": "53440/9" + }, + "repaired_charge": 1632, + "repaired_screen": { + "above_one": true, + "below_one": false, + "decimal": "1.145054399573", + "idle_mass": "17026/9", + "interval": [ + "132588241216937037437179947105000295682615175521939854886033646514272584715651/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "66294120608468518718589973552500147841307587760969927443016823257136292357843/57896044618658097711785492504343953926634992332820282019728792003956564819968" + ], + "local_mass": "5614", + "total_mass": "67552/9" + } + } + } + } + ], + "scope": "Accounting repair and scoped necessary conditions only; no physical supplier, bit-side repair or new kappa.", + "status": "PASS_KAPPA01_PLANE_ACCOUNTING_AUDIT", + "strict_transfer_note": "A complete kappa=1/10 proof needs a>1/9 under kappa= private_copy_mass, + "private COPY charge is missing from the local occurrence profile") + + +def validate_payload_replication(d, unpaid, families, local, baseline): + require(d >= 1 and unpaid == 2, + "payload replication alone cannot enlarge a geometric plane") + require(families == d * W, "replicated data families must be counted") + require(local == {r: d * count for r, count in baseline.items()}, + "all public and private occurrences must replicate") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + sources = verify_sources() + spec = importlib.util.spec_from_file_location("pinned_ceiling", ROOT / "research/complex-local-word-ceiling/ceiling.py") + C = importlib.util.module_from_spec(spec) + spec.loader.exec_module(C) + copy_profile = reconstruct_support_profile() + anchor = json.loads((ROOT / "research/complex-two-output-sum-anchor-seed65ce19/RESULT.json").read_text())["cost_screen"] + selected = {int(rank): count for rank, count in anchor["selected_profile"].items()} + require(selected == {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}, "selected profile") + require((anchor["max_direct_blocks_in_rank_one_profile"], + anchor["direct_rank_one_children_per_block"], + anchor["anchored_rank_one_children_per_block"]) == (7, 332, 112), "anchor hypothesis") + public_mass = sum(r * n for r, n in selected.items()) - 64 - 7 * (332 - 112) + require(public_mass == 3982, "anchor public mass, scalar ADDs separate") + + def interval_case(local, families, charge, unpaid): + lo, hi = C.relax(local, M, families, N, charge, A, unpaid=unpaid) + model = C.model(local, M, families, N, charge, unpaid=unpaid) + return {"interval": [str(lo), str(hi)], "decimal": f"{float((lo+hi)/2):.12f}", + "below_one": hi < 1, "above_one": lo > 1, + "total_mass": str(model["total_mass"]), + "local_mass": str(model["local_mass"]), "idle_mass": str(model["idle_mass"])} + + rows = [] + for d in range(1, 8): + entry = {"d": d, "unpaid_granted_only_for_comparison": 2*d, + "private_copy_mass": 224*d, "variants": {}} + for base_centre in (0, 64): + local = {R: Q(public_mass, R), **{r: d*n for r, n in copy_profile.items()}} + if base_centre: + local[8] = 8 + repaired_charge = base_centre + 224*d + validate_private_charge(local, repaired_charge, 224*d, base_centre) + original = interval_case(local, W, base_centre, 2*d) + corrected = interval_case(local, W, repaired_charge, 2*d) + require(corrected["above_one"], "corrected target must fail") + # Inserting private work cannot remove existing public idle work. + before_private = {R: Q(public_mass, R)} + if base_centre: + before_private[8] = 8 + before = C.model(before_private, M, W, N, base_centre, unpaid=2*d) + require(Q(corrected["idle_mass"]) == before["idle_mass"], "private insertion changes no public idle") + zero = Q((M - 2*d)*W + (224*d + base_centre)*N, M*W) + require(zero == 1 + Q(d, 292) + Q(base_centre*N, M*W), "exact zero-saving mass") + require(zero > 1, "zero-saving obstruction") + entry["variants"][str(base_centre)] = {"omitted_charge_screen": original, + "repaired_charge": repaired_charge, + "repaired_screen": corrected, "moment_at_zero": str(zero)} + rows.append(entry) + + # Correct replication: all arrays and occurrences repeat, geometry does not. + baseline = {R: Q(public_mass, R), **copy_profile} + replica = interval_case(baseline, W, 224, 2) + replication = [] + for d in (1, 2, 3, 7): + local = {r: d*n for r, n in baseline.items()} + validate_payload_replication(d, 2, d*W, local, baseline) + repeated = interval_case(local, d*W, d*224, 2) + require(repeated["interval"] == replica["interval"], "replication changes normalized moment") + replication.append({"payload_batches": d, "families": d*W, + "unpaid": 2, "moment_interval": repeated["interval"]}) + + # Scoped native-leg gate. Other work has only its rank-mass baseline charged; + # even the R=51 halving guard and all decoder/centre costs are waived here. + leg_lo, leg_hi = C.child_cost(7, M, A) + gate_lo = Q(71, 73) + Q(224)/w*(leg_lo - Q(7, 73)) + gate_hi = Q(71, 73) + Q(224)/w*(leg_hi - Q(7, 73)) + require(gate_lo > 1, "unchanged native legs obstruct target") + # Logarithm-free corroboration: the gate exceeds one exactly when this + # positive ninth root exceeds 71/63. + require(Q(71, 63)**9 < Q(73, 7), "independent exact ninth-power gate") + + controls = [ + reject(lambda: validate_private_charge(baseline, 0, 224, 0), "omitted private total-mass charge"), + reject(lambda: validate_private_charge(baseline, 224, 224, 64), "old centre silently replaced by decoder charge"), + reject(lambda: validate_payload_replication(3, 6, 3*W, + {r: 3*n for r, n in baseline.items()}, baseline), "payload copies misread as unpaid dimensions"), + reject(lambda: validate_payload_replication(3, 2, W, + {r: 3*n for r, n in baseline.items()}, baseline), "replicated family normalization omitted"), + reject(lambda: require(6*2 <= H, "three orthogonal four-planes cannot fit nine dimensions"), "dimension lift in unchanged nine-dimensional chart"), + ] + # Positive controls distinguish errors from the existing, legitimate + # conditional screen and the legitimate d=1 geometry. + require(rows[2]["variants"]["64"]["omitted_charge_screen"]["below_one"], "reproduce predecessor numerical pass") + require(6 <= H, "original three orthogonal two-plane support fits") + result = { + "status": "PASS_KAPPA01_PLANE_ACCOUNTING_AUDIT", + "base": sources["base"], "target_kappa": "1/10", "necessary_primitive_a": "1/9", + "strict_transfer_note": "A complete kappa=1/10 proof needs a>1/9 under kappa 0.306330187868...`. + Uniform direct-sum lifts preserve the failing ratio. +- Constructed finite-field lines, all rank-two binary planes in dimensions + five and six, an indefinite rational pentagon, and an explicitly priced + cross-characteristic three-subset decoder. None produces a target supplier. + Their exact rejection arguments state which models and fields they cover. +- Derived a general character-rank charge inequality for complex scalar + decoders on binary ports: `sum_j (2^r_j-1) >= V*(2^k-1)`. It permits all + asymmetric cancellations and repeated ports. It closes the small binary + plane geometries and identifies necessary high-rank queries in the + remaining rank-three geometries; it does not construct those decoders. +- Proved exact Fourier shear/swap identities and compiled the actual native + affine-address schedule. The tested compiler's charged moments are far + above one. Its affine-map and child-charge replay is separate from the + algebraic phase-completion proof. +- Tested replacement convolution frames against actual source and reader + supports. A concrete helper forces both A45=45 and A45=0 under that fixed + replacement contract. This excludes that repair, not arbitrary equivalent + circuits or schedules. +- Found an exact outer arithmetic witness with hypothetical primitive + savings `14/125` and `9/80`. Its controlling margin exceeds `1/10` and + all 46 non-domain inequalities pass. The original `b<1/32` guard remains; + the analytic extension and the required primitive suppliers are unproved. + +See [README.md](README.md) for the source-linked results and precise scopes. + +## Reproducibility and publication boundary + +The consolidated runner is: + +```sh +python3 -I -O -B research/kappa01-repair/verify.py +``` + +`REPLAY.json` binds the scoped commands, source files, receipts, selected +record and original proposal to the pinned base. The runner checks hashes +before and after its isolated optimized-Python subprocesses. Mathematical +acceptance uses exact integer/rational comparisons; diagnostic Decimal +moments are labelled separately. Environment: CPython 3.14.7. + +All eleven scoped commands passed in the consolidated runner, with the +selected and predecessor files unchanged. The final character-bound +all-stage extension was then replayed separately after its four-file +manifest refresh; the other ten verifier inputs remained byte-identical. + +The initial selected-baseline wrapper could not run because this sparse +checkout omitted additional selected-supplier packages. That was a checkout +coverage issue, not a mathematical rejection. No full selected cold replay, +CPython 3.12 run, hosted CI result, formal-kernel proof, or human review is +claimed. No public comment, PR, push, merge or selected-frontier update was +made. The local commit is a research checkpoint. + +## Remaining mathematical work + +Under the retained outer transfer, both primitive savings must exceed 1/9, +or a proved replacement interface must remove one of those dependencies. +The next finite construction must give an exact word with complete moment +below one, including independent payloads, physical frame changes, dirty +endpoints, copy lifetimes and routing. Source-bound all-size, precision, +stopping, hosting and analytic obligations remain additional requirements. + +The scoped failures leave concrete possibilities: a noncoordinate block +geometry with an efficient high-rank shared-query factorization; a joint +consumer that replaces charged public work; or global operator fusion that +changes the existing source/read schedule and recursive boundaries. Merely +replicating payloads, omitting private-copy coverage, or extending the +arithmetic search domain does not supply any of these missing constructions. diff --git a/research/kappa01-repair/FIELD-GEOMETRY.md b/research/kappa01-repair/FIELD-GEOMETRY.md new file mode 100644 index 0000000000..c02053d23e --- /dev/null +++ b/research/kappa01-repair/FIELD-GEOMETRY.md @@ -0,0 +1,94 @@ +# A concrete one-third-density replacement geometry + +This construction was investigated as an actual replacement for the paired-plane +proposal. It reaches the necessary port density, but its scalar decoder does +not meet the target cost. The accompanying finite controls are not a supplier. + +Let q=2^k and work in F_q^3 with the nondegenerate symmetric form + + B((a,t,b),(c,u,d)) = a*d+t*u+b*c. + +Take one port E_(a,b)=F_q*(a,1,b) for every (a,b) in F_q^2. Restrict scalars to +F_2 and use Tr(B). The ambient binary dimension is h=3k; each port has binary +dimension k. The restriction to a port is the field trace pairing Tr(x*y), +so each E is nondegenerate. The linear map (a,t,b) -> (t+a,t+a+b,t+b) +identifies B with the standard dot product over F_q. The binary trace form +is likewise nonalternating and nonsingular. The construction therefore has +ordinary binary symplectic frame interpretations, rather than treating a +coefficient-payload multiplicity as extra address dimension. + +For two ports, the entire cross pairing is zero exactly when + + a*d+b*c = 1. + +Otherwise it has binary rank k. More generally a pairing between spans of +whole ports has rank k times its F_q rank. Thus a nonzero charged scalar-total +query in the inherited support-span tariff costs at least k. The zero-cost +queries have orthogonal support rectangles only. + +Two distinct nonzero vectors in F_q^2 have at most one common neighbor in +this free-pair graph: the two equations specifying a common neighbor have +one solution if the vectors are independent and none if they are distinct +scalar multiples. The zero vector is isolated. Hence the graph has no C4. +This fact is what makes the stronger all-q obstruction in +[the field-line audit](../kappa01-fieldline-repair/README.md) applicable. + +## Exact finite controls + +For an independent check, we construct large sets with no free pairs using +the maximal-arc construction in Mubayi and Williford, +[Theorem 6](https://homepages.math.uic.edu/~mubayi/papers/erdosrenyi_revised.pdf). +For even k, put r=sqrt(q), choose s of absolute trace one, and take all (a,b) +for which Q(a,b)=b^2+a*b+s*a^2 belongs to F_r. There are q*r-q+r such points. +The verifier builds this set and checks every possible free neighbor exactly +for q=4,16,64,256; it does not trust the external cardinality claim. + +Here is also a direct algebraic verification of independence. Put +D=a*d+b*c and T=b*d+s*a*c+b*c. Expansion in characteristic two gives + + Q(a,b)*Q(c,d) = T^2+T*D+s*D^2. + +If D=1, the right side has absolute trace one, whereas the left side belongs +to F_r and therefore has absolute trace zero. This is a contradiction. +The cardinality follows by taking a=0 (r choices of b); for a nonzero, +put b=a*t. Each t in F_q and each nonzero lambda in F_r determines a unique +a through a^2=lambda/(t^2+t+s). There are q*(r-1) such points. + +A fitting matrix restricted to this set is the identity. After removing +zero-cost queries, its rank still forces at least alpha=q*r-q+r charged +rank-one totals, each of tariff at least k. With the ideal three-stage +parameters m=7k and W=2q^2, the full moment is at least + + 3*(2/7)^(8/9) + (3*alpha/(2*q^2))*(1/7)^(8/9). + +This grants all non-copy overhead free and is still greater than one: + +| q | k | Number of ports | Independent set | Moment lower bound | +|---:|---:|---:|---:|---:| +| 4 | 2 | 16 | 6 | 1.084909083443493742 | +| 16 | 4 | 256 | 52 | 1.039189137057888958 | +| 64 | 6 | 4096 | 456 | 1.014770529329213675 | +| 256 | 8 | 65536 | 3856 | 1.000807761612019033 | + +At q=1024 this particular lower bound is below one. The replay checks this +scope boundary rather than treating a passing lower bound as a construction. +The separate C4-free complex-minrank theorem rules out the entire family, +including larger q, in the stated scalar-total model. + +Run `python3 -I -O -B research/kappa01-repair/field_geometry.py`. +It checks finite field inverses, every trace-multiplication pairing rank, +subfield membership, explicit cocliques, and (at q<=16) all common-neighbor +counts. Moment endpoints use outward rational ninth-root bounds. No floating +point determines acceptance. Sources and external theorem dependencies are +listed here; `FIELD-RESULT.json` is the frozen computed receipt. + +## Open next questions + +This attempted repair changes actual port geometry but retains scalar totals +and separate active frame changes. To proceed, a construction must change +one of those hypotheses, or use a different high-density block geometry whose +free-pair graph is not covered by the C4-free obstruction. A concrete first +step is an exact small block decoder with its complete rank histogram; no +favorable density or algebraic rank by itself supplies that histogram. + +Substantial mathematical and implementation assistance: OpenAI Codex. diff --git a/research/kappa01-repair/FIELD-RESULT.json b/research/kappa01-repair/FIELD-RESULT.json new file mode 100644 index 0000000000..8fe3c36eb8 --- /dev/null +++ b/research/kappa01-repair/FIELD-RESULT.json @@ -0,0 +1,82 @@ +{ + "status": "finite_geometry_and_scoped_obstruction_only", + "external_attribution": "Mubayi--Williford, Theorem 6; independently checked finite cocliques", + "source_url": "https://homepages.math.uic.edu/~mubayi/papers/erdosrenyi_revised.pdf", + "target_primitive_saving": "1/9", + "data_moment": [ + "4925782365738143795749247058124475064969/5000000000000000000000000000000000000000", + "9851564731476287591498494116248950129941/10000000000000000000000000000000000000000" + ], + "cases": [ + { + "k": 2, + "q": 4, + "h": 6, + "port_rank": 2, + "ports": 16, + "modulus": 7, + "trace_rank_cases": 4, + "coclique_size": 6, + "coclique_probes": 20, + "common_neighbor_pairs": 225, + "coclique_sha256": "ee5da73f8f3984d75c7c71bc450ffe3aa452ef09d0073cc660ee16e111d8f7bc", + "moment_lower": "173585453350958998747103959462348691517159/160000000000000000000000000000000000000000", + "moment_upper": "5424545417217468710846998733198396609913/5000000000000000000000000000000000000000", + "moment_display": "1.084909083443493742" + }, + { + "k": 4, + "q": 16, + "h": 12, + "port_rank": 4, + "ports": 256, + "modulus": 19, + "trace_rank_cases": 16, + "coclique_size": 52, + "coclique_probes": 816, + "common_neighbor_pairs": 65025, + "coclique_sha256": "2399616f56a22131a266aa72d0894b5e41a978fbf77740ab247186d1a650d2f6", + "moment_lower": "266032419086819573321072429164689880839477/256000000000000000000000000000000000000000", + "moment_upper": "83135130964631116662835134113965587762363/80000000000000000000000000000000000000000", + "moment_display": "1.039189137057888958" + }, + { + "k": 6, + "q": 64, + "h": 18, + "port_rank": 6, + "ports": 4096, + "modulus": 67, + "trace_rank_cases": 64, + "coclique_size": 456, + "coclique_probes": 29120, + "common_neighbor_pairs": 0, + "coclique_sha256": "289fb1cd78e635fb7eef1f29ad5664b99dd4225971a8a0ff9f3425c8af4fbf3e", + "moment_lower": "10391250220331148042073890993483869232381381/10240000000000000000000000000000000000000000", + "moment_upper": "649453138770696752629618187092741827024039/640000000000000000000000000000000000000000", + "moment_display": "1.014770529329213675" + }, + { + "k": 8, + "q": 256, + "h": 24, + "port_rank": 8, + "ports": 65536, + "modulus": 283, + "trace_rank_cases": 256, + "coclique_size": 3856, + "coclique_probes": 986880, + "common_neighbor_pairs": 0, + "coclique_sha256": "a796ec00165d5563b067610fae49ee5ad30873d112dd963ad3fcf33027d0b3d5", + "moment_lower": "81986171831256599197966950773034760449316893/81920000000000000000000000000000000000000000", + "moment_upper": "5124135739453537449872934423314672528083887/5120000000000000000000000000000000000000000", + "moment_display": "1.000807761612019033" + } + ], + "q1024_coclique_only_control": [ + "650915044483298993097160696144874172719644749/655360000000000000000000000000000000000000000", + "40682190280206187068572543509054635794990271/40960000000000000000000000000000000000000000" + ], + "no_supplier": true, + "no_new_kappa": true +} diff --git a/research/kappa01-repair/README.md b/research/kappa01-repair/README.md new file mode 100644 index 0000000000..67a17b4157 --- /dev/null +++ b/research/kappa01-repair/README.md @@ -0,0 +1,168 @@ +# Investigating and repairing the kappa = 0.1 proposal + +**The advertised paired-plane passing row is not a working kappa=0.1 +construction. This investigation has not established a replacement supplier +or a new multiplication bound.** It does supply corrected accounting, +explicit tested replacement geometries, a general complex fitting-rank +obstruction, exact Fourier identities, and an outer arithmetic region that +can accommodate the target if the missing primitive and analytic contracts +are supplied. + +User assignment: investigate the proposed 0.1 claim and attempt to repair it, +with the objective of getting kappa=0.1 working. This is an explicit target +assignment, not a randomly drawn donation task. Source base: +`997e6a9ca7b4f95d50e366f61412fd640d72a88a`. All new work is isolated in this +package and five sibling packages. The selected conditional result remains +`836330098538459/500000000000000000 = 0.001672660197076918`. + +## What fails in the proposed passing row + +The predecessor [budget screen](../kappa010-complex-lever-floor/README.md) +explicitly disclaims a supplier or new kappa. Its d=3 row reports target +moment `0.995605075916`, under hypothetical coverage and repacking assumptions. +We reproduced that arithmetic before changing its assumptions. + +1. **Private copies need a complete charge.** For its stated 49-support + implementation, the per-call copy profile is `{2:2d,4:31d,6:16d}` with + rank mass `224d`. Under the inherited private-copy coverage law, this + mass enters both the local profile and total paid mass. Putting it only + in the former silently removes the same amount of public idle work. + The corrected centre-retained d=3 moment is `1.091829820390`, above one. + Even at exponent saving zero the centre-free ratio is `1+d/292>1`. + A joint implementation replacing public work could change this law, but + would need an actual operation trace and replacement coverage proof. +2. **Payload replication is not address dimension.** The cited block-rank + theorem tensors coefficient payloads by I_d. It preserves the same + binary two-plane geometry; it does not establish u=2d unpaid address + coordinates. A true geometric lift changes the ambient chart, native + ranks and recursive template. In particular, a size-three support of + orthogonal nondegenerate 2d-spaces requires ambient dimension at least 6d. +3. **The original public legs also constrain repairs.** Retaining the + paired-plane native implementation's 224 separate rank-seven data legs + forces a moment lower bound of approximately `1.036807899646`, even granting a free decoder, + two unpaid coordinates and linear-cost placement of all other work. + +Exact statements, pinned sources, attribution and controls are in +[the paired-plane accounting audit](../kappa01-plane-audit/README.md). +These are scoped failures of named implementations and accounting laws, +not an impossibility theorem for kappa=0.1. + +## Repairs actually attempted + +| Attempt | Result and remaining scope | +|---|---| +| Larger port subspaces and a new stage count | A compressed-window necessary condition is k/h > 0.306330187868. The old line geometry, paired planes in nine dimensions and uniform direct-sum lifts fail at every odd stage count under the stated coverage/active-climb laws. See [density proof](../kappa01-bit-repair/PROOF.md). | +| True one-third-density ports in F_(2^k)^3 | Constructed the exact family and checked binary trace ranks. A C4-free complex-minrank argument forces more than V/4 paid scalar totals, each of rank at least k. Three-stage moment exceeds 1.051658213344872 for every field size. See [all-size family proof](../kappa01-fieldline-repair/README.md) and [finite controls](FIELD-GEOMETRY.md). | +| All nondegenerate rank-two planes in F2^5 | Enumerated all 80 planes and produced a 30-set exact independent-set cover. Every subset, with multiplicities allowed, has an independent set of at least 2V/5. Even unit-rank paid queries force three-stage moment above 1.016448096636709. The pressure proof also excludes every odd stage count under the same coverage and charge assumptions. See [construction and tariff](../kappa01-bit-repair/PLANE_REPAIR.md). | +| All distinct nondegenerate rank-two planes in F2^6 | Enumerated all 336 planes for each of two explicit forms. Closed row supports overlap in at most four positions, giving complex fitting rank greater than V/5 for every induced subset. Even unit-rank query prices force moment above 1.013886814008956200. See [dimension-six proof and exact masks](../kappa01-fieldline-repair/PLANES6.md). | +| Cheap asymmetric queries on larger binary ports | A character-matrix lift proves `sum_j (2^r_j-1) >= V*(2^k-1)` for arbitrary scalar-query cancellations and repeated ports. It excludes all rank-two binary-port geometries in dimensions four, five and six under the stated model. At h=8,k=3, queries capped at rank six fail, while rank-seven/eight relaxations remain open. See [the general query-charge bound](../kappa01-bit-repair/WALSH-CHARGE.md). | +| Indefinite rational bit geometry | An explicit nondegenerate pentagon escapes the positive-definite sign-class proof. Its complete binary fitting census still has minimum rank three, and it fails the target. The general indefinite family remains open. See the same construction note. | +| Cross-characteristic three-subset decoder | Constructed and priced Gaussian-dyadic queries with total copy charge C=n^2. At n=100 its copy ratio is 0.061843, but its data-only moment is 1.126460 because its port density is only 1/100. An identity-block witness prevents improving the same mask to the required density. See [explicit decoder](../kappa01-haemers-repair/README.md). | +| Replace the separate bit supplier with Fourier address operations | Proved exact shear and fused-swap identities, with an augmented recurrence criterion. A whole-chunk swap takes three joint-width Walsh calls. Applying this to a bit-dependent supplier without charging its adapters is circular. See [outer repair](../kappa01-outer-repair/README.md). | +| Extend the outer numerical parameter domain | Proved an arithmetic region containing bit saving 14/125 and complex saving 9/80. With explicit rational backoffs the controlling margin is 11666316669/115833100000 > 1/10. All 46 non-domain inequalities pass; the unchanged b<1/32 guard rejects. Actual primitive contracts, positive bridge premises and the analytic domain extension remain unproved. | + +The scalar-query obstructions retain complete support-span tariffs and +separate public frame changes. They do not exclude a genuinely joint +multi-array primitive, a different free-entry mask or coverage law, or an +operator composition that changes those mandatory data occurrences. + +The line-graph argument also has a [three-dimensional corollary](../kappa01-fieldline-repair/LINE3-COROLLARY.md) +for distinct nondegenerate lines over any label field, including indefinite +forms. Its fitting coefficients must be complex. It does not settle the +binary bit-decoder problem on indefinite rational labels; those are different +coefficient and label fields. + +The character-rank proof does give a separate conditional bit-side result. +If an integral presentation of rational ports has every port Gram determinant +nonzero modulo 3 or modulo 5, reduction to that field and an odd-order +character table give a valid binary-scalar charge bound. Either good-reduction +condition excludes the rank-one, three-dimensional target. No such modular +condition is assumed for arbitrary rational geometries. + +## Actual adapter fusion and the shared-Fourier-frame attempt + +The [adapter compiler](../kappa01-outer-repair/ADAPTER-FUSION.md) consumes +both exact native local-interior event streams and implements their address +maps through Fourier calls. The best tested deferred-layout policy still +has target moments approximately 47.62 and 49.12. These are prices of +explicit implementations, not lower bounds on all compilers. Quadratic +phase completion is proved algebraically; the executable checks affine maps +and Fourier-child charges, without emitting a complete scalar/phase ledger. +A separate support argument excludes independent synthesis of the frozen +nonidentity map boundaries on one array, with nonzero diagonal wrappers and +Fourier calls and without auxiliary saved transforms. Fusion across those +boundaries, auxiliary saved transforms, or a different physical frame +assignment changes that model. + +A more global repair sought a common Fourier basis in which all frame changes +would become diagonal. Existing degenerate canonical frames are not generally +convolutions, but that observation alone does not rule out changing them. +The [replacement-frame audit](../kappa01-outer-repair/CONVOLUTION-FRAMES.md) +therefore solves the actual source-carry and reader constraints for a +symmetric binary matrix A. It gives both a successful alternative at one cut +and an impossible cut at another. At forward event 13759, helper 445 carries +labels 140 and 161 and has reader labels 14 and 35. The equality + + 140 xor 161 = 14 xor 35 = 45 != 0 + +would require both A45=45 and A45=0. Thus no linear A can satisfy this +particular fixed carry/read replacement contract. Arbitrary equivalent +circuits need not obey that contract; changing the source/read schedule is +an explicit remaining escape, not ruled out by this witness. + +## A further elementary limit on coordinate-only repairs + +If every port E_i is spanned by a subset S_i of one common coordinate basis, +then every scalar fitting decoder under the same full-orthogonality mask has +total pairing-rank charge C >= sum_i |S_i|. For each coordinate j, the ports +containing j are pairwise nonorthogonal, so the fitting matrix restricted to +those ports is an identity. At least that many rank-one query terms must +contribute to that restriction. Every such term has j in both its source +coordinate union and its reader coordinate union. Its pairing-rank tariff +counts exactly the intersection of these two unions. Sum over j to obtain +the bound. For rank-k ports this gives C>=Vk, which makes the usual deficit +`(s-1)Vk-sC` negative. Common-coordinate ports therefore cannot repair the +model, for any dimension or stage count. This argument does not apply to +arbitrary binary subspaces in different bases. + +## Verification and limits + +Source pins and exact receipts are retained in the corresponding packages. +All completed replays use CPython 3.14.7 and standard-library arithmetic; +mathematical acceptance uses rational/integer comparisons. The actual +adapter compiler additionally records diagnostic Decimal moments and exact +linear-rank rejection bounds. No CPython 3.12 or hosted CI result is claimed. +No complete selected-supplier cold replay, formal-kernel verification, or +independent human review was performed in this investigation. + +The consolidated replay checks its frozen file hashes before and after the +scoped verifiers, and checks that the selected record and original +budget-screen files still match the pinned base. Run it from this worktree: + +```sh +python3 -I -O -B research/kappa01-repair/verify.py +``` + +The original selected record and all frozen predecessor sources remain +unchanged. No public comments, PRs, pushes or selected-frontier updates have +been made. The local Git checkpoint is a research handoff, not certification +of a multiplication theorem. Substantial assistance: OpenAI Codex and its +parallel mathematical reviewers. Apache-2.0. + +## Open next questions + +The target under the retained transfer needs primitive savings strictly +above 1/9 on both sides, or a proved replacement for the bit-dependent +interface. The remaining construction problem is concrete: produce an exact +native word with its complete charged moment below one at such an exponent, +including its physical frame changes, independent payloads, dirty endpoints, +copy lifetimes, routing and precision costs. + +The next useful attempts must change a hypothesis of the failed repairs: +noncoordinate block geometries with cheaper mixed-rank queries; a joint +consumer that actually replaces public work; or global frame/operator fusion +that crosses the frozen recursive child boundaries. The single-supplier +Fourier route additionally needs a self-contained recursion on every shape +used by the caller. The enlarged outer arithmetic region then needs its +supplier, stopping, finite stock, precision and analytic dependencies checked. +The active research objective remains unresolved. diff --git a/research/kappa01-repair/REPLAY.json b/research/kappa01-repair/REPLAY.json new file mode 100644 index 0000000000..58fc2d5eed --- /dev/null +++ b/research/kappa01-repair/REPLAY.json @@ -0,0 +1,91 @@ +{ + "scope": "Local scoped results only; not production supplier admission or full cold replay", + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "environment": "CPython 3.14.7, standard library", + "files": { + "research/kappa01-repair/FIELD-GEOMETRY.md": "05a50526dee379796f228c2f8ba4e2258c5ca315555ddee8b4a7f321a59bb47e", + "research/kappa01-repair/FIELD-RESULT.json": "84fd00e79089f396c21891f657adaad6f23adf30276e450f87bd8b02f4c47b96", + "research/kappa01-repair/README.md": "033be2283d2149d4a57d445ae08d04a0a6198d6b7e3b48f36305f247a26d53b7", + "research/kappa01-repair/field_geometry.py": "0610fc42073d1e03ddd39e51eb54d52a75ac2fe8a56bf2c20252102f6dced97c", + "research/kappa01-repair/verify.py": "21a0c5d1eb5407fd6978ad0726f4002924e80cd469db4944028319de4e495f8d", + "research/kappa01-plane-audit/README.md": "5837a682bccfc5ab7cf234118016088cc8f83bdd25fbefc9ffb845281c816ffe", + "research/kappa01-plane-audit/RESULT.json": "bf363a3abd6a245799ca11cf0c4b8499772c6abe2a8d4fc19c9a5bbab458e07b", + "research/kappa01-plane-audit/SOURCES.json": "135ad9bb2ba37bf2b2deed7baa908958f1630ac6622ced6b262286e30d33cc90", + "research/kappa01-plane-audit/verify.py": "46f3076fdcc3283375386496054240ec43db63979e34be1580bd22ed74abb62b", + "research/kappa01-bit-repair/PLANE_REPAIR.md": "e36987fc02767c0a4a5cce6098a3f816fc1a3d30adfa9055f615b35c135c0f6a", + "research/kappa01-bit-repair/PLANE_RESULT.json": "c704aa0b3596068a4e7562f5a5d317efeda072f8ca3098fe587571dd9c635300", + "research/kappa01-bit-repair/PROOF.md": "85f5dfd939e6f4fcb5baa5aae4a317a96aa01a68967483e507bdd903d657e952", + "research/kappa01-bit-repair/README.md": "0a3b0715ec7bced6f9f3aad3c51487c3eec55a9e5f32e5ec3791bc2a505e29f6", + "research/kappa01-bit-repair/RESULT.json": "b2f724a35603b776644a06d31cf7cf12bfbca7f74c8f2e75e3d5b27464568f84", + "research/kappa01-bit-repair/SOURCES.json": "8185845c991198aebb59f2ff614f8c070d7d2d9257ad0e9b11252ea0519a4ba3", + "research/kappa01-bit-repair/WALSH-CHARGE.md": "5ea11c200e9251ef2c646b9a4e0738c823e7f35a6d6f854472ff3a6cbf6fe01f", + "research/kappa01-bit-repair/WALSH-RESULT.json": "830bfddd355a7b98dae52503481e49b80c4b3c7265462ddfec252240a2612358", + "research/kappa01-bit-repair/WALSH-SOURCES.json": "7fd48a4635453f9db48bb391629f1e89db7d581d7394b7c6c4a50c79bf9e7929", + "research/kappa01-bit-repair/plane_search.py": "54b71dadeade7247b4ba1c8a0c78be6332c2f6c20a0e77fc76bef15f417f14a1", + "research/kappa01-bit-repair/verify.py": "5bc7e03b25456ab139786ee79e35edbfb3631288c527f4b7d8ba15c4da437b81", + "research/kappa01-bit-repair/walsh_charge.py": "adce13ff0cbb7ea06ea40943564d2e6b3b20749b9c2925c00133098e6796388f", + "research/kappa01-fieldline-repair/LINE3-COROLLARY.md": "c905c8911ff9d74762d8f9b0313949281661367b6d9fd873955ded98728143ec", + "research/kappa01-fieldline-repair/PLANES6-RESULT.json": "98c11216db3a77a4a44f8707d9b567747477b69270015ac682ed263c72cf9615", + "research/kappa01-fieldline-repair/PLANES6-SOURCES.json": "b538a1ac2a4ffd961b618f4f2a7fdfbccd4d521dcd05636633efdd8aea0a5b22", + "research/kappa01-fieldline-repair/PLANES6.md": "55d3981df6c90f334fe7b5103bcffdb79cb3161295987ea51f4da2385064cc4d", + "research/kappa01-fieldline-repair/README.md": "07b951fe26431882f8ecb5f1529036940dde027b462250c382385a665f391621", + "research/kappa01-fieldline-repair/RESULT.json": "1a13110bfeeb95ff7072b5c839001042b973fcfbe2482039572f846472f302cf", + "research/kappa01-fieldline-repair/SOURCES.json": "b8e3b4beda7e08cad863c71f32fc42a1f5caef89c15e38a2ad3e3bff5668eaf3", + "research/kappa01-fieldline-repair/planes6.py": "a7d3b90aff1d92bbc088277d2b559dd24104cbae54755aa39ff71ba91c6c0fbb", + "research/kappa01-fieldline-repair/verify.py": "095278e31b07b634a9078c434a63f02cf186a47ae1e4385bfcb8be5d131e6d96", + "research/kappa01-haemers-repair/README.md": "3d9db92f6b5462bccb5c3b21da935c6de1c1ea81be48edb0010d0b317822af66", + "research/kappa01-haemers-repair/RESULT.json": "82c70cd3d529aca5c939e1f0582173a4ccd60217e2e7b024043ba9b1857d9e83", + "research/kappa01-haemers-repair/SOURCES.json": "cbc5ace4df824e9da32864cc2e6158c68d97ae04c62e882f6a68590534c826c0", + "research/kappa01-haemers-repair/verify.py": "6ad3afbf79bc0e7e77254218c5a82039c85d493de299a86fcd464cb3381a9989", + "research/kappa01-outer-repair/ADAPTER-FUSION.md": "e276c192bd63b21715b79b11a9e4b435f9ad53a26efdb5a515b46fea93733174", + "research/kappa01-outer-repair/ADAPTER-RESULT.json": "f1c8a5add06e94b35927ddfca7bbffbc634cfbfe33a4f76dbd4c71bab4e12f37", + "research/kappa01-outer-repair/CONVOLUTION-FRAMES.md": "47baaf9ae75c5362061fa887f9cb83f04f15ec100da73617086a003f04f1dde8", + "research/kappa01-outer-repair/CONVOLUTION-RESULT.json": "56ebf5031d88b990ae941e538ac232e7ca8069c00754307ba11be3ca70fee875", + "research/kappa01-outer-repair/README.md": "068cd8333facf27c9ea85c114f027a890801ec9fdd81370a4ca5c92ec2ed4f2d", + "research/kappa01-outer-repair/RESULT.json": "5591bf5ef0eb20f9494814b7e45281a79fac42a84d34714bdf1810d4159c338c", + "research/kappa01-outer-repair/adapter_fusion.py": "56bcb77128c7eb63d5b54e389771971622005ec7a792e38ca55fff8f1acfc858", + "research/kappa01-outer-repair/convolution_frames.py": "cc23e1b9ece4b42994f0dac9f100a09fc546661c8de320b18e184b5674d92fb6", + "research/kappa01-outer-repair/verify.py": "61160f895c85a85f9c509d0f277616f88689bacaaff212b6d9cc96784a962c85" + }, + "base_files": { + "certificates/selected-result.json": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "research/kappa010-complex-lever-floor/README.md": "2fe0f7a21413e24d3fc7b3bf651dedfeb79ca18c07c4d6ec215139c9d5111a75", + "research/kappa010-complex-lever-floor/verify.py": "ed56126ceb4ba109d71fe7f8e69a4bbbb5256683229f9231fd99b4cd93016d63" + }, + "commands": [ + [ + "research/kappa01-plane-audit/verify.py" + ], + [ + "research/kappa01-bit-repair/verify.py", + "--check-sources" + ], + [ + "research/kappa01-bit-repair/plane_search.py" + ], + [ + "research/kappa01-bit-repair/walsh_charge.py" + ], + [ + "research/kappa01-repair/field_geometry.py" + ], + [ + "research/kappa01-fieldline-repair/verify.py" + ], + [ + "research/kappa01-fieldline-repair/planes6.py" + ], + [ + "research/kappa01-haemers-repair/verify.py" + ], + [ + "research/kappa01-outer-repair/verify.py" + ], + [ + "research/kappa01-outer-repair/adapter_fusion.py" + ], + [ + "research/kappa01-outer-repair/convolution_frames.py" + ] + ] +} diff --git a/research/kappa01-repair/field_geometry.py b/research/kappa01-repair/field_geometry.py new file mode 100644 index 0000000000..50cb591658 --- /dev/null +++ b/research/kappa01-repair/field_geometry.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact finite controls for a one-third-density port geometry; no supplier. + +The maximal-arc control is based on Mubayi--Williford, Theorem 6. +The field/rank/orthogonality checks below are independently computed. +""" +from __future__ import annotations +import argparse +from fractions import Fraction as F +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +SCALE = 10**40 + + +def require(ok, reason): + if not ok: + raise ValueError(reason) + + +def power89(x): + a, b = x.numerator**8 * SCALE**9, x.denominator**8 + lo, hi = 0, 1 + while hi**9 * b <= a: + hi *= 2 + while hi-lo > 1: + mid = (lo+hi)//2 + if mid**9*b <= a: + lo = mid + else: + hi = mid + require(lo**9*b <= a < hi**9*b, 'outward ninth root') + return F(lo,SCALE), F(hi,SCALE) + + +def rank2(rows): + pivots = {} + for row in rows: + while row: + p = row.bit_length()-1 + if p not in pivots: + pivots[p] = row + break + row ^= pivots[p] + return len(pivots) + + +def field(k, modulus): + q = 1 << k + def mul(a,b): + r = 0 + while b: + if b & 1: + r ^= a + b >>= 1 + a <<= 1 + if a & q: + a ^= modulus + return r + tab = [[mul(a,b) for b in range(q)] for a in range(q)] + def exp(a,n): + r = 1 + while n: + if n & 1: + r = tab[r][a] + a = tab[a][a] + n >>= 1 + return r + inv = [0]+[exp(a,q-2) for a in range(1,q)] + require(all(tab[a][inv[a]] == 1 for a in range(1,q)), 'field inverses') + trace = [] + for a in range(q): + x,t = a,0 + for _ in range(k): + t ^= x + x = tab[x][x] + require(t in (0,1) and x == a, 'trace field') + trace.append(t) + for lam in range(q): + gram = [sum(trace[tab[tab[1< 1, 'finite coclique excludes target') + row['moment_lower'],row['moment_upper'] = map(str,moment) + row['moment_display'] = show(moment[0]) + rows.append(row) + # Counter-control: this particular independence bound alone stops excluding + # q=1024. This is not an admissible supplier or a passing actual decoder. + q,r = 1024,32 + c = F(3*(q*r-q+r),2*q*q) + control = tuple(base[i]+c*unit[i] for i in (0,1)) + require(control[1] < 1, 'scope control q=1024') + return dict(status='finite_geometry_and_scoped_obstruction_only', + external_attribution='Mubayi--Williford, Theorem 6; independently checked finite cocliques', + source_url='https://homepages.math.uic.edu/~mubayi/papers/erdosrenyi_revised.pdf', + target_primitive_saving='1/9',data_moment=list(map(str,base)), + cases=rows,q1024_coclique_only_control=list(map(str,control)), + no_supplier=True,no_new_kappa=True) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--write',action='store_true') + args = parser.parse_args() + got = result() + path = HERE/'FIELD-RESULT.json' + if args.write: + path.write_text(json.dumps(got,indent=2)+'\n') + else: + require(json.loads(path.read_text())==got,'frozen finite field receipt') + print('PASS_KAPPA01_FIELD_GEOMETRY q=4,16,64,256 finite_target_failures=4 scope_control=1024 no_new_kappa') + + +if __name__=='__main__': + main() diff --git a/research/kappa01-repair/verify.py b/research/kappa01-repair/verify.py new file mode 100644 index 0000000000..c17631ea2c --- /dev/null +++ b/research/kappa01-repair/verify.py @@ -0,0 +1,51 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Sequential replay of the local kappa=0.1 investigation, not a supplier test.""" +from __future__ import annotations +import hashlib +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(ok, message): + if not ok: + raise RuntimeError(message) + + +def check_files(receipt): + for name, expected in receipt['files'].items(): + require(hashlib.sha256((ROOT/name).read_bytes()).hexdigest()==expected, + 'bundle source or receipt changed: '+name) + for name, expected in receipt['base_files'].items(): + raw = subprocess.check_output(['git','show',receipt['base_commit']+':'+name],cwd=ROOT) + require(hashlib.sha256(raw).hexdigest()==expected, 'base object changed: '+name) + require((ROOT/name).read_bytes()==raw, 'selected/base working file changed: '+name) + + +def main(): + receipt = json.loads((HERE/'REPLAY.json').read_text()) + check_files(receipt) + env = os.environ.copy() + env.pop('PYTHONOPTIMIZE',None) + with tempfile.TemporaryDirectory(prefix='kappa01-replay-') as temp: + for index, args in enumerate(receipt['commands']): + cmd = [sys.executable,'-I','-O','-B','-X',f'pycache_prefix={temp}/{index}',*args] + result = subprocess.run(cmd,cwd=ROOT,env=env,text=True,stdout=subprocess.PIPE, + stderr=subprocess.STDOUT,timeout=180) + require(result.returncode==0, 'replay failed: '+str(args)+'\n'+result.stdout) + lines = [line for line in result.stdout.splitlines() if line.startswith('PASS')] + require(lines, 'missing result marker: '+str(args)) + print(lines[-1],flush=True) + check_files(receipt) + print(f"PASS_KAPPA01_REPAIR_BUNDLE exact_scoped_replays={len(receipt['commands'])} selected_unchanged no_new_kappa") + + +if __name__=='__main__': + main() From 195dcb14fb2e2b4de72d8e573ab6cbe120c844ba Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Fri, 16 Oct 2026 22:42:53 -0500 Subject: [PATCH 2/2] Record adjacent kappa 0.1 PR scope --- research/kappa01-repair/README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/research/kappa01-repair/README.md b/research/kappa01-repair/README.md index 67a17b4157..c1be8ac743 100644 --- a/research/kappa01-repair/README.md +++ b/research/kappa01-repair/README.md @@ -15,6 +15,12 @@ assignment, not a randomly drawn donation task. Source base: package and five sibling packages. The selected conditional result remains `836330098538459/500000000000000000 = 0.001672660197076918`. +This rechecks the conditional complex row in [PR #3107](https://github.com/CrocSwap/integer-mult-bounds/pull/3107). +It complements [PR #3111](https://github.com/CrocSwap/integer-mult-bounds/pull/3111), +which prices the selected bit supplier's fixed local histogram: the present +audit corrects the private-copy coverage charge and studies replacement +scalar-query geometries. + ## What fails in the proposed passing row The predecessor [budget screen](../kappa010-complex-lever-floor/README.md)