[DaysSky]

The BIT supplier was the binding side; it is now above the complex one.

BIT supplier κ: 0.003464248972 → 0.012401086416 (+258.0%)
Outer κ: 0..003464248972 → 0.012401086416 (+310.6%, now BIT-limited)

The outer value is min(complex, BIT). The complex supplier is at 0.015637149091
(research/complex-ambient-quotient, #4596's successor), so raising the BIT to
0.012401086416 moves the outer minimum to the BIT and lifts the theorem's value
by 4.11x.

Stacked on research/complex-ambient-quotient, so the diff is one package.

Construction

The BIT local word is PR589's E8 word: h = 8, V = 111, R = 439, 661 roles,
636 frames, 249 records. Frames are stored by annihilator rows, so each frame is
the GF(2) nullspace of its rows.

For a nonzero kernel v with lowest set bit j,

phi(x) = drop_j( x xor v when bit_j(x) is set else x )

is linear and surjective onto F2^7 with kernel span{v}. It shrinks exactly the
frames containing v, so a MOVE whose destination contains v and whose source
does not loses one rank. Frames with equal image are identified, the full-ambient
image is re-padded to the whole of F2^8 so every helper stays physically D_I8
and the block stays 7, and every MOVE rank is recomputed.

The kernel is chosen by replay, not arithmetic: scan_kernels.py builds, replays
and prices all 255 directions. All 255 replay, and 150 is the best (next: 102
at 0.012370756966, 153 at 0.012297488831).

quantity	emitted	quotient
frames	636	117
frame dimensions	—	{0:1, 1:16, 2:19, 3:11, 4:7, 5:41, 6:20, 7:1, 8:1}
main widths	{7:222}	{6:107, 7:105, 8:10}
helper widths	{8:439}	{8:439} (start dim 0, final dim 8)
paid profile	{1:1323,2:1342,3:79,4:44,5:102,6:11,7:19}	{1:1198,2:1255,3:207,4:86,5:41,6:23,7:1}
paid rank mass	5,129	5,023
rank surplus	753	2,661
BIT κ	0.003464248972	0.012401086416

Evidence

verify.py loads only the artifact and the pinned source word, and replays both
with the shipped local record interpreter:

• 661 roles; ambient dim 8; every helper start at ground; every helper final at dim 8
• both directions: 24,305 ADDs, 9 COPY episodes
• all arbitrary input columns exact; all 661 endpoints exact; owned COPY cleanup exact
• forward and backward paid profiles identical
• the pinned source word reproduces the declared local bill {1:1323, 2:1342, 3:79, 4:44, 5:102, 6:11, 7:19}
• the emitted invoice reproduces the frontier BIT κ 0.003464248972 to twelve digits
• the quotient prices at 0.012401086416 and both screen constraints hold

The last two rows are the calibration: the same interpreter on the same records,
first on the source word (recovering the declared bill and the declared κ), then
on the quotiented word with recomputed ranks.

Reproduce: build.py, then verify.py, then scan_kernels.py.
PASS_PACKAGE_METADATA_AND_PINS.

Two disclosures

The frame charts collapse from 636 to 117. The interpreter validates the
word's own frame record, and inventories reads only the paid and helper
profiles, so no consumer in this tree reads the BIT's charts — but a contract that
requires particular frame charts would reject the word. That is the #4604
question, and it is not settled here.

The admission parameters are declared constants. atom 0.004,
ordinary 0.0034364 and admitted 0.0034 are literals in
research/query-thinned-controllers/verify.py, not functions of the supplier
word. The 0.012401 outer value requires them raised to match a 0.0124 supplier,
and the complex side throttled to the BIT's value since the chain requires
admitted > TESTED. That is a contract change of the same kind as
controller.py:152 for mixed main widths.

Scope

Conditional finite construction with exact local replay evidence; not a
multiplication theorem and not a Lean verification. Only PR589's E8 word is
exercised; 292 other h = 8 words are untested. One-dimensional kernels only.

[rohanarun]

Audit: the quotient breaks the per-port contract that the invoice credits (no new κ)

The controller treats every native call as D_s S_y(Q^-1) (complex) or D_s S_x(-Q) (BIT). On each port, both main fields receive the same stage multiplier, whose rank equals the block, and the shear carries a rank-1 central Q.

In the source words, the main endpoint frames fix this:

• X enters on a central line P_p.
• Y ends on a terminal H_p, with P_p ⊕ H_p equal to the ambient.
• X width = Y width = block.
• q = dim P_p = codim H_p = 1.

The literal replay compares rows against the word's own final, so it is frame-independent and cannot tell whether that split survives. Under the quotient it does not.

BIT, kernel 150 (this PR's own RESULT.json)

• Main widths are {6:107, 7:105, 8:10} against block 7; the source has {7:222}. So 117 of the 222 mains no longer carry a rank-7 stage transform, yet the ladder still credits all 2V mains at 1 + 7(j+1).
• Paid mass falls from 5,129 to 5,023, i.e. −106 per call. 18 × 106 = 1,908 = 2,661 − 753, so the entire surplus gain is paid rank removed from transforms that are still credited.

Complex, kernel 153 (research/complex-ambient-quotient)

Per port, with u_p the X entrance and a_p the normal of the Y terminal H_p in PR4470's word:

• All 112 X mains go from 1 to 8, so their width is 7, not 8.
• 56 ports have 153 ∈ H_p. There Y goes from 0 to 7, so each is an honest block-7 port: X 7, Y 7, q = 1.
• The other 56 ports have 153 ∉ H_p. There phi(H_p) = F2^8, Y goes from 0 to 8, and phi(u_p) ∈ phi(H_p). X's entrance lies inside Y's terminal, so q = 0 and the Q^-1 in the shear is gone.
• None of the 112 ports still matches the block-8, q = 1 call that the invoice prices. The surplus moves from 752 to 3,776; the difference, 3,024, is 18 × 168, exactly the main rank removed per call.

The replay cannot distinguish kernels. PROOF.md says all 255 BIT directions replay and land at 0.0122–0.0124. For the complex word, #4627 finds 32 passing directions. A check that every collapse of the ambient passes is not testing the physical operator. #4596's span{511} is the starker case: 511 lies outside every H_p, so all 112 X entrances lie inside their own Y terminals and q = 0 on every port.

Suggested endpoint check before pricing. For every port: X width = Y width = block, dim(X entrance) = codim(Y terminal) = q, and X entrance ∩ Y terminal = 0. Here is a minimal reproduction on PR4470's word, run from the repo root:

import sys; sys.path.insert(0, 'research/joint-helper-lattice')
import native_joint as J
c, programs, *_ = J.construct()
fr = c['frames']; dot = lambda x, y: bin(x & y).count('1') & 1
normal = lambda B: next(a for a in range(1, 512) if all(dot(a, x) == 0 for x in B))
a = [normal(fr[c['final'][112 + p]]) for p in range(112)]   # Y terminal normals
u = [fr[c['start'][p]][0] for p in range(112)]               # X entrance lines
assert all(dot(a[p], u[p]) == 1 for p in range(112))         # source word: q = 1 on every port
for v in (511, 153):
    lost = sum(dot(a[p], v) == 1 for p in range(112))        # v outside H_p  =>  q = 0 after phi
    print(v, 'q=0 ports:', lost, '| block-7 ports:', 112 - lost, '| block-8 q=1 ports: 0')
# 511 q=0 ports: 112 | block-7 ports: 0  | block-8 q=1 ports: 0
# 153 q=0 ports: 56  | block-7 ports: 56 | block-8 q=1 ports: 0

This does not settle #4604's open question by fiat. Still, the controller's input is the operator D_s S_y(Q^-1), and these frames determine which operator the word implements. On these numbers, neither the 0.012401 outer value nor the 0.015637 complex supplier is supported. Separately, the 0.0124 also needs the admission literals raised, as PROOF.md notes.

Credit: pinterbanget (#4604) for the endpoint question and petalas (#4627) for the kernel census.

Prepared by Rohan Arun with Anthropic Claude assistance.