From 5e5f1171cd6e3b18d2d29a9016113056c81ee76f Mon Sep 17 00:00:00 2001 From: Aaron Wang Date: Tue, 13 Oct 2026 06:45:32 -0400 Subject: [PATCH 1/2] Research audit: exact endpoint-to-kappa reduction of the selected frontier799 assembly (no new kappa) --- research/audit-kappa-floor-seed67/AUDIT.md | 164 ++++++++++++ research/audit-kappa-floor-seed67/CLAIM.md | 35 +++ .../audit_kappa_reduction.py | 241 ++++++++++++++++++ 3 files changed, 440 insertions(+) create mode 100644 research/audit-kappa-floor-seed67/AUDIT.md create mode 100644 research/audit-kappa-floor-seed67/CLAIM.md create mode 100644 research/audit-kappa-floor-seed67/audit_kappa_reduction.py diff --git a/research/audit-kappa-floor-seed67/AUDIT.md b/research/audit-kappa-floor-seed67/AUDIT.md new file mode 100644 index 0000000000..1ea4adada1 --- /dev/null +++ b/research/audit-kappa-floor-seed67/AUDIT.md @@ -0,0 +1,164 @@ +# Audit: the endpoint-to-kappa reduction of the selected frontier799 assembly + +Assignment seed 67, track 60-74 (adversarial mathematical audit). +Prepared with help from opencode. Apache-2.0, per CONTRIBUTING.md. + +## What was audited + +One accounting step: the reduction that turns the recorded moment endpoints +of the selected conditional witness into the headline + + kappa = 1661634653669567/10^18 = 0.001661634653669567. + +Precisely, the function `outer_witness` in +`research/gauge44-frames-x/code/assemble.py` and the 47 strict constraints of +`research/complex-k492-owner-repair/vendor/multicold/engines/outer.py`, +evaluated on the committed record +`research/community-frontier799-audit/ASSEMBLY.json`. The reduction is: + + s = min(c, (1-beta)*b) - 1e-27 + a_0 = 384599/10^10; a_{i+1} = (1-s)*s + s*a_i (seven steps) + q_w = a_7 * (1-2*eta) + margin = (1-eta)*q_w/(1+q_w) (= eps*q = the minimum of the 7 margins) + kappa = largest 1e-18 grid point strictly below margin + +with eta = beta = 1e-24. The statement examined: the recorded kappa is exactly +this reduction of the recorded endpoints and guards, and the improvement over +the conservatively admitted kappa is attributable to one specific change. + +## Base commit and pins + +- Base commit: `f567884aeb8851b6e794af1184119a3bfbe1e631` (origin/main). +- Audited record: `research/community-frontier799-audit/ASSEMBLY.json`, + sha256 `65c7648a8edaeaf4e0b8de3e21eeda94fba124d0935010d45ac9f76375b72cec`, + audited source head `80e6463157cfc80b85af09e7e2f14748fe2dac60` + (`certificates/selected-result.json`). +- The three engines I transcribed the formulae from were hash-checked against + the assembly's own `input_sha256` pins and match exactly: + `engines/moment.py` `81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482`, + `engines/base_two_moment.py` `aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098`, + `engines/outer.py` `c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c`, + read at `research/complex-k492-owner-repair/vendor/multicold/engines/`. + +## Method + +`audit_kappa_reduction.py` recomputes the entire reduction and all 47 outer +slacks with exact rationals (`fractions`), importing none of the repository +engines. Every recorded value it recomputes is compared exactly, not +numerically: the two kappa pairs, both decimal fields, both seven-row bootstrap +tables, and all 94 recorded outer slacks (accepted and conservative rows). + +Reproduce: + + python research/audit-kappa-floor-seed67/audit_kappa_reduction.py + +Expected output (CPython 3.13.15, stdlib only, no `-O`): + + PASS endpoint-to-kappa reduction audit (seed 67) + kappa = 1661634653669567/1000000000000000000 + margin - kappa = 7.578608e-20 + (kappa + 1e-18) - margin = 9.242139e-19 + binding endpoint = complex + endpoint slack c-(1-beta)b = 6.902676e-05 + conservative -> accepted gap = 2881809/1000000000000000000 (=2.881809e-12) + endpoint gap b - b_c = 2.891409e-12 + transfer factor = 0.996679726523 + guard cap cost (guards->0) = 7.634935e-27 + guard grid cost = 0 + tightest outer slacks = [('lambda_above_internal', '1.664e-27'), ('lambda_above_tau', '1.664e-27'), ('lambda_prime_above_lambda', '1.664e-27'), ('q_below_internal', '3.329e-27'), ('delta_positive', '1.250e-25')] + margin cluster above minimum = [('Gaussian_arithmetic', '3.750e-25'), ('balanced_prefix', '1.000e-24'), ('compact_phase_layer', '0.000e+00'), ('scalar_work', '8.750e-25')] + bootstrap cutoff_log2 = ['4915613269871', '1774443388201110908', '640540491097945923200390', '231222998414134964443595932879', '83467127743916184993039472927586044', '30130053937546965452116011965235164002719', '10876379418071676456390609457427077833228788828'] + negative controls detected = 4 + +## Findings + +All findings are exact-recomputation results on the committed record. No +counterexample was found in the audited step. + +**F1 (identity confirmed).** The recorded kappa is exactly the largest 1e-18 +grid point strictly below the margin: recomputation from the recorded +endpoints and guards matches digit for digit, `kappa < margin < kappa+1e-18`, +and `margin - kappa = 7.578608e-20`, so the accepted kappa sits 0.076 of one +tick below its cap. The strict floor matters at this instance: a +nearest-grid rounding would pick `kappa + 1e-18` and violate the +compact-phase-layer margin. + +**F2 (refined claim: a four-way near-tie, not a single binding cap).** The +margin is `minimum = eps*q`, the `compact_phase_layer` margin of outer.py, and +it is strictly the smallest of the seven margins. But the binding cluster is +four margins within one tick of it: `compact_phase_layer` (0), +`Gaussian_arithmetic` (+3*eta/8 = 3.75e-25), `scalar_work` (+7*eta/8 = +8.75e-25), `balanced_prefix` (+eta = 1e-24). At `kappa + 1e-18` exactly these +four `_above_kappa` slacks turn non-positive and every other strict slack +stays positive; at `kappa - 1e-18` all 47 slacks are positive. So the next +tick is blocked by the guard cluster as a whole, and any future improvement +must clear all four margins, not only `compact_phase_layer`. The +kappa-independent slacks are nowhere near binding: the tightest +(`lambda_above_tau`, `lambda_above_internal`, `lambda_prime_above_lambda`) +equal `a_7 * eta = 1.664e-27` exactly. + +**F3 (surcharge attribution confirmed).** The published kappa exceeds the +conservatively admitted `conservative_kappa = 830817325393879/500000000000000000` +by exactly `2881809/10^18 = 2.881809e-12`, matching the recorded +`native_correction_gain`. The only input difference between the two reductions +is the complex endpoint (`b = 0.001664400278850482327913` unsurcharged versus +`conservative_complex_lower = 0.001664400275959073058404` with the bad-residue +surcharge; gap `2.891409e-12`), transferred through the margin with factor +0.996679726523. No other accounting step in the reduction contributes to that +improvement. The published kappa is therefore exactly as strong as the +surcharge-removal justification (the retained PR559 exact-cover recurrence +correction) and no stronger; the certificate's own model controls show the +surcharged moment rejects at `b`. + +**F4 (guard cost quantified).** Setting eta = beta = 0 and removing the +1e-27 floor in `s` raises the cap by exactly `7.634935e-27` and the grid kappa +by 0 ticks. The guard parameters cost less than one tick of the current +1e-18 grid; no kappa improvement is available from tuning them at this grid +resolution. (This is a headroom computation, not a witness: outer.py requires +eta > 0 and beta > 0 strictly, so zero guards are not admissible.) + +## Negative controls + +The script tampers the committed record four ways and asserts each is caught: +kappa bumped one tick, `native_correction_gain` altered, endpoints swapped, +and one outer slack replaced. It also asserts that a nearest-grid rounding +selects the next tick and fails the compact-phase-layer margin. All four +tamper controls are detected on the current record. + +## Coverage limits and inherited assumptions + +- These are finite exact recomputations of recorded identities. They are not + a formal proof and not a re-run of the construction. +- Not checked here: the moment-engine claims themselves ("accepted at b, + rejected at b+1e-24" for both engines), the invoice and owner audit feeding + the endpoints, the seven bootstrap cutoffs' analytic role + (`cutoff_log2 >= 4915613269871` identities were recomputed and match the + record; their sufficiency is the inherited analytic-transfer hypothesis), + and the surcharge-removal justification (PR559 exact-cover recurrence). + Those remain exactly where the selected record places them. +- Inherited all-size/compiler, common-label/mutable-source, whole-call + hosting, precision/tape and analytic hypotheses remain assumptions. This + note does not change the selected result and claims no new kappa. +- The bootstrap cutoffs for steps 2-7 grow past 10^18; the record treats them + as exact integers and so do I. Whether that regime is meaningful is an + analytic question outside this audit. + +## Documentation gap closed + +The maintainer review (`docs/research/community-frontier799-review.md`) and +the package README do not state which margin caps the headline kappa, the +strict 1e-18 floor semantics, or the exact attribution of the +`2881809/10^18` conservative-to-accepted gap. This note pins all three from +the code and the committed record, together with the four-way binding cluster +of F2. + +## Attribution + +Reduction and constraint engines retained from the PR547/PR548 lineage: +`engines/outer.py` prepared by eumemic with Anthropic Claude assistance +(47 constraints retained from icekylinx's PR144, adapted from Zhihao Chen's +PR23; balanced prefix from the RaD project); `code/assemble.py` prepared with +OpenAI Codex assistance in chafreaky's lineage. The selected assembly and its +review are the frontier799 maintainers' work; PR559's exact-cover recurrence +correction is credited there. This audit is new work by sprint agent-05 with +help from opencode, on base commit f567884aeb8851b6e794af1184119a3bfbe1e631. diff --git a/research/audit-kappa-floor-seed67/CLAIM.md b/research/audit-kappa-floor-seed67/CLAIM.md new file mode 100644 index 0000000000..74c8380877 --- /dev/null +++ b/research/audit-kappa-floor-seed67/CLAIM.md @@ -0,0 +1,35 @@ +# Sprint claim (local; no pinned coordination issue exists) + +- Track and seed: 60-74 adversarial mathematical audit; assignment seed 67 + (OS CSPRNG draw). PR #861 already occupies audit seed 67 on physical + counter costs with direction reversals; this claim uses a different object. +- Base commit: f567884aeb8851b6e794af1184119a3bfbe1e631 (origin/main). +- Object under audit: the supplier-endpoint-to-kappa accounting step in the + selected frontier799 assembly + (research/community-frontier799-audit/ASSEMBLY.json, generated by + research/gauge44-frames-x/code/assemble.py, function outer_witness): + the exact reduction from the recorded moment endpoints (complex_lower b, + bit_lower c) and guard parameters (eta = beta = 1e-24, s-floor 1e-27, + seven-step bootstrap chain, 1e-18 grid floor) to the headline + kappa = 1661634653669567/10^18, and which of the 47 strict outer + constraints is tightest at kappa and first violated at kappa + 1e-18. +- Proposed method: code-disjoint exact rational recomputation with Python + stdlib fractions only (no import of the package engines), plus negative + controls on perturbed endpoints; comparison against the committed + ASSEMBLY.json fields. +- Expected deliverable: a research note with exact identities, one + stdlib-only checker script, recorded coverage and negative controls. + No new kappa. +- Expected finish: within this session. + +## Result (recorded after completion) + +Delivered `research/audit-kappa-floor-seed67/`: `AUDIT.md` (findings F1-F4) +and `audit_kappa_reduction.py` (stdlib-only code-disjoint exact checker, +4 tamper negative controls plus a nearest-grid control). Confirmed the +endpoint-to-kappa identity exactly; refined the binding picture to a +four-margin guard cluster; attributed the whole 2881809/10^18 +conservative-to-accepted gap to the complex surcharge removal; quantified +the guard-parameter cost at 7.634935e-27 of cap (0 grid ticks). No new +kappa; no counterexample in the audited step. + diff --git a/research/audit-kappa-floor-seed67/audit_kappa_reduction.py b/research/audit-kappa-floor-seed67/audit_kappa_reduction.py new file mode 100644 index 0000000000..b8a6e8b7d6 --- /dev/null +++ b/research/audit-kappa-floor-seed67/audit_kappa_reduction.py @@ -0,0 +1,241 @@ +#!/usr/bin/env python3 +"""Independent exact audit of the endpoint-to-kappa reduction of the selected +frontier799 assembly (research/community-frontier799-audit/ASSEMBLY.json). + +Scope: the accounting step that turns the recorded moment endpoints +(complex_lower b, bit_lower c) and the guard parameters into the headline +kappa on the 1e-18 grid. Everything is recomputed with fractions from the +formulae in research/gauge44-frames-x/code/assemble.py (outer_witness) and +research/complex-k492-owner-repair/vendor/multicold/engines/outer.py; this +script imports none of the repository engines and re-derives every value. + +Findings (see AUDIT.md): + F1 kappa is the unique largest 1e-18 grid point strictly below the binding + margin minimum = eps*q (the compact_phase_layer margin). + F2 at kappa + 1e-18 exactly the guard cluster of margins co-fails: + compact_phase_layer (the minimum), balanced_prefix (+eta), + Gaussian_arithmetic (+3eta/8) and scalar_work (+7eta/8); every other + strict slack stays positive. + F3 kappa - conservative_kappa = 2881809/10^18 exactly, and the only input + difference between the two reductions is the complex endpoint, so that + entire increment is the complex surcharge removal (PR559 exact-cover). + F4 the guard parameters (eta = beta = 1e-24, s-floor 1e-27) cost at most + a recorded, exact amount of cap headroom. + +Reproduce: python research/audit-kappa-floor-seed67/audit_kappa_reduction.py +Requires CPython >= 3.8, standard library only, no -O. +""" +import json +from decimal import Decimal +from fractions import Fraction as Q +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +ASSEMBLY = ROOT / 'research/community-frontier799-audit/ASSEMBLY.json' + +# Reduction constants, transcribed from assemble.py outer_witness. +A0 = Q(384599, 10**10) +ETA = BETA = Q(1, 10**24) +SFLOOR = Q(1, 10**27) +TICK = Q(1, 10**18) +BRIDGE = {'literal_scalar_guard': Q(1), + 'row_product_gap': Q(10**6) - Q(51 * 20161, 25)} # [5329, 4608] halving pair + + +def ceil(x): + return -(-x.numerator // x.denominator) + + +def reduce_endpoint(b, c, eta=ETA, beta=BETA, sfloor=SFLOOR): + """The complete endpoint -> kappa reduction, exact rationals only.""" + s = min(c, (1 - beta) * b) - sfloor + chain = [A0] + cuts = [] + for _ in range(7): + old = chain[-1] + a = (1 - s) * s + s * old + gap = min(s - a, 1 - a - s, 1 - a - s * (1 - old), 1 - s) + assert gap > 0, 'bootstrap gap closed' + cut = max(ceil(Q(36) / gap**2), ceil(Q(2 * (4 + 512)) / gap)) + assert cut * gap**2 >= 36 and cut * gap >= 2 * (4 + 512) + cuts.append({'exponent': str(a), 'gap': str(gap), 'cutoff_log2': str(cut)}) + chain.append(a) + qw = chain[-1] * (1 - 2 * eta) # outer_witness q + margin = (1 - eta) * qw / (1 + qw) # = eps*qo = minimum margin + ticks = margin * 10**18 + k = Q((ticks.numerator - 1) // ticks.denominator, 10**18) + return {'kappa': k, 'margin': margin, 's': s, 'a7': chain[-1], 'cuts': cuts, + 'bit_binds': c < (1 - beta) * b, + 'endpoint_slack': abs(c - (1 - beta) * b)} + + +def slacks(a, b, kappa, eta=ETA, beta=BETA): + """The 47 strict outer slacks, transcribed from engines/outer.py.""" + tau, sigma = 1 - a, 1 - b + qo = a * (1 - 2 * eta) # outer.py q + lp = 1 - qo + lam = (tau + lp) / 2 + c_par = qo + eta / 4 + eps = (1 - eta) / (1 + qo) + minimum = eps * qo + r = (minimum + 1 - eps) / 2 + delta = eta / 8 + internal = tau + (1 - beta) * max(sigma - tau, Q(0)) + leaf = sigma + beta * (1 - sigma) + margins = {'balanced_prefix': 1 - eps, 'coordinate_movement': a, + 'compact_phase_layer': minimum, 'bulk_exposure': a, + 'Gaussian_arithmetic': min(1 - eps - delta, r - delta), + 'scalar_work': 1 - eps - delta, 'dimension': eps} + out = {'bit_positive': a, 'complex_above_bit': b - a, + 'complex_below_one_over32': Q(1, 32) - b, 'beta_positive': beta, + 'beta_below_one': 1 - beta, 'leaf_saving_above_bit': (1 - beta) * b - a, + 'q_positive': qo, 'q_below_internal': 1 - internal - qo, + 'q_below_leaf': 1 - leaf - qo, 'c_positive': c_par, + 'c_below_one': 1 - c_par, 'q_below_reservations': c_par - qo, + 'lambda_above_tau': lam - tau, 'lambda_above_sigma': lam - sigma, + 'lambda_above_internal': lam - internal, + 'lambda_prime_above_lambda': lp - lam, 'compact_leaf': lp - leaf, + 'compact_reservations': lp - (1 - c_par), 'lambda_prime_below_one': qo, + 'epsilon_positive': eps, 'epsilon_below_one': 1 - eps, + 'guard_width': 1 - eps, 'K_geometry': 1 - eps * (1 + c_par), + 'K_dominates_log': eps * c_par, 'record_suffix': 1 - eps, + 'phase_local': 1 - eps - delta, 'phase_boundary': r - delta, + 'gamma_sublinear': 1 - eps - r, 'cell_above_band': eps - (1 - r) / 2, + 'prime_interval_packing': 1 - eps, 'alpha_positive': r, + 'alpha_below_one': 1 - r, 'alpha_below_one_fourth': Q(1, 4) - r, + 'delta_positive': delta, 'delta_below_one_eighth': Q(1, 8) - delta, + 'short_record_fallback': eps - a, 'small_field_exposure': 1 - eps - minimum, + 'artificial_boundary': 8 - eps + r - delta - minimum, + 'literal_scalar_guard': BRIDGE['literal_scalar_guard'], + 'row_product_gap': BRIDGE['row_product_gap']} + out.update({name + '_above_kappa': val - kappa for name, val in margins.items()}) + assert len(out) == 47 and len(margins) == 7 + assert min(margins.values()) == minimum + return out, margins + + +def q_from_decimal_string(text): + return Q(Decimal(text)) + + +def check(asm): + """Assert every audited identity against the committed assembly record.""" + b, c = Q(asm['complex_lower']), Q(asm['bit_lower']) + k_rec = Q(asm['kappa']) + red = reduce_endpoint(b, c) + k, margin = red['kappa'], red['margin'] + + # F1: the recorded headline equals the strict grid floor of the margin. + assert k == k_rec, 'recomputed kappa differs from recorded' + assert q_from_decimal_string(asm['kappa_decimal']) == k_rec + assert q_from_decimal_string(asm['complex_decimal']) == b + assert q_from_decimal_string(asm['bit_decimal']) == c + assert k < margin < k + TICK, 'kappa is not the unique largest grid point below margin' + + # The transcribed 47 slacks must equal the recorded ones exactly. + outer, margins = slacks(red['a7'], b, k) + assert set(outer) == set(asm['outer']) + for name, val in outer.items(): + assert val == Q(asm['outer'][name]), 'outer slack mismatch: ' + name + + # Bootstrap table recomputation (accepted row). + assert red['cuts'] == asm['bootstrap'], 'bootstrap table mismatch' + + # F2: kappa + one tick fails on exactly the margins within one tick above + # the minimum margin: compact_phase_layer (the minimum itself) and the + # guard-cluster balanced_prefix (+eta), Gaussian_arithmetic (+3eta/8), + # scalar_work (+7eta/8). No other strict slack turns non-positive. + outer_next, margins_next = slacks(red['a7'], b, k + TICK) + failing = sorted(n for n, v in outer_next.items() if v <= 0) + assert failing == ['Gaussian_arithmetic_above_kappa', 'balanced_prefix_above_kappa', + 'compact_phase_layer_above_kappa', 'scalar_work_above_kappa'], failing + minimum = min(margins_next.values()) + cluster = {n: m - minimum for n, m in margins_next.items() if m - minimum < TICK} + assert sorted(n + '_above_kappa' for n in cluster) == failing + assert max(cluster.values()) < TICK, 'guard cluster exceeds one tick' + outer_prev, _ = slacks(red['a7'], b, k - TICK) + assert all(v > 0 for v in outer_prev.values()), 'kappa - one tick should stay admitted' + + # F3: the whole accepted-over-conservative increment is the surcharge removal. + cb = Q(asm['conservative_complex_lower']) + ck_rec = Q(asm['conservative_kappa']) + cred = reduce_endpoint(cb, c) + assert cred['kappa'] == ck_rec, 'recomputed conservative kappa differs' + assert q_from_decimal_string(asm['conservative_kappa_decimal']) == ck_rec + assert cred['cuts'] == asm['conservative_bootstrap'], 'conservative bootstrap mismatch' + couter, _ = slacks(cred['a7'], cb, ck_rec) + for name, val in couter.items(): + assert val == Q(asm['conservative_outer'][name]), 'conservative slack mismatch: ' + name + gain = k - ck_rec + assert gain == Q(2881809, 10**18), 'conservative-to-accepted gap changed' + assert gain == q_from_decimal_string(asm['native_correction_gain']) + assert asm['surcharge_model'] == {'complex': False, 'bit': True} + + # F4: exact guard cost, guards -> 0 (headroom only: eta, beta must stay > 0 + # for the strict outer set, so this is an upper envelope, not a witness). + ideal = reduce_endpoint(b, c, eta=Q(0), beta=Q(0), sfloor=Q(0)) + assert ideal['margin'] > margin and ideal['kappa'] >= k + + return {'kappa': k, 'margin': margin, 'margin_over_kappa': margin - k, + 'next_tick_over_margin': k + TICK - margin, 's': red['s'], 'a7': red['a7'], + 'bit_binds': red['bit_binds'], 'endpoint_slack': red['endpoint_slack'], + 'conservative_kappa': ck_rec, 'gain': gain, + 'endpoint_gain': b - cb, 'transfer': gain / (b - cb), + 'guard_cap_cost': ideal['margin'] - margin, + 'guard_grid_cost': ideal['kappa'] - k, + 'cluster': sorted(cluster.items()), + 'tightest': sorted(((v, n) for n, v in outer.items()))[:5], + 'cutoff_log2': [cut['cutoff_log2'] for cut in red['cuts']]} + + +def controls(): + """Negative controls: each tampered record must fail the audit identities.""" + asm = json.loads(ASSEMBLY.read_text()) + for label, mutate in [ + ('next_tick', lambda d: d.__setitem__('kappa', str(Q(d['kappa']) + Q(1, 10**18)))), + ('gain_tamper', lambda d: d.__setitem__('native_correction_gain', '2.88181E-12')), + ('endpoint_swap', lambda d: (d.__setitem__('complex_lower', d['bit_lower']), + d.__setitem__('bit_lower', '1/2'))), + ('slack_tamper', lambda d: d['outer'].__setitem__('bit_positive', '1/1000000000000000000')), + ]: + bad = json.loads(json.dumps(asm)) + mutate(bad) + try: + check(bad) + except AssertionError: + pass + else: + raise AssertionError('negative control not detected: ' + label) + # A nearest-grid rounding would pick the next tick here and violate the + # compact-phase-layer margin; the strict floor must not. + red = reduce_endpoint(Q(asm['complex_lower']), Q(asm['bit_lower'])) + nearest = red['kappa'] + TICK # margin - kappa = 7.58e-20 < half a tick + assert red['margin'] - red['kappa'] < TICK / 2 + assert slacks(red['a7'], Q(asm['complex_lower']), nearest)[0]['compact_phase_layer_above_kappa'] <= 0 + return 4 + + +def main(): + assert __debug__, 'Do not run with python -O' + asm = json.loads(ASSEMBLY.read_text()) + rep = check(asm) + n = controls() + print('PASS endpoint-to-kappa reduction audit (seed 67)') + print(' kappa =', asm['kappa']) + print(' margin - kappa = %.6e' % float(rep['margin_over_kappa'])) + print(' (kappa + 1e-18) - margin = %.6e' % float(rep['next_tick_over_margin'])) + print(' binding endpoint =', 'bit' if rep['bit_binds'] else 'complex') + print(' endpoint slack c-(1-beta)b = %.6e' % float(rep['endpoint_slack'])) + print(' conservative -> accepted gap =', rep['gain'], '(=%.6e)' % float(rep['gain'])) + print(' endpoint gap b - b_c = %.6e' % float(rep['endpoint_gain'])) + print(' transfer factor = %.12f' % float(rep['transfer'])) + print(' guard cap cost (guards->0) = %.6e' % float(rep['guard_cap_cost'])) + print(' guard grid cost = %s' % rep['guard_grid_cost']) + print(' tightest outer slacks =', [(n, '%.3e' % float(v)) for v, n in rep['tightest']]) + print(' margin cluster above minimum =', [(n, '%.3e' % float(v)) for n, v in rep['cluster']]) + print(' bootstrap cutoff_log2 =', rep['cutoff_log2']) + print(' negative controls detected = %d' % n) + + +if __name__ == '__main__': + main() From 144e7e21c4f6ab4afda1338fe25eaab5a53b4431 Mon Sep 17 00:00:00 2001 From: Aaron Wang Date: Tue, 13 Oct 2026 06:46:29 -0400 Subject: [PATCH 2/2] Record the audit result and PR link in the sprint claim --- research/audit-kappa-floor-seed67/CLAIM.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/research/audit-kappa-floor-seed67/CLAIM.md b/research/audit-kappa-floor-seed67/CLAIM.md index 74c8380877..d4352e7f2c 100644 --- a/research/audit-kappa-floor-seed67/CLAIM.md +++ b/research/audit-kappa-floor-seed67/CLAIM.md @@ -33,3 +33,6 @@ conservative-to-accepted gap to the complex surcharge removal; quantified the guard-parameter cost at 7.634935e-27 of cap (0 grid ticks). No new kappa; no counterexample in the audited step. +Submitted as PR https://github.com/CrocSwap/integer-mult-bounds/pull/894 +(base commit f567884aeb8851b6e794af1184119a3bfbe1e631). +