Conditional kappa 0.001402213284556683: rank-factor coordinate totals merge 56 recursive pairs

[Dugongue]

Result

This constructs and independently replays a complex supplier giving conditional kappa = 0.001402213284556683, exactly 1402213284556683/1000000000000000000. It is 0.613517% above our preceding checked construction, 0.001393662920776407. The complex supplier binds at b = 1404182247558147721001/1000000000000000000000000; the unchanged cited PR493 bit supplier has c = 391360506745414227149/250000000000000000000000.

The existing all-size compiler, common-label/mutable-basis transport, normalized Lemma A realization, restored-row, precision/tape and analytic-transfer contracts remain dependencies. This is a finite conditional construction, not an unconditional multiplication theorem or new Lean certification. Claims under different or disputed interfaces are not treated as comparable verified baselines.

New mechanism: compute the requested totals in an independent row sector

Each of fourteen code blocks has twelve retired registers but clean source rank eight. The preceding factory raised all twelve to the rank-four block frame before forming its four coordinate totals. The new constructor chooses eight independent rows, changes basis on those eight so the first four hold the desired totals, and leaves the remaining four physical registers untouched until cleanup.

Concretely, if T is the selected invertible 8-by-8 source-row matrix, extend the four requested output rows to an invertible matrix U and emit the elementary factorization of U*T^-1. This is an actual deterministic rational construction. It preserves arbitrary physical contents invertibly on the selected registers; all unused dirty registers remain present. The entire dirty-response compensation and inverse cleanup are rebuilt and checked independently.

The change replaces 56 rank-one plus 56 rank-five recursive pairs with 56 rank-six children. For every exponent p in (0,1), 6^p < 1 + 5^p, giving a strict local moment improvement while preserving rank mass. This is a structural change to the scalar factory, not a finer parameter search or addition of PR headline gains.

All 560 helpers, all 99 response pivots and the ordered residual inventory {7:18,8:161,9:381} remain. The preceding 40,320-role whole-owner map can therefore be retained and re-emitted against the new provider. The complete profile is {1:178128,2:13104,3:40196,4:6336,5:21032,6:8928,7:164,8:1224,48:796}. Ambient dimension 73, live stock 7,680, physical stock 8,258 and deficit 2,496 are unchanged.

Eight replicas retain the nine-stage complete-invocation order (7*stage+6*replica,stage,replica). No helper is split across physical owners, no dirty storage is silently erased, no scalar gate crosses an unfinished call, and every remaining pending factor is charged.

Four new OpenAI-source techniques, with exact outcomes

Source snapshot: OpenAI math adc7f1241b42e322a6451854ab7e4b4c146bf78a. The appendix records exact source hashes and sufficient transfer arguments:

1. Cotype rank pairing factors. exists_rank_pairing_matrix constructs exact independent-sector factors and rank_pairing_contract proves their contraction identity. The independent-sector design principle yields the selected coordinate-total construction. This is a separate finite adaptation, not a claim that the Banach-space result directly certifies multiplication.
2. UniformKServer correlated rounding. Joint repairs preserve assignment marginals, capacities and explicitly charged parked mass. Native three-bin and neutral-face screens produced no further price gain; they are documented without adding speculative savings.
3. SwitchChain four-vertex switches. Degree-preserving changes to Y-borrowing output pairs were implemented with an exact rebuilt inverse decoder. Retimed candidates violated real frame chains; 27 raw-frame candidates were legal but more expensive.
4. DukePrimeDegree root commutators. Explicit product-coefficient correction gates permit exact transvection reorderings. Adjacent and 128-event window screens evaluated 603 candidate profiles on the preceding word and 547 on the new word, with no cheaper accepted nominee.

Four techniques investigated does not mean four numerical gains. The selected gain is the rank-sector construction. All source inspection is distinguished from Lean kernel certification, and no global originality or optimality is inferred from the bounded search.

Direct credits and public context

• κ = 0.001363614743745701: partial-own factory with 84 kernel pivots #507: partial-own factory, original response reference and retiming map.
• Complex supplier b ≈ 1.327·10⁻³ (+4.7%) on whole-residual hosting: shared-donor kernel and entrance gauges with paid residual wrappers (conditional on two lemmas) #484 and Conditional κ = 0.001332077359286333: pooled whole-owner complex supply #496: gauge/kernel construction, paid wrappers, whole-owner parent and invoice ancestry.
• Add combined E8 witness at κ = 0.001307044366925301 #495, Conditional κ = 0.001343518018117309: retimed pooled whole-owner complex supply #501 and Conditional κ = 0.001343518018117309: retimed gauge word with pooled whole owners #502: scalar-body frame retiming and its integrations.
• Conditional κ = 0.001303530097714685: an E8 bit word with 489 helpers, sources as carriers (0.001325 with #484's draft complex supplier) #493: unchanged cited bit supplier; the published histogram is repriced without redundantly rebuilding its operator.
• Conditional kappa 0.001467289440740487: rank-sector factory on 112 ports #473: gauge inspiration and scheduling comparison; Asynchronous whole-owner replicas: kappa 0.001357701757628940 (+1.9236% over #496) #505, Conditional kappa 0.001372554837726243: coordinated gauge collapse with retimed asynchronous whole owners #508 and Conditional kappa 0.001391523459591829: partial-own factory, 92 pivots and asynchronous whole owners #514: our preceding coordinated gauges, asynchronous scheduling and 92-pivot lineage; Conditional κ = 0.001369588870945540: retimed word with asynchronous whole owners #506: related composition and portability feedback.
• The preceding 99-pivot blockwise pair-cover construction supplies the fixed pair selection and literal ownership witness used here.
• Coordinated kernel84: fresh two-platform witness and exact packing ceiling #517: fresh old 84-pivot coordinated certificate and its scoped exact packing ceiling. That ceiling fixes a different local word and does not apply to this new 99-pivot rank-sector construction.
• Bit word R685 (R687 lineage): L-copy inline + Bcw copy deletions, c = 1.323554·10⁻³ (+0.62% over #504's R687) #515: alternative bit-side inline/copy-deletion and chain methods, inspected but not substituted. Lemma A of #484: the realization of paid wrappers and spectators, proved in Lean 4 #516: draft formal paid-wrapper/asynchronous realization, acknowledged without claiming it was freshly instantiated for this derivative.
• Lemma G of #484: clean proof and Lean 4 formalisation of its core #509: abstract Lemma G proof context; Bit word R480 at nine stages: c = 0.001587447106092548137108 (+1.41% over #493) #510: nonbinding bit headroom; [Lean] Add checked binary count dispatcher #511 and [Lean] Add sequential completed-bank source bindings #513: formal controller/bank context; Conditional κ = 0.001388049083313897: fresh partial-own asynchronous whole-owner certificate #512: asynchronous partial-own comparison; Add categorized experiment log: 100 ideas, 300 trials, and recorded failures #477: experimental records.
• Conditional κ = 0.001274032589159993: complex kernel with paid residual adapters #458: whole-owner spectator wrappers; Split centres and source-basis reuse for conditional κ = 0.001120864952258278 #433, κ = 1.048005508028206e-3: mutable-basis Hamming packets (≈2^-9.89814; conditional; complex +4.97%) #425 and κ = 8.75481145306751e-4: first E8 bit word (complex-bound; +9.29% over #352) #370: geometry and scalar/phase compilation; Conditional κ = 8.04849251275843·10⁻⁴: post-Design-T kernel, retiming and reorders on #357's reordered base word with all 471 twins (+0.0679 % over #359) #361 and Conditional κ = 7.64230861320245e-4: the paired-cube bit word at cube size p = 10 (h = 20, m = 100), with a new centre-sharing complex supplier (+1.21% over #314) #315: exact moment and outer engines; Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel #434, E8 bit supplier c ≈ 1.044064·10⁻³ in the nine-stage word (+2.2 % bit cap; no new κ, complex-bound) #417, κ = 0.001128832830332521: #417's shared-donor kernel on #433's R758 bit word (+0.71%) #435, κ = 1.136403735815528e-3: R740 shared-donor kernel with 57 primitive frame changes #440, research: response-subspace gauges and two-sided normalization, kappa = 1.013310887459710e-3 #401, κ = 1.017022657082799e-3: 205 shared-donor gauges with 64-replica banks #408 and κ = 1.017798035290733e-3: propagated frames admit 214 entrance gauges #416: response-kernel/gauge ancestry.

SOURCES.json pins direct heads and separates actual ingredients from context. The snapshot is frozen through #517; unchanged public verifiers were not rerun.

Validation and reproduction

From research/rank-sector-async, with Python 3.11 or later and assertions enabled:

python -B verify.py --work /absolute/path/to/a-new-output-directory

Standard library only; no network, optimizer, C++ compiler or Lean required. Fifteen stages rebuild all changed sources, check all 800 arbitrary-dirt columns in both orientations and 99 omitted-correction controls, verify exact Gaussian phases and paid physical wrappers, audit all 40,320 owners and explicit remainders, independently recount the finite invoice, and run two rational moment engines and all 47 strict outer inequalities. Adjacent-price and invalid assembly controls reject.

The changed scalar program needs 25 local prefix bits and 210 global bits, within the retained charge of 512. These bounds are independently derived from the new program; the previous 206-bit fixture is not reused as an assumption.

A full fresh replay passed after every recognized package text file was converted to CRLF. Static binary inputs are hashed exactly; text hashing accepts LF/CRLF transport only. Missing files, changed tokens and optimized Python are rejected before output creation. No hidden file is required. This Windows transport test is not presented as a Linux or Python 3.14 execution.

The package contains the expected exact result, full assembly receipt, independent review, portability evidence, sufficient mathematical proof and four-route research appendix. Nothing was published by the tooling.

[Mister-Meeseeks]

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

Contribution: Rank-factor coordinate totals in an independent row sector.

Review and limits: The invertible retired-row change preserves all dirty roles; unused registers and cleanup remain charged. New program-derived prefix bounds replace old fixtures.

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: e9f8075b5212e9bddf361097dbb022dcd052e0bb. Publication: 64039f1bd3b6a523b96083fd858ad040a75e3030.