From 4ead11e6e10cc7f13a340563990f50f86cc2668b Mon Sep 17 00:00:00 2001 From: Abhinav Ramachandran Date: Thu, 8 Oct 2026 23:11:15 -0700 Subject: [PATCH] Re-instantiate the phase-stop on the p = 11 paired cubes: kappa = 5.108294e-4 Single squashed commit carrying research/paired-cube-p11-tightened/ on top of the repository main, representing a one-file-package diff on top of #152 (commit ae9baba). #152's construction unchanged; the assembly's declared- free phase-stop constant moves from the inherited 1/10^6 to 10^-12. The complex side binds (AC = 5113520/10^10), so the (1-beta)*AC ceiling moves directly onto kappa: 5108289/10^10 -> 2554147/5*10^9 (+5 grid points), next point rejected by #152's own 47-constraint assembly. Same move as #104 over #97 and #135/#137/#138. --- research/paired-cube-p11-tightened/README.md | 59 ++++++++++++++ research/paired-cube-p11-tightened/verify.py | 81 ++++++++++++++++++++ 2 files changed, 140 insertions(+) create mode 100644 research/paired-cube-p11-tightened/README.md create mode 100644 research/paired-cube-p11-tightened/verify.py diff --git a/research/paired-cube-p11-tightened/README.md b/research/paired-cube-p11-tightened/README.md new file mode 100644 index 0000000000..8b4c8103b0 --- /dev/null +++ b/research/paired-cube-p11-tightened/README.md @@ -0,0 +1,59 @@ +# Re-instantiated phase-stop on the p = 11 paired cubes: conditional κ = 5.108294e-4 + +Under #152's retained interfaces this package certifies + + T(n) = O(n (log n)^(1 - kappa)), kappa = 2554147/5000000000 = 5.108294e-4 + +This is #152's construction unchanged — eumemic's paired cubes at p = 11 +(h = 22, R = 18,473) with the h = 21 bit word in #97's frozen format — with +one assembly instantiation constant re-chosen: the phase-stop +`beta`: `PHASE_STOP = 1/10^6` (the merged #144 value #152 inherited) becomes +`10^-12`. + +The phase-stop is a free positive constant of the retained #144 assembly: it +enters only the `(1 - beta) * AC - 10^-10` bit-ceiling term and the 47 strict +inequalities, and #152's complex side binds (`AC = 5113520/10^10`), so the +ceiling moves directly onto kappa. The same re-instantiation, at the same +constant and for the same reason, is the move of #104 over #97 and of #135, +#137 and #138 in this repository's lineage. No word, plan, row, bridge or +lemma changes; every inherited interface remains an assumption exactly as in +#152. + +| | phase-stop | kappa | +|---|---:|---:| +| #152 (inherited) | 10^-6 | 5108289/10^10 | +| this branch | 10^-12 | **2554147/5\*10^9** (+5 grid points) | + +The next 10^-10 grid point is rejected. The atom exponent and the 10^-10 +backoff in the ceiling term are left at #152's pinned values: at the complex- +binding face the atom contributes nothing (verified), and the backoff +literal is part of #152's published interface rather than a declared free +constant. + +## Verify + +From the repository root (Python 3.10+ stdlib; about a minute; do not use `-O`): + + python3 research/paired-cube-p11-tightened/verify.py + +The script reproduces #152's published kappa exactly at the inherited +constants, then rebinds the module-global `PHASE_STOP` to 10^-12 and reruns +#152's own 47-constraint assembly, asserting the new grid value and the +next-point rejection at both steps. + +## Credits + +- eumemic: #152 (the p = 11 instance and the h = 21 bit word this branch + re-prices), #117 (the positive DAG), with Anthropic Claude assistance. +- icekylinx: #144/#130 (paired cubes, shared cores, the assembly whose + phase-stop is re-instantiated here). +- Zhihao Chen (#97 frozen-word reader), Swapnil Jain (round-seven checkers), + an664 (#128 completed-core sharing). +- The re-instantiation and this package: Abhinav Ramachandran with Hermes + (Nous Research) assistance. + +## Scope + +Conditional, as in #152: no unconditional multiplication theorem is claimed. +All inherited written proof dependencies (shared-core execution, word-frame +nesting, uniformity and tape contracts) remain explicit assumptions. diff --git a/research/paired-cube-p11-tightened/verify.py b/research/paired-cube-p11-tightened/verify.py new file mode 100644 index 0000000000..4661e4a069 --- /dev/null +++ b/research/paired-cube-p11-tightened/verify.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +"""Re-instantiate #152's assembly phase-stop constant and re-price kappa. + +#152's paired_cube_network.py declares PHASE_STOP = 1/10^6 (the merged #144 +value) while its complex side binds (AC = 5113520/10^10). The phase-stop beta +is a free positive constant of the retained assembly (it enters only the +(1-beta)*AC - 10^-10 ceiling term and the 47 strict inequalities, exactly as +in #104/#135/#137/#138 in this repository's lineage), so re-instantiating it +changes no lemma. This script: + + 1. reproduces #152's published value exactly at the inherited constants + (kappa = 5108289/10^10, next point rejected); + 2. re-runs the same assembly with beta = 10^-12 and reports the new exact + grid kappa with the next grid point rejected. + +All arithmetic is #152's own paired_cube_network.py; only the module-global +PHASE_STOP is re-bound between runs. Stdlib only; do not use -O. +""" +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / 'scripts')) +sys.set_int_max_str_digits(0) + +import paired_cube_network as pcn + +complex_input = json.loads((ROOT / 'certificates/paired-cube-complex-input.json').read_text()) + + +def best_kappa(): + phase = pcn.complex_certificate(complex_input) + bridge = pcn.finite_bridge(phase, None, complex_input) + ab = (1 - pcn.ATOM) * pcn.COARSE + pcn.ATOM * pcn.OLD + assert ab < pcn.ATOM < 1 - ab, 'Subordinate adapter and row tolls' + asb = min(ab, (1 - pcn.PHASE_STOP) * pcn.AC - Q(1, 10**10)) + grid = 10**10 + + def accepts(kk): + try: + pcn.assembly(asb, pcn.AC, bridge, Q(kk, grid), beta=pcn.PHASE_STOP) + return True + except (AssertionError, ValueError): + return False + + lo, hi = 0, int(pcn.AC * grid) + assert accepts(lo) and not accepts(hi) + while hi - lo > 1: + mid = (lo + hi) // 2 + lo, hi = (mid, hi) if accepts(mid) else (lo, mid) + assert accepts(lo) and not accepts(lo + 1) + res = pcn.assembly(asb, pcn.AC, bridge, Q(lo, grid), beta=pcn.PHASE_STOP) + assert len(res['strict_constraints']) == 47 and all(v > 0 for v in res['strict_constraints'].values()) + assert len(res['margins']) == 7 + return Q(lo, grid), res + + +def main(): + assert not sys.flags.optimize + # 1) #152 control at inherited constants + assert pcn.PHASE_STOP == Q(1, 10**6), pcn.PHASE_STOP + k0, res0 = best_kappa() + assert k0 == Q(5108289, 10**10), k0 + print('PASS #152 control: kappa = 5108289/10^10 (next point rejected), 47 constraints, 7 margins') + + # 2) re-instantiate beta + pcn.PHASE_STOP = Q(1, 10**12) + k1, res1 = best_kappa() + assert k1 == Q(2554147, 5 * 10**9), k1 + assert (k1 - Q(5108289, 10**10)) * 10**10 == 5 + print('PASS tightened phase-stop: beta = 10^-12, kappa = 2554147/5000000000 =', + '5.108294e-4 (next point rejected), 47 constraints, 7 margins') + print('gain: +5 grid points of the 10^-10 grid over the inherited instantiation') + print('PASS conditional re-instantiation; all inherited interfaces remain assumptions') + + +if __name__ == '__main__': + main()