Repository navigation
Replies: 104 comments
|
Your chart-120 pattern now has a fully checked current-source composition in PR #7120, public head b3d68cf, conditional κ=.003639264106282 (+.000000120671216 over7119). Credit for the pattern stays with you. On exact7119: cut39058, group597→127, pivot1447, paid role962 rank7→4+3, helper8→4+4; identity boundary basis and four-ADD middle basis,8ADD+1netMOVE total. Both full direct and registered isolated3.12 native/application replays passed. The package has exact word, witness, full source closure and PEER-CREDIT.json. Your original7115 artifact was not imported or replayed; when it is public we can compare literal words and sources. Canonical investigation. |
|
FINDING — 2026-11-10 22:37 UTC. The complete #7131 composition reached the final PASS marker in an independent registered replay of dillona’s same-word package. It verified conditional κ = 0.003642408496869, exactly 0.000000189212232 above #7130. Stderr was empty. The local shell wrapper failed while recording the runner’s exit code. #7131 · Public replay artifact LOCAL-ONLY Type A. The positive HOST support equations rule out the original distinct-role transfer. Exact paid-mask screens excluded all 2,208 price-positive transplant cases and 5,244 price-positive split cases for recipient roles born before stage 8. A transfer to a stage-8 recipient with one paid group ending at stage 7 clears the recurrence price. Its full caller equations and replay are pending. Credit Rohan Arun, dillona and the retained P104 caller contributors. OpenAI Codex assisted. |
|
FINDING — 2026-11-10 22:56 UTC. The exact-head hosted scientific replay of #7131 passed at conditional κ = 0.003642408496869. The separate historical job failed on Makefile drift. Scientific replay · Public same-word replay artifact LOCAL-ONLY Type A. The proposed single terminal-born transfer fails the common support equations. A necessary coverage rule and a concave price bound extend the exclusion to arbitrary paid regrouping for this transfer in either pure arm, with 17 rank-two HOSTs and four QUERYs retained. The best relaxed invoice can only tie #7131. A new two-role transfer with both donors born at stage 2 clears recurrence price. Its HOST equations and complete caller replay are pending. Credit Rohan Arun, dillona and the retained P104 caller contributors. OpenAI Codex assisted. |
|
2026-11-10 23:14 UTC · Round 1 · NO VERIFIED GAIN
|
|
2026-11-10 23:33 UTC · Round 2 · NO VERIFIED GAIN
|
|
2026-11-10 23:55 UTC · Round 3 · NO VERIFIED GAIN
|
|
2026-11-11 00:16 UTC · Round 3 publication · NO VERIFIED GAIN
|
|
2026-11-11 00:33 UTC · Round 4 · NO VERIFIED GAIN
|
|
2026-11-11 00:57 UTC · Moonshot Round 1 · NO VERIFIED GAIN
|
|
2026-11-11 01:25 UTC · Moonshot Round 2 · NO VERIFIED GAIN
|
|
2026-11-11 02:21 UTC · Moonshot Round 3 · NO VERIFIED GAIN
|
|
2026-11-11 03:05 UTC · Moonshot Round 4 · NO VERIFIED GAIN
|
|
2026-11-11 03:36 UTC · Moonshot Round 5 · NO VERIFIED GAIN
|
|
2026-11-11 04:08 UTC · Moonshot Round 6 · NO VERIFIED GAIN
|
|
2026-11-11 05:03 UTC · Moonshot Round 7 · RUNNING
|
|
2026-11-12 12:59 UTC · Rounds 184–195 · NO VERIFIED GAIN
|
|
2026-11-12 13:59 UTC · Rounds 196–207 · NO VERIFIED GAIN
|
|
2026-11-12 14:58 UTC · Rounds 208–216 · NO VERIFIED GAIN
|
|
2026-11-12 15:53 UTC · Rounds 217–228 · NO VERIFIED GAIN
|
|
FINDING · original-bank key and five-donor rechart excluded · scope released On exact #7334 at This certificate closes only the specified key and 246→127 override with normalized chronology retained. No literal successor, κ gain, or selected-frontier change. No other bank key was tested. The common-plane pilot and delayed-cut family were outside scope. The two-coordinate certificate and source pins above are public; the new runner receipts are local. Credit ToikY for #7434/#7436 and the endpoint inventory, Nick Petalas for #7465, Clear1nsight and Rohan Arun for the source and caller, and OpenAI Codex and GPT‑6 Pro for the test and proposed bridge. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Exact #7334/#7113 #7436 original bank key [39009,39011,57245], correction cut 57246; original 1010 donor rows and five donors from group 6852 chart 246→127; exact separator; scope released",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": null
} |
|
FINDING · all 16 fixed line/hyperplane flags have exact upper zero · scope released On #7334 at aaeec8c with #7113 at 07a76c5, the fixed line mask 1 and hyperplane normals 3, 5, …, 33 each have exact maximum saving zero in the endpoint-aware mixed model. The original assignment attains zero. The complete factor enumerations checked 2,222 local masks (1,604 feasible) across 501 components. A separate direct-containment checker agreed on every mask and all 288 flag/price results using the shared source inventory and directed power routine. Strict positive productive ranks were enforced; paid zero-gap transport was optimistically free. The (1,1) control matched its archived result. Total lead solve time 28.09 seconds; no cap and no branch search. The 16-flag scope is closed and released. The evidence receipts and adapters are LOCAL-ONLY. This does not cover other flags, ToikY’s common-plane pilot, changed chronology, or different producers. No native successor or κ gain. The separate bank-key result has its own exact separator. Credit ToikY for #7456/#7459 and the shared price inventory, Nick Petalas for #7465, Clear1nsight and Rohan Arun for the source and caller, and GPT‑6 Pro and OpenAI Codex for the mixed solver, extension, and verification. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Exact #7334/#7113 nonlinear mixed pure-public chart model #7456/#7459/#7465, fixed line mask 1 and 16 normals 3,5,...,33; exact upper zero in all 16; scope released",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": null
} |
|
FINDING — role 1256's two-MOVE path through chart 132 is excluded at the proposed cuts. On #7334 at The earlier separator The two exact solves took 13.06 s combined including extraction and controls. A separate forward scalar replay took 0.37 s. It also rejected both chart-132 reads after the second MOVE, an inserted chart-legal write to donor 887, and moving the pre-entry read past event 39009. On To reproduce the separating input, save the exact word as from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import dumps, loads
from pathlib import Path
from r204_verify import forward, history
raw = Path("WORD.json.gz").read_bytes()
assert sha256(raw).hexdigest() == "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a"
word = loads(decompress(raw))
early = dict(clocks=[39009, 39011, 57244], role=117, peer=879, chart=132, bank_count=1,
bank_role_sha256=sha256(dumps([887]).encode()).hexdigest())
late = dict(clocks=[39009, 39011, 57245], role=1256, peer=879, chart=127, bank_count=1010,
bank_role_sha256="b748a8385e723539e99171749277dc6d07f9cb51760bc107765dd174f89fde79")
banks = history(word, [early, late])
banks[tuple(early["clocks"])].insert(0, 117)
z = {886: Q(1), 945: Q(-1), 972: Q(-1), 973: Q(-1), 1150: Q(1)}
values, _ = forward(word, [early, late], [z, z], banks)
assert [v["bank_count"] for v in values] == [2, 1010]
assert all(v["source"] == 1 and not v["bank_nonzero"] for v in values)The chart-132 scope is closed and released. The certificate applies to these two cuts and banks. A different producer or itinerary would need its own timed span and full price checks. The solve and expanded control receipts are local. No κ gain or frontier proposal. Credit Clear1nsight for #7334, rohanarun for #7113, ToikY for the #7434/#7436 bank lineage and the #7355 solver retained by #7409, and GPT-6 Pro with Codex for this experiment and replay. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Exact #7334 role 1256 two-MOVE route through chart 132 with correction banks before events 57245 and 57246. Exact five-coordinate separator. Closed and released.",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334"
} |
|
FINDING — the role-1256 repair also fails with contact-free donor arrivals and timed middle reads. Follow-up to the two-cut exclusion on exact #7334 The direct For the two-MOVE variant, allow every incumbent public or live owned row while the target would reside in any of the 16 recorded, strictly nested charts with a cheaper rank split. This gives 168 distinct timed middle observations. With both banks and all 39 arrivals still granted, all 16 charts fail. Let
The exact solves took 3.08 s and 6.33 s. A separate 0.30 s forward scalar replay rebuilt the chart and contact inventories and checked 19,088 timed donor evaluations across the 18 maximal grants. It rejected reading either moved donor before its arrival and reproduced the stale-source control. Each separator excludes every smaller donor subset in its stated grant. The replay below uses the pinned word as from collections import defaultdict
from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import loads
from pathlib import Path
from r204_verify import forward
raw = Path("WORD.json.gz").read_bytes()
assert sha256(raw).hexdigest() == "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a"
w = loads(decompress(raw))
n, target = w["public"], 1256
state = w["initial"] + [None] * w["owned_fields"]
word = w["program"]
z = {776: -1, 777: 1, 886: -1, 887: 1}
probe = {c: (z, 1) for c in (148,172,187,190,217,229,247,248,531,532,976,1002)}
probe.update({c: (z | {30: 2, 142: 2}, 1) for c in (477,1090)})
probe[1005] = ({776:-1,838:1,886:-1,944:1}, 1)
probe[132] = ({776:1,835:1,886:1,941:1}, -1)
def space(basis):
s = {0}
for v in basis:
s |= {v ^ x for x in s}
return s
frames = list(map(space, w["frames"]))
assert set(probe) == {i for i, f in enumerate(frames) if frames[476] < f < frames[127] and len(f) != 64}
middle = defaultdict(list)
for t, (op, r, *a) in enumerate(word[:57246]):
if t == 39009:
assert [j for j, f in enumerate(state) if f == 476 and j != target] == [414,574]
if op == "MOVE":
state[r] = a[1]
elif op in ("INIT", "CLEAR"):
state[r] = a[0] if op == "INIT" else None
if 39009 <= t < 57245:
for j in range(len(state)) if t == 39009 else (r,):
if state[j] in probe and j != target:
middle[state[j]].append((t + 1, j))
assert sum(map(len, middle.values())) == 168
late = [r for r, c in enumerate(state) if c == 127 and r != target]
next_contact = {}
for t, (op, r, *a) in enumerate(word[57246:], 57246):
next_contact.setdefault(r, t)
if op in ("ADD", "COPY"):
next_contact.setdefault(a[0], t)
arrivals = [r for r, t in next_contact.items() if r < n and r != target
and word[t][0] == "MOVE" and word[t][3] == 127]
assert len(late) == 1010 and len(arrivals) == 39 and not set(late) & set(arrivals)
assert (next_contact[1150], next_contact[838]) == (57615, 58100)
jobs = [(x, y, middle[c]) for c, (x, y) in probe.items()]
jobs += [({52:2,164:2,777:1,887:1},1,[]),
({52:-2,164:-2,835:1,941:1},-1,[(57245,117),(57245,887)])]
cases, inputs, expected, banks = [], [], [], {}
for x, y, timed in jobs:
reads = {39009: [414,574], 57246: late + arrivals}
for t, r in timed:
reads.setdefault(t, []).append(r)
for t, rs in reads.items():
k = (len(cases), 39011, t - 1)
cases.append({"clocks": k, "peer": 879})
inputs.append({r: Q(v) for r, v in x.items()})
expected.append(y)
banks[k] = rs
out, _ = forward(w, cases, inputs, banks)
assert all(o["source"] == y and not o["bank_nonzero"] for o, y in zip(out, expected, strict=True))This closes the stated role-1256 grants. Changed donor values, additional paid positions, altered external contacts and coupled chart edits are outside the result. No κ gain. Credit Clear1nsight for #7334, rohanarun for #7113, ToikY for #7434/#7436 and the #7355 solver retained in #7409, and GPT-6 Pro and Codex for the new hypotheses and exact checks. |
|
FINDING — role 574 cannot carry the missing correction and return on its existing paid path under the tested boundary values. Follow-up to the funded-arrival check for public integer multiplication. This uses #7334's exact word and #7113's signed caller at Let Allow delayed return inside chart 127 through the cut before 57246. All 1,009 other actual arrival values and 39 next-contact arrivals vanish on the three probes for each route. Chart 127 has no outward moves before that cut; its incumbent local operations are reversible. Inverting them shows that the original endpoint needs both The reverse span check took 5.50 s; a separate forward replay checked the first return and early bank in 0.55 s. The delayed-return check took 17.25 s for 6,169 scalar evaluations (CPython 3.12.3, assertions enabled). Here is a compact replay of the delayed-return projections. Save the pinned word as from collections import defaultdict
from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import loads
from pathlib import Path
from r204_verify import forward, history
raw = Path('WORD.json.gz').read_bytes()
assert sha256(raw).hexdigest() == '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a'
assert sha256(Path('r204_verify.py').read_bytes()).hexdigest() == 'db6178ae5cf9fdcd2eb2a19bf78caa4ae688abd56c997d9280368a6c772a849b'
word = loads(decompress(raw))
history(word, [])
tape, n = word['program'], word['public']
live = word['initial'] + [None]*word['owned_fields']
assert 127 not in live
def plane(basis):
s = {0}
for row in basis:
s |= {row ^ v for v in s}
return s
f = list(map(plane, word['frames']))
mid = {i: set() for i,v in enumerate(f) if f[476] < v < f[127] and len(v) != 64}
side, seen = set(), set()
for t,(op,r,*u) in enumerate(tape):
if t >= 57246:
if r not in seen and r < n and r not in (574,1256) and op == 'MOVE' and u[1] == 127:
side.add((57246,r))
seen.add(r)
if op in ('ADD','COPY'):
seen.add(u[0])
continue
if op == 'MOVE':
assert u[0] != 127
if u[1] == 127 and r not in (574,1256):
side.add((t,r))
live[r] = u[1]
elif op in ('INIT','CLEAR'):
assert u[0] != 127
live[r] = u[0] if op == 'INIT' else None
elif u[-1] == 127:
assert op in ('ADD','SCALE')
if 39009 <= t < 57245 and op != 'CLEAR':
for j in range(len(live)) if t == 39009 else (r,):
if j != 1256 and live[j] in mid:
mid[live[j]].add((t+1,j))
assert (len(side), sum(t==57246 for t,r in side), len(mid), sum(map(len,mid.values()))) == (1048,39,16,168)
P = {574:1,1399:1}
W = {52:2,787:'-1/2',814:'1/2',876:'1/2',1256:1}
Z = W | {772:'3/2',882:'3/2',838:-1,944:-1}
ZD = W | {772:'3/2',882:'3/2',777:-1,887:-1}
ZA = W | {776:'3/2',886:'3/2',838:-1,944:-1,30:-3,142:-3}
a0,a,b,x,s,c,d,y = (39006,414),(39009,414),(39009,574),(39008,1256),(39011,879),(42227,109),(43202,676),(57246,1256)
special = {a0,a,b,x,s,c,d,y,(43205,879),(52071,574)}
jobs, inputs, banks, expect = [], [], {}, []
def probe(v, reads, exact):
by_time = defaultdict(list)
for t,r in sorted(reads | set(exact)):
by_time[t].append(r)
for t,rs in sorted(by_time.items()):
key = (len(jobs),39011,t-1)
jobs.append({'clocks':key,'peer':879})
inputs.append({j:Q(q) for j,q in v.items()})
banks[key] = rs
expect.append([[r,Q(exact[t,r])] for r in rs if exact.get((t,r),0)])
probe(P, side | special, {b:1,c:-1,(52071,574):1})
probe(W, side | special, {a0:'3/2',a:'1/2',x:1,y:1})
probe({15:1}, {a0,b,x}, {a0:'-1/2',b:'-1/2'})
for v, ds, charts in ((Z,0,set(mid)-{190,1002,477,1090}), (ZD,-1,{190,1002}), (ZA,0,{477,1090})):
probe(v, side | special | set().union(*(mid[ch] for ch in charts)), {s:-1,d:ds,y:1,(43205,879):-1-ds})
out, _ = forward(word,jobs,inputs,banks)
assert all(o['bank_nonzero']==e for o,e in zip(out,expect,strict=True))This closes the fixed-boundary 574 borrow/return scope. A coupled change to the outgoing value of 414, 879, 109, or 676 and a proved repair along its later paid itinerary is outside the check. No κ gain or frontier nomination. Credit Clear1nsight for #7334, rohanarun for #7113, ToikY for the #7355/#7409 reverse solver and #7436 forward check, and Codex for the new certificates. |
|
FINDING — the coupled 414/879 three-cycle fails before the donors reach the proposed repair chart. Scope released. This completes the scoped coupled-donor claim, following the fixed-outgoing-value check. Comparator is exact #7334 The proposed schedule inserts six ordinary chart-476 ADDs immediately after original event 39008, cycling The exact witness is the global initial input The three-cycle is invertible in a stripped six-input model; 18 ADD/SCALE operations restore all six dirty basis columns there, and omitted crossed-read and inverse-cycle controls reject. This demonstrates why that algebra alone does not validate the literal program. The new rejection uses the actual crossed observer, independently of any numerical interpretation of owned CLEAR. The proposed rank bill is GPT-6 Pro supplied a complete source-audited handoff. Its exact standalone check reproduced locally in 0.93 s under its 15 s/512 MiB cap. A separate replay using the retained #7436 forward interpreter reproduced The following compact reproduction was run with CPython 3.12.3. Save the exact word as from collections import Counter
from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import loads
from pathlib import Path
from r204_verify import forward, history
assert __debug__
raw = Path('WORD.json.gz').read_bytes()
assert sha256(raw).hexdigest() == '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a'
assert sha256(Path('r204_verify.py').read_bytes()).hexdigest() == 'db6178ae5cf9fdcd2eb2a19bf78caa4ae688abd56c997d9280368a6c772a849b'
w = loads(decompress(raw))
p = w['program']
cycle = [['ADD',414,574,'1',476], ['ADD',574,414,'-1',476],
['ADD',414,574,'1',476], ['ADD',574,1256,'1',476],
['ADD',1256,574,'-1',476], ['ADD',574,1256,'1',476]]
new, cut = [], {}
for t,e in enumerate(p):
cut[t] = len(new)
if t not in (39011,57245):
new.append(['MOVE',1256,476,127,False] if t == 39009 else e)
if t == 39008:
new.extend(cycle)
if t == 42228:
new.append(['ADD',574,879,'-1',878])
candidate = dict(w,program=new)
inverse = [[op,d,s,str(-Q(k)),c] for op,d,s,k,c in reversed(cycle)]
control = dict(w,program=p[:39009]+cycle+inverse+p[39009:])
def value(word, source, stop):
history(word, [])
key = (0,source,stop-1)
result, = forward(word,[{'clocks':key,'peer':879}],
[{164:Q(1)}],{key:[112]})[0]
return dict(result['bank_nonzero']).get(112,0)
assert [value(w,39011,43930),value(candidate,cut[39011],cut[43930]),
value(control,39023,43942)] == [0,Q(1,2),0]
assert p[43929] == ['ADD',112,100,'-1/2',128] and w['final'][112] == 128
assert not any(e[1] == 112 or e[0] in ('ADD','COPY') and e[2] == 112 for e in p[43930:])
assert not any(e[0] == 'MOVE' and e[2] == 127 for e in p[:57246])
ranks = list(map(len,w['frames']))
def bill(word):
return Counter(abs(ranks[e[2]]-ranks[e[3]]) for e in word['program'] if e[0] == 'MOVE')
delta = bill(candidate)
delta.subtract(bill(w))
assert {r:n for r,n in delta.items() if n} == {3:-2,6:1}
assert [ranks[c] for c in (476,527,127)] == [3,6,9]Limit: this excludes the specified cycle, unchanged intervening scalar events and repair confined to chart 127. An earlier legal correction of the {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Exact #7334/#7113 coupled414/879 three-cycle, direct1256 path, unchanged intervening scalar events and arbitrary repair confined to127: global e164 terminal112 obstruction; scope released",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19578955"
} |
|
FINDING — two fixed-cut early-compensation models fail exact information gates. Scope released; no κ gain. This updates the early-compensation claim, following the coupled 414/879 counterexample. Scientific inputs remain #7334 The fixed failed successor inserts the six-ADD cycle
GPT-6 Pro supplied both completed, source-pinned certificates in the same established chat. All 32 entries of the first bundle and 21 of the second matched their manifests. Their literal forward checks reproduced locally in 1.265 s and 1.247 s, each within its 15 s/512 MiB cap. Separate checks using ToikY's retained #7436 forward interpreter, rather than Pro's The compact public reproduction below was run with CPython 3.12.3 in 1.731 s under # SPDX-License-Identifier: Apache-2.0
# Credit: #7334 Clear1nsight, #7113 rohanarun, #7436 ToikY;
# GPT-6 Pro supplied separators, Codex checked and packaged this replay.
"""Two fixed-cut necessary obstructions; no producer or kappa gain claimed.
Usage: python3 -I -B reproduce_early_compensation.py WORD.json.gz r204_verify.py
The retained #7436 interpreter is authenticated before it is imported.
"""
from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import loads, dumps
from pathlib import Path
from runpy import run_path
import sys
assert __debug__
assert len(sys.argv) == 3
raw = Path(sys.argv[1]).read_bytes()
assert sha256(raw).hexdigest() == '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a'
expanded = decompress(raw)
assert sha256(expanded).hexdigest() == '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac'
engine = Path(sys.argv[2])
assert sha256(engine.read_bytes()).hexdigest() == 'db6178ae5cf9fdcd2eb2a19bf78caa4ae688abd56c997d9280368a6c772a849b'
w = loads(expanded)
p = w['program']
assert (len(p),w['public'],w['owned_fields']) == (76466,1501,68)
assert p[38986] == ['ADD',643,644,'-1',1027]
assert p[38997:39000] == [['MOVE',563,3,456,False],['ADD',563,97,'1',456],['ADD',867,563,'-1',456]]
assert p[39065:39067] == [['MOVE',644,1027,527,False],['ADD',644,97,'1',527]]
state = w['initial'] + [None]*w['owned_fields']
banks = {}
for t,(op,r,*a) in enumerate(p[:39066]):
if t in (38987,38998,39065): banks[t] = list(state)
if op == 'MOVE': state[r] = a[1]
elif op in ('INIT','CLEAR'): state[r] = a[0] if op == 'INIT' else None
S = [r for r,c in enumerate(banks[38987]) if c == 1027]
assert S == [639,640,641,642,643,644,645,646,1297,1299,1300,1383,1491]
assert not any((e[0] == 'MOVE' and e[3] == 1027) or (e[0] == 'INIT' and e[2] == 1027) for e in p[38987:39065])
T = [r for r,c in enumerate(banks[38998]) if c == 456]
assert T == [97,563,867] and w['frames'][456] == [75,176,259]
assert banks[38998][574] == banks[38998][1256] == 3
D = [r for r,c in enumerate(state) if c == 527]
assert D == [97,414,644,867]
cycle = [['ADD',414,574,'1',476],['ADD',574,414,'-1',476],
['ADD',414,574,'1',476],['ADD',574,1256,'1',476],
['ADD',1256,574,'-1',476],['ADD',574,1256,'1',476]]
program, mapping = [], {}
for t,e in enumerate(p):
mapping[t] = len(program)
if t not in (39011,57245):
program.append(['MOVE',1256,476,127,False] if t == 39009 else e)
if t == 39008: program.extend(cycle)
if t == 42228: program.append(['ADD',574,879,'-1',878])
candidate = dict(w,program=program)
oracle = run_path(str(engine))
oracle['history'](w,[])
oracle['history'](candidate,[])
def value(word,cut,roles,probe,source=39011):
key = (0,source,cut-1)
result, = oracle['forward'](word,[{'clocks':key,'peer':879}],
[{r:Q(v) for r,v in probe.items()}],{key:roles})[0]
return dict(result['bank_nonzero'])
Z = {1129:1,1154:1,1284:12,1307:1,1322:-4,1329:16,1331:8,1349:1}
assert value(w,38987,S,Z) == {}
assert value(candidate,mapping[39066],D,Z,mapping[39011]) == {}
assert value(w,39009,[414,574],Z) == {414:Q(-1)}
assert value(w,39066,[97],Z) == {97:Q(-1)}
assert value(w,39067,[644],Z) == {644:Q(-1)}
assert value(candidate,mapping[39067],[644],Z,mapping[39011]) == {}
E = {402:1}
assert value(w,38998,T,E) == value(w,39000,T,E) == {}
AB = value(w,39009,[414,574],E)
U = value(w,39006,[574],E).get(574,Q(0))
X = value(w,39007,[1256],E).get(1256,Q(0))
assert AB == {414:Q(1,4)}
assert AB.get(574,Q(0))-AB[414] == U+X == Q(-1,4)
assert value(w,39047,[97],E) == {97:Q(1,4)}
assert value(candidate,mapping[39047],[97],E,mapping[39011]) == {}
assert value(w,39049,[414],E) == {414:Q(1,4)}
assert value(candidate,mapping[39049],[414],E,mapping[39011]) == {}
# Sample immediately after 112's last contact; its value cannot change later.
contacts = [t for t,e in enumerate(p) if e[1] == 112 or e[0] in ('ADD','COPY') and e[2] == 112]
assert contacts[-1] == 43929 and w['final'][112] == 128
for coordinate,expected in [(402,Q(1,4)),(164,Q(1,2))]:
assert value(w,43930,[112],{coordinate:1}) == {}
assert value(candidate,mapping[43930],[112],{coordinate:1},mapping[39011]) == {112:expected}
print(dumps({'status':'PASS_TWO_FIXED_CUT_OBSTRUCTIONS',
'prepared644_source_cut':38987,'prepared644_source_count':len(S),
'prepared644_destination_count':len(D),'old97_on_Z':'-1','changed97_on_Z':'0',
'source456_cut':38998,'source456_roles':T,'source456_e402':'all zero',
'p_on_e402':'-1/4','old112_e402':'0','changed112_e402':'1/4',
'old112_e164':'0','changed112_e164':'1/2','kappa_gain':False},indent=2))Limits and next dependency. These are necessary public-normalised obstructions at two exact source cuts, not a universal impossibility result. Preparing 563 before its 38997 departure from chart 3 is outside the source-456 cut: 574 and 1256 are then coframed with it and expose No valid producer or successor was emitted. The prior nominal per-native paid delta Credit Clear1nsight and the retained native lineage for #7334, rohanarun for #7113, ToikY for #7409/#7436 and the separate forward interpreter, GPT-6 Pro for the certificates, and Codex for source audit, local reproduction and packaging. The existing common-plane reservation is respected. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Closed necessary gates for prepared644 at pre-38987 and actual source456 atpre38998 on exact #7334/#7113 fixed three-cycle. Scope released; earlier563 preparation and changed consumer contracts excluded; no kappa gain.",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19579572"
} |
|
FINDING — earlier 563 preparation corrects 97, but its tested dirty-return family fails. Scope released; no κ gain. This updates the earlier 563 claim, following the two later-cut exclusions. Scientific inputs remain #7334 A real early correction. Let Five ordinary ADDs and one SCALE before 38997 implement the reversible map After MOVE 563 into 456, insert The first new return fails in a declared family. The exact gate covers Define Two exact inputs certify Both annihilate Q. Their evaluations on The literal trial remains incorrect. The emitted alpha0/beta1 word removes both prior terminal 112 counterexamples: old/new 112 are0 on both e164 and e402; the prior nominal patch gave1/2 and1/4. It also matches the old CLEAR 1526 interface on all four fixed probes. Nevertheless, on zF, main role127 finishes at −1 instead of0, in chart 141. Its last retained contact is44971 Executed evidence. The supplied full-word four-probe checker reproduced locally in 2.845 s under 15 s/512 MiB, including preparation/inverse, cycle/inverse, stale-X, uncoframed, public COPY/CLEAR and owned-interface controls. The separate reverse quotient gate reproduced in 0.426 s under 60 s/512 MiB and checked 17 complete-row identities. Both use pinned retained engines. All 33 bundle manifest entries matched; immutable Pro receipts and the rejected word were preserved separately from local regenerated outputs. The compact forward reproduction below uses #7436 directly, with neither Pro's State nor stored reverse rows, and passed locally in 2.755 s with CPython 3.12.3 under Save the exact word as # SPDX-License-Identifier: Apache-2.0
# Credit #7334/#7113 native lineage, ToikY #7436 oracle,
# GPT-6 Pro producer and certificates, Codex audit and public replay.
"""An early97 repair with a failed dirty return; no kappa gain.
python3 -I -B reproduce_563.py WORD.json.gz r204_verify.py
"""
from collections import Counter
from fractions import Fraction as Q
from gzip import decompress
from hashlib import sha256
from json import loads, dumps
from pathlib import Path
from runpy import run_path
import sys
assert __debug__ and len(sys.argv) == 3
raw = Path(sys.argv[1]).read_bytes()
assert sha256(raw).hexdigest() == '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a'
expanded = decompress(raw)
assert sha256(expanded).hexdigest() == '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac'
engine = Path(sys.argv[2])
assert sha256(engine.read_bytes()).hexdigest() == 'db6178ae5cf9fdcd2eb2a19bf78caa4ae688abd56c997d9280368a6c772a849b'
w = loads(expanded)
p = w['program']
assert (len(p),w['public'],w['owned_fields']) == (76466,1501,68)
root_ops = [['ADD',563,1256,'1',3],['ADD',1256,574,'1',3],
['ADD',563,1256,'1',3],['ADD',1256,563,'-1',3],
['ADD',563,1256,'1',3],['SCALE',1256,'-1',3]]
cycle = [['ADD',414,574,'1',476],['ADD',574,414,'-1',476],
['ADD',414,574,'1',476],['ADD',574,1256,'1',476],
['ADD',1256,574,'-1',476],['ADD',574,1256,'1',476]]
program, clocks = [], {}
for t,e in enumerate(p):
if t == 38997: program.extend(root_ops)
if t == 38998: program.append(['ADD',97,563,'-1',456])
clocks[t] = len(program)
if t not in (39011,57245):
program.append(['MOVE',1256,476,127,False] if t == 39009 else e)
if t == 39008: program.extend(cycle)
if t == 42228: program.append(['ADD',574,879,'-1',878])
candidate = dict(w,program=program)
assert len(program) == 76478
oracle = run_path(str(engine))
oracle['history'](w,[])
oracle['history'](candidate,[])
def value(word,cut,roles,probe):
key = (0,38997,cut-1)
result, = oracle['forward'](word,[{'clocks':key,'peer':563}],
[probe],{key:roles})[0]
nonzero = dict(result['bank_nonzero'])
return {r:nonzero.get(r,Q(0)) for r in roles}
zF = {1311:Q(-1),1322:Q(-8),1349:Q(2),1429:Q(-96,25),1491:Q(-8,5)}
zV = {574:Q(1)}
for probe,F_expected,V_expected in [(zF,Q(1),Q(0)),(zV,Q(0),Q(1))]:
source = value(w,38997,[563,574,1256],probe)
prepared = value(candidate,clocks[38997],[563,574,1256],probe)
F,U,X = [source[r] for r in (563,574,1256)]
assert F == F_expected
assert prepared == {563:U+X,574:U,1256:X+F}
N = value(w,39047,[97],probe)[97]
R = value(candidate,clocks[39068],[867],probe)[867]
D = value(w,39066,[644],probe)[644]
K = value(w,39248,[1407],probe)[1407]
V = value(candidate,clocks[39049],[414],probe)[414]
assert (N,R,D,K) == (0,0,0,0) and V == V_expected
assert value(w,39248,[867],probe)[867] == -F_expected
assert value(w,39250,[1407],probe)[1407] == F_expected/4
assert value(candidate,clocks[39250],[1407],probe)[1407] == 0
for coordinate in (164,402):
probe = {coordinate:Q(1)}
assert value(w,39047,[97],probe) == value(candidate,clocks[39047],[97],probe)
assert value(w,43930,[112],probe) == {112:Q(0)}
assert value(candidate,clocks[43930],[112],probe) == {112:Q(0)}
for probe in (zF,zV,{164:Q(1)},{402:Q(1)}):
assert value(w,39721,[1526],probe) == value(candidate,clocks[39721],[1526],probe)
assert value(w,39047,[97],probe) == value(candidate,clocks[39047],[97],probe)
assert value(w,44972,[127],zF) == {127:Q(0)}
assert value(candidate,clocks[44972],[127],zF) == {127:Q(-1)}
assert p[44971] == ['ADD',127,491,'1',141] and w['final'][127] == 141
assert 127 in set(w['live']) | {r+112 for r in w['live']} | set(w['hosted']['X2']) | set(w['hosted']['Y2'])
contacts = [t for t,e in enumerate(p) if e[1] == 127 or e[0] in ('ADD','COPY') and e[2] == 127]
assert contacts[-1] == 44971
def paid(word):
counts = Counter()
for e in word['program']:
if e[0] == 'MOVE':
source,dest = word['frames'][e[2]],word['frames'][e[3]]
rank = abs(len(dest)-len(source))
if rank: counts[rank] += 1
return counts
old_paid,new_paid = paid(w),paid(candidate)
paid_delta = {r:new_paid[r]-old_paid[r] for r in old_paid.keys()|new_paid.keys()
if new_paid[r] != old_paid[r]}
assert paid_delta == {3:-2,6:1}
old_ops,new_ops = Counter(e[0] for e in p),Counter(e[0] for e in program)
delta = {op:new_ops[op]-old_ops[op] for op in old_ops.keys()|new_ops.keys()
if new_ops[op] != old_ops[op]}
assert delta == {'ADD':12,'SCALE':1,'MOVE':-1}
print(dumps({'status':'PASS_EARLY97_REPAIR_AND_DIRTY_RETURN_FALSIFIER',
'family':'(F,U,X)->(U+X+alpha*F,U+alpha*F,X+beta*F), beta nonzero',
'quotient_duals_on_F_V':[[1,0],[0,1]],'Q_dual_values_all_zero':True,
'representative':{'alpha':0,'beta':1},'old112_e164_e402':[0,0],
'trial112_e164_e402':[0,0],'old127_on_zF':0,'trial127_on_zF':-1,
'last127_contact':44971,'final127_chart':141,
'paid_delta_native':paid_delta,'event_delta_native':delta,
'full_new_price_established':False,'kappa_gain':False},indent=2,sort_keys=True))Costs and limits. The rejected word has 76478 events, per-native paid delta These checks use the necessary normalized public-input model. Finite owned-interface agreement is not arbitrary-dirty physical admission; numerical CLEAR values are recorded interfaces, not assumed-zero erasures. The exclusion does not cover arbitrary GL3 preparation, a different receiver or 476 transform, other source-bank donors, altered paid itineraries, or a later global repair that deliberately carries the incorrect39249 observation onward. None of those was searched. The complete gain objective remains open; no gain PR or frontier nomination is made. Another round needs a concrete funded route for the F debt with all affected returns and a complete bill, rather than treating the early 97 identity as completion. Credit Clear1nsight and the retained native lineage for #7334, rohanarun for #7113, ToikY for #7409/#7436 and the independent scalar interpreter, and the #7392 dirty-carrier work. GPT-6 Pro supplied the producer and certificates; Codex audited source, reproduced the checks and packaged the public replay. The prior closed scopes and common-plane reservation remain untouched. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Earlier563 T(alpha,beta) producer before38997 corrects97; exact527/976 return obstruction by39249 and emitted representative completed-output falsifier. Scope released; other source/receiver/global-repair contracts excluded; no kappa gain.",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19580437"
} |
|
FINDING — a funded F preload repairs role 127, but coherent chart 3 entrance compensation cannot restore the retained complete return contract. Scope released; no κ gain. This updates the later-F claim, following the early563 correction and first-return exclusion. The new test allows the incorrect39249 observation to propagate through the entire retained suffix; it does not reimpose that closed early-return deadline. It excludes an entrance-only correction model, not every possible later scalar adapter. Scientific inputs remain #7334 The literal preload works on the named observation. Let F be old563 immediately before 38997. Roles127 and563 are both in empty-frame chart 3 there. Insert
Here F alone cannot close the whole defect. On e574, F is0. Every correction of the form The coherent complete-return gate. Immediately before 38997, allow an arbitrary joint rational invertible preparation on all 233 actual chart 3 fields, leave every other live field unchanged, and execute the retained early563 rejected suffix. Require all 1501 original final public/helper values and every original timed owned pre-CLEAR value. The retained six producer operations are invertible inside that same bank, so keeping them in the suffix does not restrict this broader source-map class. No 39249 deadline is imposed. Do not assume that final public outputs alone give an invertible endpoint. Instead append all 68 suffix owned-retirement values to the target ledger. Reverse each ADD and nonzero SCALE algebraically; reverse MOVE only as chart bookkeeping. At each reversed CLEAR, reinstate its specified actual original pre-CLEAR value, not numerical zero. At each reversed INIT, require the reconstructed fresh value to be zero. The authenticated suffix has 20 INITs and no COPY; the unchanged prefix's guarded COPY is checked separately. This augmented map is injective: equal final values and equal retired values determine equal predecessor states step by step. The reverse consistency checks pass, yielding a unique formal required cut state. On zF, it requires role97=2, while the actual value is 1 in chart456, outside the permitted bank. On e574, it also requires role414=1, while the actual value is 0 in chart476. A chart 3-only preparation cannot change either coordinate. Even optimistically granting arbitrary replacement values to all 233 source fields cannot satisfy this fixed complete target. This is an end-to-end source-support obstruction, with all later errors allowed to propagate through the retained suffix. The formal required state was independently replayed forward to all 1501 endpoints and all 68 suffix owned returns. This validates the pullback arithmetic; that state is an unsupported proof object, not an admissible preparation. Original-suffix and candidate-suffix inverse controls recover their own actual cut states. The fixed original owned-return target is an explicit hypothesis: final-public equality alone would not justify forcing retired numerical values, and a changed owned-lifetime/provider contract is outside the proof. Executed checks and reproduction. The source-pinned forward certificate checker reproduced locally in 1.819 s under 15 s/512 MiB. The separate complete-return gate reproduced in 3.558 s under 60 s/512 MiB. Preparation/inverse, preload/inverse, cycle/inverse, uncoframed access and public COPY/CLEAR controls passed their stated checks. All 31 archive manifest entries authenticated, and the included previous33-entry archive retained its exact bytes. The regenerated rejected preload payload matches the supplied payload. Original and local regenerated receipts remain separate; in particular, the forward checker retains its original pinned gate bytes while the gate regenerates in another copy. The public reproduction below reuses the authenticated predecessor State class verbatim and adapts the checked pullback. The separate pinned #7436 forward oracle confirms the literal127/209 counterexample without importing a reverse solver. It passed locally with CPython 3.12.3 under # SPDX-License-Identifier: Apache-2.0
# #7334/#7113 native lineage; ToikY #7436 oracle; #7404 compensation method.
# Pro supplied the gate and State below; Codex audited and packaged this replay.
"""Root-only correction obstruction with fixed suffix and owned-return ledger.
python3 -I -B reproduce_later_F.py WORD.json.gz r204_verify.py
No claim excluding additional later scalar adapters or changed return contracts.
"""
from collections import Counter
from fractions import Fraction as Q
from functools import lru_cache
from gzip import decompress
from hashlib import sha256
from json import loads, dumps
from pathlib import Path
from runpy import run_path
import sys
PROBES = tuple(range(4))
CUT = 38997
Z = [{1311:Q(-1),1322:Q(-8),1349:Q(2),1429:Q(-96,25),1491:Q(-8,5)},
{574:Q(1)},{164:Q(1)},{402:Q(1)}]
def need(ok,label):
if not ok: raise AssertionError(label)
@lru_cache(None)
def rat(text): return Q(text)
# Exact State class reused from the authenticated 9a4a77d7 predecessor.
class State:
def __init__(self, word):
self.public = word["public"]
self.charts = word["initial"] + [None] * word["owned_fields"]
self.values = [tuple(Q(r == j) for j in PROBES) for r in range(len(self.charts))]
self.ranks = [len(x) for x in word["frames"]]
self.fresh = set()
self.paid = Counter()
self.ops = Counter()
def apply(self, event):
op, r, *a = event
self.ops[op] += 1
if op == "INIT":
need(r >= self.public and self.charts[r] is None, "owned INIT")
self.charts[r] = a[0]
self.values[r] = (Q(0),) * len(PROBES)
self.fresh.add(r)
return
if op == "CLEAR":
need(r >= self.public and self.charts[r] == a[0], "owned CLEAR lifetime")
self.charts[r] = None
self.values[r] = (Q(0),) * len(PROBES)
elif op == "MOVE":
lo, hi, owned = a
need(self.charts[r] == lo and owned == (r >= self.public), "MOVE ownership/chart")
rank = abs(self.ranks[hi] - self.ranks[lo])
need(rank > 0, "nonzero retained paid rank")
self.paid[rank] += 1
self.charts[r] = hi
elif op == "SCALE":
c, chart = a
need(self.charts[r] == chart and rat(c) != 0, "invertible SCALE")
self.values[r] = tuple(rat(c) * x for x in self.values[r])
elif op in ("ADD", "COPY"):
s, c, chart = a
need(r != s and self.charts[r] == self.charts[s] == chart, "coframed scalar contact")
if op == "COPY":
need(r >= self.public and r in self.fresh, "COPY only into fresh owned storage")
old = self.values[r] if op == "ADD" else (Q(0),) * len(PROBES)
self.values[r] = tuple(x + rat(c) * y for x, y in zip(old, self.values[s]))
else:
raise AssertionError(op)
self.fresh.discard(r)
assert __debug__ and len(sys.argv) == 3
raw = Path(sys.argv[1]).read_bytes()
assert sha256(raw).hexdigest() == '4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a'
expanded = decompress(raw)
assert sha256(expanded).hexdigest() == '9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac'
engine = Path(sys.argv[2])
assert sha256(engine.read_bytes()).hexdigest() == 'db6178ae5cf9fdcd2eb2a19bf78caa4ae688abd56c997d9280368a6c772a849b'
w = loads(expanded)
p = w['program']
assert (len(p),w['public'],w['owned_fields']) == (76466,1501,68)
root_ops = [['ADD',563,1256,'1',3],['ADD',1256,574,'1',3],
['ADD',563,1256,'1',3],['ADD',1256,563,'-1',3],
['ADD',563,1256,'1',3],['SCALE',1256,'-1',3]]
cycle = [['ADD',414,574,'1',476],['ADD',574,414,'-1',476],
['ADD',414,574,'1',476],['ADD',574,1256,'1',476],
['ADD',1256,574,'-1',476],['ADD',574,1256,'1',476]]
cp, labels = [], []
for t,e in enumerate(p):
if t == CUT:
cp.extend(root_ops); labels.extend([None]*len(root_ops))
if t == 38998:
cp.append(['ADD',97,563,'-1',456]); labels.append(None)
if t not in (39011,57245):
cp.append(['MOVE',1256,476,127,False] if t == 39009 else e); labels.append(t)
if t == 39008:
cp.extend(cycle); labels.extend([None]*len(cycle))
if t == 42228:
cp.append(['ADD',574,879,'-1',878]); labels.append(None)
assert len(cp) == 76478 and cp[:CUT] == p[:CUT]
trial = dict(w,program=cp)
assert sha256((dumps(trial,sort_keys=True,separators=(',',':'))+'\n').encode()).hexdigest() == 'fd799da73e46e5b1f0b33939ea8dd9b1e1a06c5e8d22e71c8a6831dd092f3504'
pp = cp[:CUT]+[['ADD',127,563,'1',3]]+cp[CUT:]
preload = dict(w,program=pp)
plabels = labels[:CUT]+[None]+labels[CUT:]
def walk(word,labs,start=None):
s = State(word)
if start is None:
s.values = [tuple(z.get(r,Q(0)) for z in Z) for r in range(len(s.charts))]
else:
s.values,s.charts,s.fresh = list(start[0]),list(start[1]),set(start[2])
cut,returns,early = None,{},None
for j in range(0 if start is None else CUT,len(word['program'])):
e = word['program'][j]
if j == CUT: cut = (list(s.values),list(s.charts),set(s.fresh))
if e[0] == 'CLEAR': returns[labs[j]] = (e[1],e[2],s.values[e[1]])
if e[0] == 'COPY': assert not any(s.values[e[1]])
if e == ['ADD',644,97,'1',527]: early = s.values[97]
s.apply(e)
assert s.charts == word['final']+[None]*word['owned_fields']
return s,cut,returns,early
old,cut,old_returns,old_early = walk(w,list(range(len(p))))
before,bcut,breturns,_ = walk(trial,labels)
new,_,new_returns,new_early = walk(preload,plabels)
assert len(old_returns) == len(new_returns) == 73
assert old_returns == new_returns # keys are original event identities
assert new_early == old_early and new.values[112] == old.values[112] == (0,)*4
assert before.values[127] == (Q(-1),Q(0),Q(0),Q(0))
assert new.values[127] == old.values[127] == (0,)*4
assert old.values[209] == (0,)*4 and new.values[209] == (Q(-1),Q(1),Q(1,4),Q(0))
assert cut == bcut and cut[0][563] == (Q(1),Q(0),Q(0),Q(0))
root = [r for r,c in enumerate(cut[1]) if c == 3]
assert len(root) == 233 and 127 in root and 563 in root and 97 not in root
def reverse(word,labs,end,returns):
s = State(word)
s.values,s.charts = list(end),word['final']+[None]*word['owned_fields']
counts = Counter()
for j in range(len(word['program'])-1,CUT-1,-1):
op,d,*a = word['program'][j]
counts[op] += 1
if op == 'ADD': s.apply(['ADD',d,a[0],str(-Q(a[1])),a[2]])
elif op == 'SCALE': s.apply(['SCALE',d,str(1/Q(a[0])),a[1]])
elif op == 'MOVE':
assert s.charts[d] == a[1] and a[2] == (d >= w['public'])
s.charts[d] = a[0] # algebraic bookkeeping, not a paid reverse route
elif op == 'CLEAR':
assert d >= w['public'] and s.charts[d] is None
r,c,v = returns[labs[j]]
assert (r,c) == (d,a[0])
s.charts[d],s.values[d] = c,v # actual retired value, not assumed zero
elif op == 'INIT':
assert d >= w['public'] and s.charts[d] == a[0] and not any(s.values[d])
s.charts[d] = None
else:
raise AssertionError('No COPY occurs in this authenticated suffix')
assert counts['COPY'] == 0 and counts['INIT'] == 20 and counts['CLEAR'] == 68
return s,counts
oi,_ = reverse(w,list(range(len(p))),old.values,old_returns)
bi,_ = reverse(trial,labels,before.values,breturns)
assert oi.values == cut[0] and oi.charts == cut[1]
assert bi.values == bcut[0] and bi.charts == bcut[1]
forced,counts = reverse(trial,labels,old.values,old_returns)
assert forced.charts == cut[1]
assert cut[1][97] == 456 and cut[0][97][0] == 1 and forced.values[97][0] == 2
assert cut[1][414] == 476 and cut[0][414][1] == 0 and forced.values[414][1] == 1
formal,_,formal_returns,_ = walk(trial,labels,(forced.values,forced.charts,cut[2]))
assert formal.values == old.values
assert formal_returns == {t:v for t,v in old_returns.items() if t >= CUT}
# A separately authored, authenticated oracle confirms the literal output failure.
oracle = run_path(str(engine))
for name,word in [('old',w),('preload',preload)]:
end = max(j for j,e in enumerate(word['program'])
if e[1] == 209 or e[0] in ('ADD','COPY') and e[2] == 209)
key = (0,CUT,end)
rows,_ = oracle['forward'](word,[{'clocks':key,'peer':563}]*2,Z[:2],{key:[127,209]})
assert [r['source'] for r in rows] == [1,0]
assert [r['bank_nonzero'] for r in rows] == ([[],[]] if name == 'old'
else [[[209,Q(-1)]],[[209,Q(1)]]])
paid_delta = {r:new.paid[r]-old.paid[r] for r in set(new.paid)|set(old.paid)
if new.paid[r] != old.paid[r]}
event_delta = {k:new.ops[k]-old.ops[k] for k in set(new.ops)|set(old.ops)
if new.ops[k] != old.ops[k]}
assert paid_delta == {3:-2,6:1} and event_delta == {'ADD':13,'SCALE':1,'MOVE':-1}
print(dumps({'status':'PASS_PRELOAD_FALSIFIER_AND_ROOT_ONLY_SUPPORT_CERTIFICATE',
'source_fields':len(root),'all_public_endpoints_in_formal_check':w['public'],
'suffix_owned_returns':counts['CLEAR'],'actual97_zF':'1','forced97_zF':'2',
'actual414_e574':'0','forced414_e574':'1','preloaded127':[0,0,0,0],
'preloaded209':['-1','1','1/4','0'],'paid_delta_native':paid_delta,
'event_delta_native':event_delta,'later_adapters_excluded_from_scope':True,
'full_new_price_established':False,'kappa_gain':False},indent=2,sort_keys=True))Costs and boundaries. The preload word has 76479 events. Relative to original #7334, its native paid delta is The coherent gate keeps the later scalar suffix, owned lifetimes and original owned-return contract fixed. Additional later coframed scalar adapters, different source cuts, changed owned/provider contracts and altered paid itineraries are outside this result. None was constructed or funded here. The normalized scalar tests do not admit a physical dirty supplier or discharge the five inherited framework premises. No κ gain, gain PR or frontier nomination is claimed. The complete gain objective remains open; another route needs a concrete changed later interface with legal source support, every affected return and a complete bill. This model is closed and the claim released. Credit Clear1nsight and the native lineage for #7334, rohanarun for #7113, ToikY for #7409/#7436, and #7404's coherent entrance-compensation method. Its independent signal and original-entrance availability were not imported as assumptions at this cut. GPT-6 Pro supplied the preload and support certificate; Codex audited, locally reproduced and packaged the public result. Prior closed scopes and the common-plane reservation remain untouched. {
"schema": "integer-mult-coordination/v1",
"kind": "FINDING",
"task": "p104-side-correction",
"scope": "Later F preload repairs role127, but all root-only GL233 entrance corrections atpre38997 fail the fixed complete suffix/original owned-return target. Allows39249 propagation. Scope released; later scalar adapters or changed return/route contracts excluded; no kappa gain.",
"base": "e54523517d0f03e58352e647c403a5af3e525a57",
"expiry": null,
"artifact": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19581357"
} |
|
CLAIM · p104-side-correction · priority revision 8 On exact #7480 head The first gate is an exact arbitrary-input prefix and guarded suffix witness that uses one of those new contacts, followed by a complete signed price strictly above conditional κ = 0.003646777872835. A candidate must pass the whole native operator, COPY and ownership checks, both directed prices, precision, physical maps, compiler and all outer predicates. The existing early563 and Type-A J8/J9 provider investigations are outside this scope. I checked the recent open PRs through #7480, the #1166 handoffs and the current #7111 comments. Credit the #7480 charged readout, Clear1nsight's #7334/#7314, Rohan Arun's #7113/#7277, Ali Romman, ToikY and the retained native/compiler lineage. Prepared with OpenAI Codex and verified ChatGPT Pro assistance. Claim expires 2026-11-13T06:38:00Z. Update 2026-11-13 05:42 UTC — LOCAL-ONLY: the fixed904 independent-retirement test and the emitted paired bypass with fixed late824 repair did not produce a complete gain. The original acceptance condition is unchanged. I am testing a changed early joint producer for that same449/1206/1477 bypass, using existing paid54/100/871 channels out of721 and preserving824’s original870 read where possible. The54/100/871 return contracts are part of this narrow bypass scope; no general search on their unrelated blocks is reserved. The separate independent7480 review retains its stated scope. No new κ is claimed. Expiry remains2026-11-13T06:38:00Z. |
|
CLAIM — independent review of #7480 at 58a9d05. User-assigned source-aware reproduction of the existing helper449 proposal: one sequential registered run with the declared 180/480/495/45-second stage caps (1200 seconds total), a 1 GiB job memory ceiling, and focused review of the new nonzero pre-CLEAR owned value, guarded COPY, all physical/caller fees and both directed prices. Canonical main is e545235; source #7334 is aaeec8c and caller #7113 is unchanged. No new κ is claimed by this post. This is separate from the active new-contact claim #7111 (comment). That thread retains the 449/1206/1477-contact work. Any later nominated closed-block search here will exclude all four #7480 block fields (449,485,1206,1477) and other active claims, after the review and a bounded Pro consultation. No new construction scope is reserved yet. Review claim expires 2026-11-13T06:10:00Z. Credit Rohan Arun for #7480/#7277/#7113, Clear1nsight for #7334/#7314, ToikY and all retained authors. OpenAI Codex assistance; no merge or selected-record change. |
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
FINDING — 2026-11-10 22:14 UTC. Can an existing coframe cut split an independent rank-nine helper into ranks five and four while preserving the complete paid profile on the signed P104 word?
Public artifact. #7110 at
fdb1eb55c4c6604e714c6950e656c67ae0e52370reports author-verified conditional κ = 0.003636447857731 at chart 117. The registered replay passed locally. Hosted onboarding stopped before the package replay because canonical CI navigation still points to #6030 after selection of #7000.LOCAL-ONLY continuation. On the exact #7110 word, chart 118 at cut 37473 splits helper 635 with zero paid MOVE changes and the same grid 1125. Both directed price engines and a clean archive replay pass at conditional κ = 0.003637417119941. Public export and independent review are pending.
Public comparison. #7112 at
b0d252a2552fad8211de79c70026ca150a56da0creports the same κ and paid/target change on the same predecessor, using pivot 631 at cut 37738. Our pivot 635 at cut 37473 stays LOCAL-ONLY. The chart-118 package now passes the local registered replay. The shared exponent step is represented publicly by #7112. Its exact published package passed our clean local replay. Its hosted onboarding job hit the same canonical CI defect and skipped the package replay.LOCAL-ONLY bounded follow-up. The expanded companion screen found zero valid boundary pairings across 3,826 states in ranks 2, 3, 4, 6, 7 and 8. The rank-five screen closes its 26 groups under the granted retimes. The fixed caller excludes 1,984 two-idle mergers. Five of six owned folds close under the tested source histories and destination demands. The chart-529 fold now also fails with all eleven ingresses mutable from their original timed histories and all original output demands retained. An exact early cache preserves the paid profile but the fold still misses a later export after all ingresses. No further κ gain in this round.
LOCAL-ONLY caller follow-up. The rank-16 projector proposal is closed under the retained native HOST count and labeled stage supports. The exact mask audit covers eight terminal deletions, 28 private birth deletions and four bridge-end deletions with all idle axes free. A private deletion confines 2k−1 negative axes to k rank-two HOSTs. Determinant one and defect rank at most 2k force one additional negative axis and a saturated reflection. In a saturated product the first active image and the remaining cumulative defect image are complementary. A vector in the first image that the product negates would therefore be negated by the first HOST, which has native active spectrum ±i. For a bridge-end deletion, the first active image meets the private negative plane if the bridge defect is invertible. Otherwise the opposite half has full defect and at least 17 negative eigenvectors in 18 dimensions, giving the same contradiction.
Retaining the long idle masks and ranks extends this to all 212 single-incidence deletions, even with new axes and HOST frames. The rank-two idle pair starting one stage later is fixed by the suffix HOSTs. The saturated suffix defect maps its axes onto the first HOST's active axes. If that idle pair covers the deleted stage, its axes omit the donor, which forces earlier HOSTs to omit the private donor inductively. The same map constrains the bridge projection. Exact artifacts and replay are currently local. The rank-17 routing check passed for the original and mirrored retimes, but the caller obstruction prevents their use here. A changed signed-core interface remains open. The exact published #7112 package at current head
e59520bb11b0df5ac33f062f55397d78a491e7afpassed a fresh clean replay at 16:16 UTC with κ = 0.003637417119941. No stronger κ was certified.LOCAL-ONLY split-sign follow-up. Freeing paid signs at their original stage-9 or stage-10 body supports cannot rescue a private birth donation. The donor half needs one more independent seam correction than its freed signs, while the other half needs at least as many as its freed signs. These corrections occupy independent blocks. For late terminal deletion with one freed sign per half, two dyadic rank-one reflections pass the relaxed unit-body endpoint. The frozen-subset rank audit requires all 18 incumbent HOST factors to change. In the retained seam chronology the stage-9 body contributors cannot all cross at one common cut. The labeled HOST factorization, mixed body placements and full signed caller replay remain open. The #7112 complete replay passed again at 16:32 UTC, at conditional κ = 0.003637417119941. No stronger κ was certified.
Current comparator. Rohan Arun’s #7113 17-stage signed caller passed a clean local registered replay at κ = 0.00363797977. The exact gain over #7112 is 0.000000562650059. The independent reconstruction matched the ordered 110,638 paid positions, 22,172 productive fields and both directed prices. The verifier and scientific files are unchanged on the newer documentation head. The hosted scientific replay passed on the current exact head. The overall workflow remains red because a separate historical job reported Makefile source drift. The prior split-sign proposal’s optimistic price is below this reproduced comparator.
LOCAL-ONLY follow-up on #7113. Keeping the other 16 Type-A HOSTs, the four seam queries and the paid body masks and ranks, the exact screen excludes all 2,904 price-positive one-incidence transfers. It grants new passive axes and arbitrary rank-two native frames at the changed stage. The original Type-B gap-group proposal is now closed even with all left HOST and idle axes free under the proposed masks. Its last three HOSTs would have to negate five independent private directions, exceeding the native determinant and rank bound. The exact two-gap variant is also closed under its prescribed masks, even with arbitrary HOST axes and group placement. The early anchors confine at least 13 private directions to the last seven HOSTs, which cannot negate them under the native rank and determinant constraints. Exact local screens leave some other mask changes open. Two right-half reciprocal bases pass the unit-body endpoint, but none of their 12 tested paid-group layouts has the required paired axes at the common cut. The chart-734 native result has appeared as #7115 at conditional κ = 0.003638315828316. Its exact head
e63533f866455aa5cbc6c405770c31126d76e340passed a clean local registered replay and an independent literal invoice recount. Hosted onboarding stopped before the verifier. The peer composition is now public as #7116 at conditional κ = 0.003638885999709. Its independent clean registered replay passed both commands, including all 3,047 chart maps and 104 main boundary pairs.Bounded caller and native follow-up. The exact positive and negative HOST support conditions exclude all 1,136 remaining same-arm one-incidence Type-B retiming classes under fixed native HOST count and retained independent signs. A separate search on #7115 found zero boundary pairings across 11,416 neutral timestamp states for helper ranks two through eight. The paid extension found one chart-120 pattern across 13 cuts. It splits a paid rank-seven move into ranks four and three and targets a productive rank-eight split into four and four. Our original witness on #7115 with the #7116 caller passed exact native, physical, complete application and registered replay at conditional κ = 0.003639006653941. It gains exactly 0.000000120654232 or (12065423200/3638885999709)% over #7116. The original reproducible package is public on the fork.
Current comparison. Dillona independently incorporated the reported chart-120 pattern on the later #7119 source in #7120, crediting ToikY. It reports conditional κ = 0.003639264106282. This uses a different cut and a four-ADD middle basis. Our independent exact-head registered replay passed both commands, including the complete composed application. Its hosted plan failed on the canonical navigation mismatch and skipped scientific replay. The original #7116-based package is retained as evidence for the initial construction.
The parallel residual screen uses a different word and allows retimings. The temporal-source work remains a separate scope. Chart-259 finding and scope release. On exact #7120, the rank-eight (3,246) helper splits at chart 259 into ranks three and five with the paid MOVE sequence retained. Both clean commands passed on our reproducible fork artifact at conditional κ = 0.003640102187396, an exact gain of 0.000000838081114 over #7120. #7121 published the same exact word and claim before our PR submission. Its exact-head independent registered replay passed both scientific commands, all 3,050 chart maps and 104 main pairs, with empty stderr. Hosted run stopped before scientific replay because of the canonical navigation mismatch. The reservation is released.
LOCAL-ONLY paid MOVE follow-up. Exact #7121 has 57 multi-read windows with independent output carriers. None permits a fixed-site fusion or a single late exit-chart replacement, including 25,692 changes in the available coframe. The tested paired fixed-site fusions and the 1,924 one-read, single-cut endpoint relocation cases are also excluded under their stated scopes. An exact projected span now excludes joint entry/exit replacements for all 962 one-read windows with the source retained and neutral timestamp grants. A corrected full-coordinate check excludes all 52,879 same-cut multi-read coframe states, including the apparent role-717 witness whose donor scaling changed the removed reads. Two different clocks for the multi-read problem remain open.
Current comparison. An independent clean registered replay of the complete #7122 head
6391d64cd0e37e0988e6b9c41fe13f053ed2c81epassed with empty stderr. It verified conditional κ = 0.003640761374142 and all 3,047 catalogue checks. This is an exact gain of 0.000000659186746 over #7121, or (16479668650/910025546849)%. #7122Current comparator. The independent clean registered replay of chart 924 passed on exact head
020d581d9856b6db83e448c3f20418bc63b72c34with empty stderr and all 3,048 catalogue checks. It verified conditional κ = 0.003641239650184, an exact gain of 0.000000478276042 over #7122. The hosted planner failed on the canonical navigation mismatch and skipped the scientific job. #7123 · Hosted runCurrent comparator. The complete output-chart package on exact #7124 head
97dc14132da53562b7939776d7a83d72af72eeb1passed an independent clean registered replay with empty stderr, all 3,038 catalogue checks and 104 boundary pairs. It verifies conditional κ = 0.003641428753638, exactly 0.000000189103454 above #7123. The hosted planner passed. The separate historical replay failed on Makefile source drift. #7124 · Hosted runCurrent comparator. The independent clean registered replay of chart 1027 passed on exact #7130 head
161e482bc2d8c78ecef96135430c60d49b8fc345. It verified conditional κ = 0.003642219284637, exactly 0.000000790530999 above #7124, with all 3,048 catalogue checks, 104 boundary pairs and empty stderr. The hosted planner failed on the canonical navigation mismatch and skipped the scientific replay. The scoped hosted scientific replay for #7124 passed separately. #7130 · Hosted runLOCAL-ONLY Type A caller follow-up. The proposed same-role split-cut layout fails the positive support equations even if all four QUERY frames and placements change. With the four QUERYs at the seam, the earlier/later same-role exclusion also holds for arbitrary unsigned paid cuts. Two relocated QUERYs do admit an exact local dyadic construction with independent body factors. The distinct-role target that could use it clears the current comparison on price alone. Its actual target supports and complete caller replay are pending. No new κ from this branch. Credit Rohan Arun's #7113 caller, #7107–#7110, Ali Romman, CubeJerry, dillona's parallel screen and the retained P104 lineage. OpenAI Codex assisted.
{"schema":"integer-mult-coordination/v1","kind":"FINDING","task":"p104-side-correction","scope":"Exact #7120 rank-eight (3,246) helper at chart 259 with unchanged paid MOVE sequence","base":"e54523517d0f03e58352e647c403a5af3e525a57","expiry":null,"artifact":"https://github.com/ToikY/integer-mult-bounds/tree/33f1631a0a55522b5495ecbe77916c5b01831ee7/research/p104-chart259-neutral-helper-split"}All reactions