Boolean-lattice (zeta) finite networks: compiler-level construction, in-tree assembly projection 15x-48x, obligations named (research record, draft)

[mikey1201]

Research record (draft). Adds research/zeta-family/ only; no existing files change.

Change and mathematical scope

A new finite-network construction, the zeta family, on the Boolean lattice. Inputs are all nonzero, non-full bitmasks of [h]; the DAG is the fast Yates zeta transform; the side root for target t is Z_{full^t} = the sum of every input submasked into complement(t), i.e. bit-disjoint from t. The in-tree side-root orthogonality contract (value span inside the orthogonal complement of the targets' addresses) holds by construction. No center roots, so ell = 0 and the in-tree identity gives deficit = 2v. The binding quantity is the role density R/v.

Compiled through the merged in-tree compiler (scripts/paired_cube/frames.py::compile_graph, the #144 path), priced through the in-tree assembly with both sides configured at the family saving (the two-sided projection):

h	v	R	R/v	saving	kappa	x PR #163 (reference)
3	6	12	2.00	3.0519e-2	2.8764e-2	48.4x
4	14	38	2.71	1.7960e-2	1.7337e-2	29.2x
5	30	100	3.33	1.2279e-2	1.1985e-2	20.2x
6	62	242	3.90	9.0809e-3	8.9189e-3	15.0x
7	126	560	4.44	7.0573e-3	6.9591e-3	11.7x
8	254	1262	4.97	5.6780e-3	5.6142e-3	9.5x

Changed hypotheses: none to the retained interfaces. upstream/ untouched; no certificates, patches or scripts/ edited.

Open obligations (stated; this is not a reviewed headword claim).
A. Source histogram shape supplied explicitly for h <= 6 (the in-tree default Counter({2:v, h-4:v, 1:v}) is a dict literal whose duplicate keys collapse at h in {5,6} and is negative at h=3; the supplied {2:v, 1:v(h-3)} is the legal mass-v(h-1) form and is conservative). h >= 7 uses the default unchanged.
B. Centerless scope: ell = 0 passes every in-tree assert; the role coordinate-star centers discharge in the retained notes is not re-derived.
C. Semantics: the DAG computes y_t = sum_{u&t=0} x_u (checked literally below). Its service to the upstream reduction - the analogue of H+K+B = I - is not established here and is the main open obligation.
D. The scalar word/replay is included: adjoint pre-reads on raw dirt, V-gates, compute, reads, full inverse; dirty scratch restored; four tamper controls rejected (mod 2^61-1 and integers; three seeds). Not built here: the physical placement/recycling layer. The graph verifies through the merged complex-side compiler path; the bit-side path carries its own H0 = (I-J/9)/2 cap geometry and does not accept this graph as-is (checked: rejects with 'root physical compatibility'), so the bit-side construction remains an obligation and every table number is a two-sided projection under A-C.

Validation

python3 research/zeta-family/verify.py (stdlib only, run without -O, about 1 second):

• Finite identity check (not a proof): a literal semantic evaluation of the DAG - every root equals sum_{u: u&t=0} x_u for random inputs, both seeds, h = 3..8.
• The scalar word/replay: dirty scratch on every register, restored by the inverse pass; the map y_t = sum_{u&t=0} x_u recovered exactly; four tamper controls rejected, on two rings and three seeds, h = 3..8.
• The in-tree compiler's full assert chain on each graph, including mass == h*R + ell and deficit == 2v - 3*ell.
• The in-tree 47-constraint assembly with both sides at the family saving (b < 1/32, b > a, all 47 slacks, seven margins).
• make paired-cube-verify: PASS (recorded; the change adds files only, so the selected incremental target is unaffected).
• CI: .github/workflows/zeta-family.yml runs the package verifier on Python 3.11 and 3.13.

The frontier multiple is re-derived from PR #163's certified number and is a reference only.

Credits

The compiler (scripts/paired_cube/frames.py), the assembly, the side-root orthogonality contract and the identity bookkeeping are icekylinx's #144 lineage, used unchanged. Graph construction, semantic evaluation and the audit table by this contribution, prepared with AI assistance (Cline). Apache-2.0.

[Swapnil-jain]

Obligation C fails for this family, not just stays open, so the table does not yield a κ.

Each invocation must realise H + K + B = I (paired-cube-construction.tex; scripts/paired_cube/verify.py::verify). H and K can only join F2-orthogonal addresses, and an odd-weight address is not orthogonal to itself. So for every odd-weight port t, H_tt = K_tt = 0 and the diagonal 1 has to come from B. With ell = 0 we get B = 0 and (H+K+B)_tt = 0 on all 2^(h-1)-1 odd-weight inputs, whatever network sits over these addresses.

If the centers supply the missing term, then B = I - Z and ell >= rank(I - Z) = 6, 9, 30 at h = 3, 4, 5. That gives a deficit of -6, 1 and -30 respectively, so the saving disappears.

compile_graph passes because its asserts (mass == hR+ell, deficit == 2v-3ell) hold for any graph. The identity is checked only in paired_cube/verify.py::verify, and this PR never calls it. About half the inputs are also even-weight (degenerate) addresses, which the framework excludes.

I checked this independently with my own stdlib code written from the notes, at h=3,4,5, with the upstream paired cube at p=4,5 as a positive control and perturbed controls as negatives.

[eumemic]

Obligation C cannot be met with ℓ = 0.

In #144 the decoder identity is H + K + B = I, and its diagonal comes only from the centre term B. scripts/paired_cube/verify.py checks H + K₂ + B₂ = 2·[t = s] with H_tt = 0 and K_tt = 0, so B_tt = |q_t| − 1 = 2 supplies the whole diagonal. Side roots deliver only on readable pairs, and a port is never readable against itself. A centre-free network therefore delivers a matrix with zero diagonal.

That is the case here. The delivered map is (Dx)t = Σ{u ∧ t = 0} x_u, with D = [[1,1],[1,0]]^{⊗h}, and D_tt = 0 for every nonzero t. The reduction needs Y_T = X_T, so the compiled saving prices D, not I.

Adding centres does not rescue it. For ports that range over all nonzero masks, the odd overlaps take every odd value, so an affine-in-Gram centre term needs degree about h/2. Its rank then grows like C(h, ~h/4), well beyond the 2v gross deficit. For #144's triples the odd non-self overlaps take only the value 1, which is why (Gram − J)/2 works there.

[DominikScholz]

I'm Astra (OpenAI), posting these research findings at Dominik's request. I independently reproduced this PR's verifier at 427b23bc79489e7b2b7548bfd434dd9670fd5c47. This is a finite mathematical audit, not a claim to have verified the inherited all-size framework.

I agree with the identity obstruction described above. One additional result closes the apparent small-dimensional exception left by scalar rank alone: keeping this disjointness map and repairing it only with copied centers has negative paid deficit for every advertised h = 3,…,8, over both rational and binary scalar coefficients.

Let D[T,S] = 1[T & S == 0] and B = I-D. A factorization through n scalar centers requires n >= rank(B). If their source-frame dimensions sum to ell, a dimension-d center can cover at most 2^d-1 distinct nonzero binary input labels. Every input must be covered because B[S,S]=1. Convexity therefore gives, for any certified rank lower bound r,

v <= (r-1) + (2^(ell-r+1)-1)
ell >= r-1 + ceil(log2(v-r+2)).

This counts arbitrary center coefficients and overlapping supports; further physical constraints can only increase the cost. For rational frames the same support bound follows by projecting the span injectively onto pivot coordinates.

For h = 3,…,8, exact elimination gives:

• rational rank lower bounds (modulo 101 and 103): 6, 9, 30, 61, 126, 185;
• binary ranks: 5, 9, 21, 41, 85, 169;
• resulting upper bounds on 2v-3ell, rational side: −6, −5, −30, −62, −126, −65;
• binary side: −6, −5, −12, −11, −18, −17.

In particular h=4 needs ell >= 11, not merely ell >= 9, so its deficit is at most −5. Restricting to odd-norm ports also leaves the complex center-only repair with negative deficit throughout h=3,…,8. As a concrete control, appending one actual rank-one center per source to the unchanged compiler gives ell=v, deficit −v, and no positive characteristic root. This bookkeeping does not repair the separate even-norm-port or bit-geometry issues.

The scalar Möbius inverse does exist: D = P Z, with P complementing a subset and Z the inclusion-zeta matrix. But applying that inverse is additional physical work, not a free endpoint relabeling. Also, verify.py's dummy_bridge() and installation of projected savings on both branches should remain explicit limitations of the numerical table.

Useful direction: retain Yates as a disjoint-subset query module inside an already valid H+K+B=I decoder. I implemented and checked a restricted ranked-Yates DAG on all input basis columns, including a duplicate-operand negative control. For (n,k)=(13,5),(12,4),(11,3),(10,2),(9,1), the active binary-addition counts are 19,320; 8,112; 2,523; 495; 42. Those exclude channel replication, roots, centers and physical storage; they are ingredients for a future compiler experiment, not new κ values.

These obstructions are scoped to the retained decoder/center accounting. They do not rule out a different cover, additional paid connectors, or a new computational interface.