A κ ceiling of 2.5592e-3 for every word on #144's paired-cube design (no new κ)

[DaysSky]

Adds research/design-ceiling/ and one workflow. No new κ, and no existing file changes.

Result

No word on #144's paired-cube design can certify more than

κ < 2.5592 × 10⁻³        (complex saving a < 2.5657 × 10⁻³),

whatever its circuit, root groups, gauges, reuse pairs, terminal sinks, frames and p. For comparison, the selected construction on main certifies κ = 6.618855 × 10⁻⁴, so the ceiling is about 3.87 times that.

Scope

The design is the paired-cube ports, the identity K + H + B = I, the coordinate-star decoder, the K step on the source registers and the three-stage shared cores. A word must obey the eight rules of PROOF.md §3.4. They describe #144's word format, as checked by scripts/paired_cube/verify.py, the frame-and-reuse layer of #155–#168 and the terminal-sink gate of #168.

Not covered:

• Source-assisted words (Source-assisted common-frame compression for conditional kappa = 6.566436e-4 #184, Source-assisted complex word on PR168 v4 modules: conditional κ = 6.626307e-4 #191, Pair donors to avoid parity erasure on the source-assisted v4 word: conditional κ = 6.647872e-4 #193, Source-assisted v4 complex word with PR189's bit supplier: conditional κ = 6.674324e-4 #194). They use the original source registers as controls and reuse registers after exact cancellation, which breaks rules R1, R2 and R7.
• A different decoder, port family or stage structure.
• The bit supplier. The bound is on the complex saving, and κ is also below the bit saving.

Argument

Write D = 2v − 3ℓ for the deficit and C = Σ n_r·r·ln(m/r) for the cost of the ledger's children. Every certified saving satisfies a < D/C (from e^x ≥ 1 + x), and both assemblies on main force κ < a/(1+a). So it is enough to show that every word pays at least C(p).

The floor comes from one structural fact: along any path of a source value from its injection to a target, frames never decrease. Three lemmas follow, for every p ≥ 7.

• Every source enters at its own line. Its role's register starts at dimension 1 and must climb to the full space.
• Every source needs two registers that leave its line and stop again before the full space. One subspace larger than the line misses at least 4(p−3) of the source's targets.
• Every target needs two registers at its own hyperplane, or an extra stop of its own register.

A charging argument adds these to the fixed cost of the data registers. Each ingredient lowers the ceiling:

Floor	Ceiling on a
data registers and star copies only	6.3627e-3
+ one register per source	4.2121e-3
+ a second register per source	2.9420e-3
+ registers at each target's hyperplane	2.7868e-3
+ source roles enter from frame 0	2.7653e-3
+ the K itinerary of the source registers	2.5657e-3

The maximum over p is at p = 13. Every p from 7 to 99 is evaluated exactly, and a tail bound covers p ≥ 100.

PROOF.md is self-contained: the ledger, the rules, each lemma with its proof, the charging argument and the numbers.

Verify

python3 research/design-ceiling/ceiling.py --check     # the ceiling, exact; under a second
python3 research/design-ceiling/ceiling.py --brute     # counting lemmas at small p; a few seconds
python3 research/design-ceiling/model_check.py         # the lemmas on #144's word; about 15 seconds

All three use the standard library only and refuse -O.

• ceiling.py evaluates D/C(p) in exact rational arithmetic, with every logarithm enclosed between two rationals, and asserts the side conditions of the charging argument at every p.
• ceiling.py --brute enumerates the counting lemmas: over every vector at p = 7, 8, and over one vector from each symmetry orbit for 7 ≤ p ≤ 16. This is a sanity check; the proofs cover every p ≥ 7.
• model_check.py rebuilds the proof's abstraction for the certified Paired cubes and shared completed cores for conditional kappa = 4.609169e-4 #144 word (p = 12) with the repository's own producer. It checks that the abstraction lists exactly the certified children, and that every lemma's conclusion holds on that word.

Run before opening:

• All three pass on Python 3.14 and 3.12 (macOS), and again from a clean export of the commit.
• model_check.py --tree also passes on a checkout of Annealed modules, terminal sinks and physical bit words on paired cubes: conditional κ = 6.558894e-4 #168 (p = 11, with frame layer, 2,310 reuse pairs and 47 sinks).

Not run: make verify, and anything on Linux. The new workflow runs the three commands on Python 3.11 and 3.14.

Limits

• The proofs are by hand. Nothing is machine-checked beyond the scripts' exact arithmetic and self-tests, and no one else has reviewed them.
• The rules are a model of the format. They are stated in PROOF.md §3.4 so they can be checked against the code. The model check confirms the lemmas' conclusions on two certified words; it does not prove that every acceptable word obeys the rules.
• The ceiling is far from tight. On Paired cubes and shared completed cores for conditional kappa = 4.609169e-4 #144's and Annealed modules, terminal sinks and physical bit words on paired cubes: conditional κ = 6.558894e-4 #168's words the floor is 19% and 26% of the certified cost. The proof charges two registers per source; the certified words use about eight auxiliary registers per port.
• It was not run on main's selected word (Shared-edge supplier, coordinated frames and entrance banks: conditional kappa = 6.61885549259598e-4 #186), which is stored in its own archive format.

Related

• Add an exact κ-ceiling check for the exponent assembly (no new κ) #183 (romainhedouin) gives the assembly's acceptance ceiling in closed form. This PR bounds the supplier saving that enters it.
• A κ ceiling of 7.010e-4 for every frame layout of #168's word (no new κ) #192 bounds one fixed word (Annealed modules, terminal sinks and physical bit words on paired cubes: conditional κ = 6.558894e-4 #168's) over all frame layouts, at 7.010e-4. This PR bounds every word, far less tightly.

Credits

• icekylinx: the paired-cube design, its compiler and independent checker, shared cores and assembly (Paired cubes and shared completed cores for conditional kappa = 4.609169e-4 #144, Three-stage Cayley covers for conditional kappa = 3.146011e-4 > 2^-12 #130).
• eumemic: the frame-and-reuse layer and terminal-sink gate (Paired cubes at p = 11 with physical frames and a paired-cube bit word: conditional κ = 5.508074e-4 #155–Annealed modules, terminal sinks and physical bit words on paired cubes: conditional κ = 6.558894e-4 #168).
• jamesyc: the terminal-sink lemma (Add exact dirty-target terminal compiler and 67-sink witness #166) and birth-read reuse (Birth-read slot recycling: conditional kappa 1.1038332094346e-4 #124).
• an664: completed-core sharing (Completed-core sharing: conditional kappa > 2^-13 #128).
• romainhedouin: the assembly ceiling (Add an exact κ-ceiling check for the exponent assembly (no new κ) #183).

The lemmas, the charging argument and the scripts were prepared by DaysSky, assisted with Claude.

[Mister-Meeseeks]

Thank you @DaysSky. This contribution is now retained on main in the scoped 100-PR review and contributor credits.

Contribution: Ceiling for the specified paired-cube design class.

Review and limits: Prior exact-head three-command review. Restrictions R1-R8 matter: source-assisted words and different stage structures are outside this ceiling.

The complete original source, notices and relevant execution evidence are retained through the pinned source archive. The review distinguishes fresh local runs, source-bound historical Linux CI and prior exact-head review; it does not claim 100 fresh full mathematical audits. Closing this historical PR as reconciled. This preserves parallel and cumulative credit without replacing the selected frontier or promoting priced research targets to completed constructions.

Reviewed head: b3c128ec4c3a4ac1a095f45a8d86e387bbda05ec. Publication: 50d768818f579d4e165b4c257c6ee25bca300802.