Paired lockstep first-stage vertices on three-stage covers: conditional κ = 3.416202e-4

[ikeboy]

Change and mathematical scope

Conditional κ = 1708101/5000000000 = 3.416202e-4: +8.59% over #130 (3.146011e-4) and +2.83% over #131 (3.32205398986e-4). It builds on #130 (head 6a9970a, included in this branch) and keeps all of its interfaces. The complex side binds; the next κ grid point at denominator 10^10 is rejected.

Idea: share and run in lockstep. In #130's first stage the offset is 0, so a core occupies only its 24-dimensional active space kA of the 70-dimensional cover space E. Let κ be the coordinate involution exchanging e_i and e_(24+i) for i < 24. It is orthogonal, κ² = 1 and κA ⊂ B + C, so kA and (kκ)A are orthogonal for every vertex k. Pair the first-stage vertices k and kκ:

• the two cores share every auxiliary stream (each acts block-diagonally on its own directions and accepts the other's as spectators, as in Completed-core sharing: conditional kappa > 2^-13 #128's completed-core sharing);
• they run the same first-stage word in lockstep, so each joint frame step U₁⊕U₂ → U₁′⊕U₂′ is one nested transition, hence one child of width d₁ + d₂ by Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's general Clifford lemma (valid for degenerate subspaces too), instead of two children;
• the shared dirty tail has rank m − 2h + 2 dim σ instead of two tails of m − h + dim σ.

Stages two and three carry the offsets kB and k(B + C), which leave no orthogonal room, so they stay as in #130. All data streams, routers, partitions and the bit side are #130's, unchanged.

per pair of vertices	#130	here
persistent streams	180,326	151,621
complex saving	3.147997e-4	3.418543e-4
stopped bit saving	3.731650e-4	unchanged
κ	3.146011e-4	3.416202e-4

The same lockstep principle applies wherever identical cores share streams on orthogonal subspaces. On #128/#129's completed-core groups (24 complex or 11 bit cores per stream) it raises κ from 1.29186e-4 to 2.05734e-4 (branch ikeboy:research/lockstep-cores, not opened as a PR because #130 is higher).

Validation

Finite checks (research/paired-cover/paired_cover.py, seconds):

• Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's three-stage-cover-complex-input.json and three-stage-cover-network.json pinned by SHA-256;
• the unpaired per-vertex profile rebuilt from the input equals Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's certified children;
• κ is an orthogonal involution with κA ⊆ B + C;
• the paired profile telescopes (W·m − s = 2(2v − 3ℓ) per pair; largest child 68 < 70);
• the complex saving is the largest on the 10^-10 grid under Stopped product-ring interchange and rational centers for conditional kappa = 7.79476e-5 #104's exact moment (next point rejected);
• the bit saving is Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's certified stopped saving;
• the finite bridge is Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's construction with the paired stream count (group order, local and router charges, semantic induction, row stock p^160000); all 47 strict constraints and 7 margins hold at κ, and the next κ is rejected.

Proof arguments, not machine-checked here: the lockstep schedule, the spectator sharing of first-stage streams and the shared tail (research/paired-cover/PROOF.md §3–§4), which use #130's general Clifford lemma and dirty-tail formula and #128's sharing argument. All of #130's inherited hypotheses remain.

python3 research/paired-cover/paired_cover.py

Credits

• icekylinx: the three-stage Cayley cover, general Clifford frames and weighted bit interface (Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130); the stopped product-ring framework (Stopped product-ring interchange and rational centers for conditional kappa = 7.79476e-5 #104).
• an664: completed-core sharing (Completed-core sharing: conditional kappa > 2^-13 #128). eumemic: Deferred bit word and a 28,705-role complex producer under stopped-product accounting: conditional κ = 1.044939e-4 #117's local DAG, Shared bit cores and gauged scratch reuse: conditional κ = 1.29186205798e-4 #129, Physical frames and scratch reuse on Cayley covers: conditional κ = 3.32205398986e-4 #131.
• Zhihao Chen (jacklightChen): Deferred endpoints and signed phase correction for a conditional 63965813/10^12 > 2^-14 bound #97's bit ledger. Swapnil Jain: the round-seven bit witness.
• Everyone credited in Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130's NOTICE and SOURCES.json.

Avi Eisenberg (ikeboy) prepared the pairing, the lockstep schedule and this certificate with Anthropic Claude assistance.

🤖 Generated with Claude Code

[Swapnil-jain]

Thanks for this, the pairing geometry is a nice observation. However, I think the lockstep schedule in §3–§4 does not restore its targets, and an exact small replay seems to confirm it.

The merge algebra checks out. With the cores in lockstep, the joint transition T_{U1'+U2'} T_{U1+U2}^{-1} is exactly the product of the two cores' transitions, so the merged step is a single C^{⊗(d1+d2)} child, as claimed.

The schedule is where it breaks. The proof relies on each core acting "block-diagonally on its own coordinate directions". But kA and (kκ)A are subspaces of frame labels, meaning address digits of the shared stream. They are not separate storage. Every read/add gate of core k adds or reads the whole register. So while both cores are live, core k's frame steps also transform the data core kκ has already added to the shared stream, and core kκ's reads pick up core k's live data. #130's dirty-tail and transparency arguments only cancel scratch that stays static while a core runs. The consecutive schedule, as in #128, satisfies that. Lockstep doesn't. For a step to commute with another core's live data, its residual would have to act trivially on that data, which doesn't hold for general inputs.

Minimal exact instance, built literally from §3–§4. Registers are exact Q(i) arrays over the addresses, and frames are T_U = K_G C^{⊗r} K_G^{-1}.

• Setup: E = F_2^5, h = 2, κ swapping e_i and e_{2+i}. Two paired cores run the same transparent local word on one shared auxiliary stream with arbitrary dirty scratch.
• Run one after the other, each core restores its scratch and produces its targets exactly.
• Run in lockstep, 64 of 64 target entries are wrong, in both orientations. The merged child still equals the product of the two transitions; only the schedule fails.

The same failure appears for the earlier lockstep-cores branch on #128/#129 groups:

• Bit side: three cores of a Fano class under H = 9I − J get 3 of 3 targets wrong.
• Complex side: on an h = 8 Q(i) word whose consecutive schedule passes, lockstep gets every data pair wrong.

What does survive is merging at boundaries between consecutive cores, where only one core is live on the stream. That gain is negligible.

If I've misread how the cores' data is kept apart, I'd be glad to be corrected. Otherwise, κ = 3.416202e-4 and the results stacked on it (the paired numbers in #134 and #135) would need the unpaired accounting. I can share the small exact replay script if useful.

[ikeboy]

Retraction. @Swapnil-jain is right: the lockstep schedule in this PR is invalid, so the claimed κ = 3.416202e-4 does not hold. Thank you for the careful replay.

I reached the same conclusion with my own check. When two paired cores share a role stream at the same time, both cores add their sources into the same register. Each core's readout then also receives the partner's sources. The partner's frame changes also act on the register while it holds this core's data. PR #128's consecutive schedule avoids both problems, because each core removes its sources before the next core starts.

My check: addresses F_2^4, two cores with active coordinates {0, 1} and {2, 3}, one shared dirty role, Hadamard frames, and the transparent word y -= z; z += x; y += z; z -= x. The consecutive schedule is exact. The lockstep schedule restores the role but leaves errors of order 1 in both targets.

With the consecutive schedule, the same first-stage pairing gives a complex saving of 3.218208e-4, which is below PR #131. Later PRs that reuse this pairing's lockstep accounting inherit the problem. I am closing this PR.