From d19fd87da09642a60c825c2caa61dc292d1b10df Mon Sep 17 00:00:00 2001 From: Clear Insight Date: Mon, 19 Oct 2026 10:17:06 +1100 Subject: [PATCH 1/9] research: test the causal centre first-variation contract Separate parameterised scalar oracle rank from fixed native operator identities. Preserve selected inputs and frontend; draft source-dependent replay pending. --- research/centre-causal-tangent/PROOF.md | 135 +++++++++ research/centre-causal-tangent/README.md | 56 ++++ research/centre-causal-tangent/SOURCES.json | 1 + research/centre-causal-tangent/TASK.json | 1 + research/centre-causal-tangent/VERIFY.json | 1 + .../centre-causal-tangent/test_tangent.py | 123 +++++++++ research/centre-causal-tangent/verify.py | 261 ++++++++++++++++++ 7 files changed, 578 insertions(+) create mode 100644 research/centre-causal-tangent/PROOF.md create mode 100644 research/centre-causal-tangent/README.md create mode 100644 research/centre-causal-tangent/SOURCES.json create mode 100644 research/centre-causal-tangent/TASK.json create mode 100644 research/centre-causal-tangent/VERIFY.json create mode 100644 research/centre-causal-tangent/test_tangent.py create mode 100644 research/centre-causal-tangent/verify.py diff --git a/research/centre-causal-tangent/PROOF.md b/research/centre-causal-tangent/PROOF.md new file mode 100644 index 0000000000..80e4c0dc06 --- /dev/null +++ b/research/centre-causal-tangent/PROOF.md @@ -0,0 +1,135 @@ +# First-variation gate for parameterised centre sharing + +Clear1nsight, substantial OpenAI assistance. Apache-2.0. + +## Exact contract + +Retain the selected 144 local calls, complete scalar words, paired bridges, +all ordinary outputs and signed terminal exchanges. As in PR2622/2763, +project climbs, adapters, idle factors and address translations to identity. +Replace each of the 1,152 centre actions on its private scalar by multiplication +by z. Also test the version with z at forward calls and z^(-1) at backward +calls. The parameter varies near 1. A replacement must agree as a rational +function family, not just at z=1 or a root of unity. + +This changed scalar oracle contract is NOT the fixed native Fourier operator. +The theorem below cannot be used as a native recursive-call lower bound. + +## Time-expanded sheaf and derivative theorem + +A finite causal linear circuit has states x_t and constraints +x_(t+1)=M_t(z)x_t, input injection J and final projection P. It can include +fixed linear recoding, extra finite workspace, copies and singular clears. +Its boundary transfer is + + F(z)=P M_(s-1)(z) ... M_0(z) J. + +Assign state-space stalks to the chronological vertices and coordinate +compatibility restrictions to edges. Global sections are exactly legal linear +traces. Causality gives a unique trace for each input. This time-expanded +sheaf language describes compatibility, not a free implementation of elimination. + +The product rule at z=1 gives + + F'(1)=sum_t P M_(s-1)(1)...M_(t+1)(1) + M'_t(1) M_(t-1)(1)...M_0(1) J. + +If charged gates have derivative ranks r_t and every free operation is +independent of z, rank subadditivity gives + + rank F'(1) <= sum_t r_t. + +Each scalar-register multiplication by z or z^(-1) has derivative rank one. +Thus q such oracle calls imply rank F'(1)<=q. This holds for arbitrary fixed +linear causal recoding and finite workspace, including arbitrary dirty values +held fixed when varying payload inputs. Invertibility of every intermediate +operation is unnecessary. A parameter-independent coordinate change cannot +alter the required boundary derivative. A gate on d independent coordinates +may have derivative rank d and must not be counted as a single scalar query. +Nonlinear/adaptive branching and parameter-dependent free maps are not covered. + +## Application to the selected projected schedule + +At z=1, let C contain the actual chronological centre-input covectors and B +the final response columns to additive centre-output perturbations. C has +shape 1152-by-14336, and B has shape 14336-by-1152. The baseline complete +ordinary endpoint is identity. With Sigma diagonal, all +1 or signed by call +orientation, the product rule is equivalently + + F'(1)=B Sigma C. + +PR2622/2763 already establish full source-history rank, and PR2622 establishes +full final-error-response rank. Those are credited predecessor results. +The new verifier reconstructs both from the pinned selected archive without +importing predecessor executable code. Full modular ranks at two primes, +with opposite pivot conventions, certify their rational ranks as 1,152. +C is therefore surjective, B injective and Sigma invertible. Hence + + rank F'(1)=1152. + +Combining this with the derivative theorem proves that any replacement in +the declared parameterised linear oracle class needs at least 1,152 scalar +oracle gates. Halving to 576 is impossible in this class. This is a gate on +generic temporal sharing, NOT a complete supplier rejection or native tariff. + +The source-bound implementation independently derives all local endpoints, +chronological source rows, final response columns and the complete ordinary +baseline identity. A separately coded full dual-number interpreter over +Q[epsilon]/epsilon^2 checks both derivative sign conventions on dense signed +rational initial data. Each literal run retains 2,835,792 scalar instructions +and all 1,152 centre occurrences; every final ordinary field and private clear +must agree. This interpreter shares the input parser but calls none of the +primary local, bridge or endpoint routines. The dense checks support code +correctness; the rank/product-rule argument establishes the all-input result. + +## Fixed-operator escape and essential limitations + +The derivative concerns nearby parameters. A fixed native operator may obey +special algebraic identities that no generic z obeys. For example, n independent +coordinates transformed four times give F(z)=z^4 I_n and rank F'(1)=n. Under +the discrete condition z^4=1, the same fixed output is identity and uses zero +oracle calls. Consequently the generic lower bound cannot be transferred to +a finite-order native transform. The tests execute this counterexample. + +A claimed free operation z I_n is another counterexample to dropping a premise: +it supplies derivative rank n with no charged query. Fixed source/readout +changes, weaker required endpoints, nonlinear algorithms, different native +primitives and actual higher-dimensional oracle gates also require a new model. +The all-output condition matters, including helper restoration. The theorem +does not silently replace the native endpoint by a source-only observation. + +Eight generic test groups exercise product-rule ranks for noncommuting words, +a tight full-rank example, singular clears, coordinate changes, lost outputs, +fixed-operator and parameter-dependent-free-work counterexamples, and actual +missing/corrupt source loader rejection. Both normal and optimised modes are +registered. No independent human or formal proof-kernel acceptance is claimed. + +## Decision and next question + +NARROW to this exact generic scalar contract. A time-expanded sheaf alone +cannot remove work required by its boundary derivative. The useful constructive +escape is now explicit: bind one native fixed-operator identity that fails the +generic z model but preserves the complete required dirty-input endpoint. +Then charge source access, frames, chronological lifetimes, restoration, +precision, hosting and the complete recursive invoice. Those costs remain +unknown here, not zero. No paid profile, supplier or selected kappa changes. + +## Credit and overlap + +Sagar Thakrar/PR2199, after Adam Gall/PR1918, ywz65/PR2622 and the separate +bridge-source audit PR2763 supply the projected source/response lineage. +Tekalign/PR2814, after Arham Tahir/PR2799, already uses causal feedback and +operator derivatives for terminal-Y error kernels; this package instead bounds +the complete input/output derivative against fixed linear causal recoding. +PR3151 and PR3194 retain their distinct circle/history obstructions. +David Charbonneau/PR3147 supplies the research direction. Matarener/PR3656 and +Ross Richardson/PR3797 retain the block and independently established full-kernel +result; our PR3828 is not repeated. Retain Rohan Arun, Jeremy Kothe, Hao Yan, +Aaron Wang/navinor and all selected native/compiler source attribution. + +The sheaf viewpoint uses established local-to-global linear algebra, including +Hansen and Ghrist, Toward a spectral theory of cellular sheaves (2019), +DOI10.1007/s41468-019-00038-7. The product rule and rank inequality are elementary. +No priority claim for temporal sheaves or generic oracle lower bounds is made. +Separate implementations share the author and source. No agent-spawning tool +was available in this session, and no multi-agent execution is claimed. diff --git a/research/centre-causal-tangent/README.md b/research/centre-causal-tangent/README.md new file mode 100644 index 0000000000..1249f40c03 --- /dev/null +++ b/research/centre-causal-tangent/README.md @@ -0,0 +1,56 @@ +# Generic causal centre-sharing gate + +User-assigned continuation of priority 1 in the PR3147/3828 stream. +Clear1nsight with substantial OpenAI assistance. Apache-2.0. + +## Scope and result + +PROOF.md gives a first-variation rank gate for the COMPLETE selected scalar +projected endpoint after replacing each centre by a common parameter z, +or z/z^(-1) according to orientation. If the two source-derived ranks pass, +its boundary derivative has rank1,152. Any finite causal linear replacement +with parameter-independent free maps and rank-one oracle calls then needs +at least1,152 such calls. Generic half-sharing at576 is ruled out. + +This is NOT a native Fourier-call lower bound. A fixed-root-of-unity example +shows exactly why the derivative argument does not apply to a fixed native +operator. No physical sharing circuit, supplier saving or new kappa is claimed. +The source/history ranks are credited to PR2622/2763, not claimed as new. + +## Verification and reproduction + +Eight generic controls passed locally on CPython3.13.5 in normal and optimised +modes. The selected archive is not available to the local runtime because DNS +is unavailable. Actual source-dependent execution is pending in the existing +registered Python3.12 workflow; draft status remains until inspected. + +```sh +python3.12 -I -B scripts/research_package.py --package research/centre-causal-tangent +``` + +The primary derives all formal source/error rows and exact modular ranks. +A separate full dual-number interpreter checks dense signed input on every +archived scalar instruction and both sign conventions. These share the parser +and archived mathematical source, not the local/bridge/end-state routines. +The direct `--emit` option produces discovery output. Final replay without +that flag requires strict equality with a committed RESULT.json. + +## Open next questions and gate + +Can an actual fixed native-operator identity evade the generic model and meet +the complete required endpoint, including arbitrary dirty inputs and cleanup? +Start with one identity that fails generic z but holds for the actual native +operator, then charge all source, frame, ownership, precision and return costs. +No such circuit or favourable full bill is supplied. NARROW until that boundary +is specified; another abstract kernel census would not answer it. + +Canonical main is pinned at20ecf2891d80b5acf18d980b2164fb44ea7faa90, revision6. +AGENTS.md, autoresearch.md, CONTRIBUTING.md and the family gate were reread. +Targeted live overlap included1012/2622/2763/2814/3147/3754/3797/3828. Full +Discussion access was unavailable, and the attempted upstream claim returned403. +No claim was published or reserved. No main branch, frozen input or frontier is +changed. No separate agent, independent human or proof-kernel review is claimed. + +Predecessor attribution and exact mathematical boundaries are in PROOF.md. +Ross Richardson's PR3797 independently covers the prior fixed-block full-kernel +result and is explicitly credited rather than repeated in this contribution. diff --git a/research/centre-causal-tangent/SOURCES.json b/research/centre-causal-tangent/SOURCES.json new file mode 100644 index 0000000000..8aaccef134 --- /dev/null +++ b/research/centre-causal-tangent/SOURCES.json @@ -0,0 +1 @@ +{"schema_version":1,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","files":[{"path":"certificates/selected-result.json","usage":"provenance","git_blob":"b1fea0c94436b236cc2b7d41a7be032811b94c81","sha256":"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"},{"path":"docs/research/agent-task-catalog.json","usage":"provenance","git_blob":"67f085acd86acd7d4e03922d9cf4b26bca66fed5","sha256":"47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"},{"path":"research/community-frontier1094-audit/selected-replay.tar.gz","usage":"input","git_blob":"c24daf067f9c543421d89ca2eeaa4eb78a57fb6f","sha256":"f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"}]} diff --git a/research/centre-causal-tangent/TASK.json b/research/centre-causal-tangent/TASK.json new file mode 100644 index 0000000000..a0fd43673b --- /dev/null +++ b/research/centre-causal-tangent/TASK.json @@ -0,0 +1 @@ +{"schema_version":1,"task_id":"centre-path-sharing","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"centre-path-sharing","question":"Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt","certificates/selected-result.json"],"methods":["Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.","Prove a lower bound on copied information per call for the selected decoder contract."],"acceptance_gate":"Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).","bottleneck_link":"The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.","allowed_variations":["One sharing pattern across a fixed number of calls.","One reduced copied-total contract for the existing decoder.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Removing copies without a replacement contract for the decoder's copied totals.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["centre path","copied totals","private temporary","shared centre","batching"]},"scope_status":"changed","actual_scope":"First-variation rank gate for the selected complete scalar projected transfer under a common or reciprocal generic centre parameter, with a fixed-operator counterexample.","scope_change_reason":"User assigned temporal sheaves and cross-call sharing. The new implication combines credited source/response ranks with an arbitrary causal linear oracle rank budget. It deliberately does not extend that bound to the fixed native Fourier operator.","bottleneck_link":"Tests whether generic temporal recoding can remove half the centre oracle calls before spending effort on a physical schedule.","budget_minutes":null,"stop_rule":"Finish one parameterised contract gate and its source-bound checks. No native construction expansion without an explicit changed endpoint and fully paid cost ledger.","outcome":"partial","evidence":"Eight generic tests passed locally normally and with -O on CPython3.13.5. The two archive-dependent ranks and literal dual-number comparisons await hosted execution.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance; separate implementations, no spawned agents, independent human review or formal-kernel acceptance.","open_questions":[{"question":"Can a fixed native operator identity evade the generic parametric rank gate?","why_it_matters":"The fixed native transform need not agree with a family near z=1.","first_step":"Specify one fixed-operator identity with every required input, output, frame and restoration condition, and its complete cost.","blocked_by":"No qualifying native sharing circuit or favourable supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API checked at entry and again before packaging, unchanged. Shell network unavailable.","overlap":"Targeted live PR and source reads including2622/2763/2814/3147/3754/3797/3828; incomplete Discussion/diff coverage.","claim":"Upstream claim comment rejected403; not published and no reservation.","preservation":"Frozen archive and predecessor code unchanged; isolated additive package only."},"family_gate":{"decision":"narrow","proved":"Written generic product-rule rank theorem and synthetic controls.","pending":"Actual selected source-dependent replay.","unknown":"Fixed native sharing, physical access, frames, precision, dirty restoration, hosting and full recursive costs."}} diff --git a/research/centre-causal-tangent/VERIFY.json b/research/centre-causal-tangent/VERIFY.json new file mode 100644 index 0000000000..f5c855fac6 --- /dev/null +++ b/research/centre-causal-tangent/VERIFY.json @@ -0,0 +1 @@ +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":60,"checks":"Eight exact generic theorem and boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":60,"checks":"Generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py","--emit"],"timeout_seconds":450,"checks":"Source-bound chronological factors, two prime-field rank certificates and two complete literal dual replays; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/verify.py","--emit"],"timeout_seconds":450,"checks":"Fresh optimised source-bound and literal dual replay; discovery output."}]} diff --git a/research/centre-causal-tangent/test_tangent.py b/research/centre-causal-tangent/test_tangent.py new file mode 100644 index 0000000000..9ec9307037 --- /dev/null +++ b/research/centre-causal-tangent/test_tangent.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Small exact controls for the parametric rank theorem and its limits. + +Clear1nsight, substantial OpenAI assistance; not a native supplier proof. +""" +from fractions import Fraction as Q +from pathlib import Path +import types +import unittest + +HERE=Path(__file__).resolve().parent +m=types.ModuleType('source_tangent') +m.__file__=str(HERE/'verify.py') +exec(compile((HERE/'verify.py').read_bytes(),m.__file__,'exec'),m.__dict__) + + +def ident(n): + return [[Q(int(i==j)) for j in range(n)] for i in range(n)] + + +def mm(a,b): + return [[sum((x*y for x,y in zip(row,col)),Q(0)) for col in zip(*b)] for row in a] + + +def plus(a,b): + return [[x+y for x,y in zip(r,s)] for r,s in zip(a,b)] + + +def rk(a): + a=[list(map(Q,r)) for r in a]; k=0 + for j in range(len(a[0])): + hit=next((i for i in range(k,len(a)) if a[i][j]),None) + if hit is None: continue + a[k],a[hit]=a[hit],a[k]; d=a[k][j]; a[k]=[x/d for x in a[k]] + for i in range(k+1,len(a)): + d=a[i][j]; a[i]=[x-d*y for x,y in zip(a[i],a[k])] + k+=1 + if k==len(a): break + return k + + +def product_dual(gates): + n=len(gates[0][0]); base=ident(n); tangent=[[Q(0)]*n for _ in range(n)] + for g,dg in gates: + tangent=plus(mm(dg,base),mm(g,tangent)) + base=mm(g,base) + return base,tangent + + +class Tests(unittest.TestCase): + def test_causal_product_rule_and_rank(self): + for n in range(2,7): + zero=[[Q(0)]*n for _ in range(n)] + for count in range(1,2*n+1): + gates=[]; total=0 + for j in range(count): + free=ident(n); free[j%n][(j+1)%n]=Q((-1)**j,j+1) + derivative=[[Q(0)]*n for _ in range(n)] + derivative[j%n][j%n]=Q((-1)**j) + gates.extend([(free,zero),(ident(n),derivative)]) + total+=rk(derivative) + _,d=product_dual(gates) + self.assertLessEqual(rk(d),total) + + def test_exact_full_rank_tight_example(self): + n=5; gates=[] + for i in range(n): + d=[[Q(0)]*n for _ in range(n)]; d[i][i]=1 + gates.append((ident(n),d)) + _,derivative=product_dual(gates) + self.assertEqual(derivative,ident(n)); self.assertEqual(rk(derivative),5) + + def test_singular_clear_cannot_increase_rank(self): + n=3; zero=[[Q(0)]*n for _ in range(n)]; d=ident(n); d[1][1]=d[2][2]=0 + clear=ident(n); clear[0]=[Q(0)]*n + _,before=product_dual([(ident(n),d)]) + _,after=product_dual([(ident(n),d),(clear,zero)]) + self.assertEqual(rk(before),1); self.assertEqual(rk(after),0) + + def test_fixed_operator_escape(self): + # Four queries per coordinate give z^4 I. At z^4=1 the same fixed + # response is I with zero queries, despite derivative 4I at z=1. + n=3; gates=[] + for i in range(n): + for _ in range(4): + d=[[Q(0)]*n for _ in range(n)]; d[i][i]=1 + gates.append((ident(n),d)) + base,d=product_dual(gates) + self.assertEqual(base,ident(n)); self.assertEqual(d,[[4*x for x in r] for r in ident(n)]) + self.assertEqual(rk(d),n) + self.assertEqual((1j)**4,1) + self.assertEqual((-1j)**4,1) + + def test_free_parameter_dependence_breaks_premise(self): + n=4 + # Calling a zI operation 'free' gives rank n with zero charged calls. + self.assertEqual(rk(ident(n)),4) + self.assertGreater(rk(ident(n)),0) + + def test_coordinate_change_preserves_rank(self): + b=[[Q(1),Q(0)],[Q(0),Q(1)],[Q(1),Q(1)]] + c=[[Q(1),Q(0),Q(3)],[Q(0),Q(1),Q(2)]] + a=[[Q(1),Q(2)],[Q(0),Q(1)]]; inv=[[Q(1),Q(-2)],[Q(0),Q(1)]] + self.assertEqual(mm(mm(b,a),mm(inv,c)),mm(b,c)) + self.assertEqual(rk(mm(b,c)),2) + + def test_missing_history_or_output_invalidates_full_rank(self): + b=ident(4); c=ident(4) + self.assertEqual(rk(mm(b,c)),4) + b[3]=[Q(0)]*4 + self.assertEqual(rk(mm(b,c)),3) + + def test_source_and_typed_result_guards(self): + self.assertNotEqual(m.canon({'rank':1}),m.canon({'rank':True})) + import tempfile + with tempfile.TemporaryDirectory() as tmp: + with self.assertRaisesRegex(ValueError,'regular selected archive'): m.load(Path(tmp)) + path=Path(tmp)/m.ARCHIVE; path.parent.mkdir(parents=True); path.write_bytes(b'corrupt') + with self.assertRaisesRegex(ValueError,'selected archive hash'): m.load(Path(tmp)) + + +if __name__=='__main__': unittest.main() diff --git a/research/centre-causal-tangent/verify.py b/research/centre-causal-tangent/verify.py new file mode 100644 index 0000000000..9cba67978e --- /dev/null +++ b/research/centre-causal-tangent/verify.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""First-variation gate for the selected SCALAR projected centre programme. + +Clear1nsight with substantial OpenAI assistance. The observation/response +reconstruction adapts the credited PR2199/2622/2763 mathematics. This does not +model native Fourier operators or prove a native recursive-call lower bound. +""" +from __future__ import annotations +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import gzip +import json +from pathlib import Path +import tarfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +ARCHIVE = 'research/community-frontier1094-audit/selected-replay.tar.gz' +ARCHIVE_SHA = 'f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6' +MEMBERS = { + 'global': ('candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz','2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760'), + 'program': ('candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz','241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a'), +} +SKIP = {'idle_cover_sweep','terminal_Y_translations','bank_padding_cover_sweep','translate_every_live_family'} +LOCAL_SKIP = {'phase','climb','adapter','residual_adapter'} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def canon(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), allow_nan=False).encode() + + +def row_digest(rows): + return sha256(canon([{str(k): str(v) for k,v in sorted(r.items())} for r in rows])).hexdigest() + + +def load(root=ROOT): + path = root / ARCHIVE + need(path.is_file() and not path.is_symlink(), 'regular selected archive') + need(sha256(path.read_bytes()).hexdigest() == ARCHIVE_SHA, 'selected archive hash') + result = {} + with tarfile.open(path) as archive: + for key,(name,digest) in MEMBERS.items(): + matches = [m for m in archive.getmembers() if m.name == name] + need(len(matches) == 1 and matches[0].isfile(), 'unique regular source member') + data = archive.extractfile(matches[0]).read() + need(sha256(data).hexdigest() == digest, 'source member hash: '+key) + result[key] = json.loads(gzip.decompress(data)) + return result + + +def axpy(dest, source, factor=Q(1)): + for key,value in list(source.items()): + new = dest.get(key,Q(0)) + factor*value + if new: dest[key] = new + else: dest.pop(key,None) + + +def local_model(program): + state = {('L',i):{i:Q(1)} for i in range(704)} + responses = {('L',i):{} for i in range(704)} + queries = {} + for event in program: + kind = event[0] + if kind == 'scalar': + op = event[1]; name,dest = op[0],tuple(op[1]) + for stream in (state,responses): + if name == 'clear': stream[dest] = {} + elif name == 'copy': stream[dest] = dict(stream[tuple(op[2])]) + elif name == 'scale': stream[dest] = {k:v*Q(op[2],op[3]) for k,v in stream[dest].items()} + elif name == 'add': + need(dest != tuple(op[2]), 'distinct ADD roles') + axpy(stream[dest],stream[tuple(op[2])],Q(op[3],op[4])) + else: raise ValueError('unknown scalar instruction') + elif kind == 'center': + k=event[1]; need(k not in queries and event[4] == 8, 'centre binding') + queries[k] = dict(state['C',k]) + axpy(responses['C',k],{k:Q(1)}) + else: need(kind in LOCAL_SKIP, 'unknown local event') + need(set(queries) == set(range(8)), 'eight local queries') + need(all(not r for k,r in state.items() if k[0] != 'L'), 'baseline private cleanup') + need(all(not r for k,r in responses.items() if k[0] != 'L'), 'response private cleanup') + ordinary=[state['L',i] for i in range(704)] + return [queries[i] for i in range(8)],ordinary,[responses['L',i] for i in range(704)] + + +def call_key(c): + return tuple(c[k] for k in ('time','replica','stage','provider_id')) + + +def bind(data): + template=data['global']; need(template['live'] == 14336, 'live stock') + calls={call_key(c):c for c in template['calls']} + need(len(calls) == 144, 'call count') + for c in calls.values(): + owners=[x[0] for x in c['owners']] + need(len(owners)==len(set(owners))==704 and all(0<=x<14336 for x in owners),'owner injection') + need(sha256(canon(data['program'][c['orientation']])).hexdigest() == c['local_program_sha256'],'call/program binding') + base=896*c['replica']+224*c['pair'] + need(owners[:224]==list(range(base,base+224)), 'bridge/data owner binding') + order=[calls[call_key(e)] for e in template['execution_schedule'] if e['kind']=='local_cover_sweep'] + need(len(order)==144 and len({call_key(c) for c in order})==144, 'schedule bijection') + return calls,order + + +def bridge(states,e): + b=896*e['replica']; d=b+224*e['dst']; s=b+224*e['src']; g=e['coefficient'] + need(e['dst']!=e['src'] and g in (-1,1) and 0<=e['replica']<16 + and all(0<=e[k]<4 for k in ('dst','src')), 'paired bridge') + for p in range(112): + for state in states: + axpy(state[d+p],state[s+p],Q(g)) + axpy(state[s+112+p],state[d+112+p],Q(-g)) + + +def factors(data): + calls,order=bind(data) + local={o:local_model(data['program'][o]) for o in ('forward','backward')} + for orientation,(_,endpoint,_) in local.items(): + expected=[{i:Q(1)} for i in range(704)] + for p in range(112): + d,s,g=(112+p,p,1) if orientation=='forward' else (p,112+p,-1) + axpy(expected[d],expected[s],Q(g)) + need(endpoint==expected,'independently derived local endpoint') + base=[{i:Q(1)} for i in range(14336)] + response=[{} for _ in base]; history=[]; used=0 + for e in data['global']['execution_schedule']: + kind=e['kind'] + if kind=='local_cover_sweep': + c=calls[call_key(e)]; owners=[x[0] for x in c['owners']] + queries,_,impulses=local[c['orientation']] + for form in queries: + row={} + for r,g in form.items(): axpy(row,base[owners[r]],g) + history.append(row) + for p in range(112): + d,s,g=(112+p,p,1) if c['orientation']=='forward' else (p,112+p,-1) + for state in (base,response): axpy(state[owners[d]],state[owners[s]],Q(g)) + for r,row in enumerate(impulses): + axpy(response[owners[r]],{8*used+k:g for k,g in row.items()}) + used+=1 + elif kind=='bridge': bridge((base,response),e) + elif kind=='terminal': + need(e['pairs']==4 and 0<=e['replica']<16,'four terminal pairs') + for pair in range(4): + for p in range(112): + x=896*e['replica']+224*pair+p; y=x+112 + for state in (base,response): state[x],state[y]=state[y],{k:-v for k,v in state[x].items()} + else: need(kind in SKIP,'unknown global projection event') + need(base==[{i:Q(1)} for i in range(14336)],'complete baseline identity') + return history,response,order + + +def rank_mod(rows,prime,largest=False): + pivots={} + for original in (reversed(rows) if largest else rows): + row={k:(v.numerator*pow(v.denominator,-1,prime))%prime for k,v in original.items()} + row={k:v for k,v in row.items() if v} + while row: + at=max(row) if largest else min(row) + if at not in pivots: + inv=pow(row[at],-1,prime); pivots[at]={k:v*inv%prime for k,v in row.items()}; break + scale=row[at] + for k,v in pivots[at].items(): + value=(row.get(k,0)-scale*v)%prime + if value: row[k]=value + else: row.pop(k,None) + return len(pivots), sorted(pivots) + + +def literal_dual(data,initial,reciprocal): + """Separate full scalar interpreter over Q[epsilon]/epsilon^2. + + Does not call local_model, factors, bridge, or use their endpoint formulas. + Every archived scalar instruction is executed, with centre multiplier + 1+epsilon, or 1-epsilon at backward calls in reciprocal mode. + """ + state=[(Q(x),Q(0)) for x in initial]; bykey={call_key(c):c for c in data['global']['calls']} + scalar=centres=0 + for e in data['global']['execution_schedule']: + kind=e['kind'] + if kind=='local_cover_sweep': + c=bykey[call_key(e)]; owners=[a[0] for a in c['owners']]; local={('L',r):state[o] for r,o in enumerate(owners)} + sign=-1 if reciprocal and c['orientation']=='backward' else 1 + for event in data['program'][c['orientation']]: + if event[0]=='scalar': + op=event[1]; name,d=op[0],tuple(op[1]); scalar+=1 + if name=='clear': local[d]=(Q(0),Q(0)) + elif name=='copy': local[d]=local[tuple(op[2])] + elif name=='scale': + a,b=local[d]; q=Q(op[2],op[3]); local[d]=(q*a,q*b) + elif name=='add': + a,b=local[d]; x,y=local[tuple(op[2])]; q=Q(op[3],op[4]); local[d]=(a+q*x,b+q*y) + else: raise ValueError('unknown dual scalar') + elif event[0]=='center': + d=('C',event[1]); a,b=local[d]; local[d]=(a,b+sign*a); centres+=1 + else: need(event[0] in LOCAL_SKIP,'unknown dual local event') + need(all(v==(0,0) for k,v in local.items() if k[0]!='L'),'dual private restoration') + for r,o in enumerate(owners): state[o]=local['L',r] + elif kind=='bridge': + b=896*e['replica']; dx=b+224*e['dst']; sx=b+224*e['src']; gain=e['coefficient'] + for p in range(112): + d,s=dx+p,sx+p + state[d]=tuple(a+gain*b for a,b in zip(state[d],state[s])) + state[s+112]=tuple(a-gain*b for a,b in zip(state[s+112],state[d+112])) + elif kind=='terminal': + for pair in range(e['pairs']): + for p in range(112): + x=896*e['replica']+224*pair+p; y=x+112 + state[x],state[y]=state[y],tuple(-a for a in state[x]) + else: need(kind in SKIP,'unknown dual global event') + need([a for a,b in state]==list(map(Q,initial)),'dual baseline equality') + need(centres==1152,'dual centre occurrences') + return [b for a,b in state],scalar + + +def run(data): + C,B,order=factors(data) + ranks={} + for p,reverse in ((2147483647,False),(2305843009213693951,True)): + cr,_=rank_mod(C,p,reverse); br,_=rank_mod(B,p,reverse) + need(cr==br==1152,'full source and response ranks') + ranks[str(p)]={'source_rank':cr,'response_rank':br} + probes=[] + initial=[Q((i*i+17*i+11)%31-15,8) for i in range(14336)] + inputs=[sum((v*initial[k] for k,v in row.items()),Q(0)) for row in C] + for reciprocal in (False,True): + signs=[-1 if reciprocal and c['orientation']=='backward' else 1 for c in order for _ in range(8)] + want=[sum((v*signs[k]*inputs[k] for k,v in row.items()),Q(0)) for row in B] + got,count=literal_dual(data,initial,reciprocal) + need(got==want,'full literal derivative equals B diag(sign) C') + need(count==2835792,'all archived scalar operations retained') + probes.append({'reciprocal':reciprocal,'scalar_operations':count,'nonzero_outputs':sum(bool(x) for x in got), + 'derivative_sha256':sha256(canon(list(map(str,got)))).hexdigest()}) + return {'schema_version':1,'status':'PASS_CENTRE_CAUSAL_TANGENT','calls':144,'sites':1152,'live':14336, + 'source_rows_sha256':row_digest(C),'response_rows_sha256':row_digest(B),'rank_certificates':ranks, + 'first_variation_rank':1152,'scalar_oracle_minimum':1152,'half_share_576_rejected':True, + 'schedule_counts':dict(sorted(Counter(e['kind'] for e in data['global']['execution_schedule']).items())), + 'literal_dual_probes':probes,'fixed_native_operator_bound_claimed':False} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__); parser.add_argument('--root',type=Path,default=ROOT) + parser.add_argument('--emit',action='store_true',help='Discovery output; skips committed receipt equality') + args=parser.parse_args() + result=run(load(args.root)) + expected=HERE/'RESULT.json' + if not args.emit: + need(expected.is_file() and not expected.is_symlink(),'missing regular committed result') + need(canon(json.loads(expected.read_bytes()))==canon(result),'typed result mismatch') + print('RESULT_JSON='+canon(result).decode()); print(result['status']) + + +if __name__=='__main__': main() From 4878895a3a8ff339d7b9aa30f52389282ae9a9fc Mon Sep 17 00:00:00 2001 From: Clear Insight Date: Mon, 19 Oct 2026 10:20:44 +1100 Subject: [PATCH 2/9] research: bind pooled unpaid-coordinate claims to physical family coverage Audit the actual selected frame/owner/idle ledger. Separate legitimate pooling from a changed endpoint and distinguish private centre mass from ordinary unpaid credits. Source-dependent draft checks pending. --- .../PROOF.md | 131 ++++++++++++ .../README.md | 53 +++++ .../SOURCES.json | 1 + .../TASK.json | 1 + .../VERIFY.json | 1 + .../test_coverage.py | 66 +++++++ .../verify.py | 187 ++++++++++++++++++ 7 files changed, 440 insertions(+) create mode 100644 research/selected-family-coverage-boundary/PROOF.md create mode 100644 research/selected-family-coverage-boundary/README.md create mode 100644 research/selected-family-coverage-boundary/SOURCES.json create mode 100644 research/selected-family-coverage-boundary/TASK.json create mode 100644 research/selected-family-coverage-boundary/VERIFY.json create mode 100644 research/selected-family-coverage-boundary/test_coverage.py create mode 100644 research/selected-family-coverage-boundary/verify.py diff --git a/research/selected-family-coverage-boundary/PROOF.md b/research/selected-family-coverage-boundary/PROOF.md new file mode 100644 index 0000000000..660716c729 --- /dev/null +++ b/research/selected-family-coverage-boundary/PROOF.md @@ -0,0 +1,131 @@ +# Physical-family boundary of the two-unpaid relaxation + +Clear1nsight with substantial OpenAI assistance. Apache-2.0. + +## Claim and scope + +This rebinds PR1012's family coverage identity to the actual selected #1094 +archive and answers the contract bridge in PR3754's pooling question. It does +not show that every possible changed decoder has at most one unpaid coordinate, +and does not dispute the arithmetic fact that pooling can make an average +integer. No new histogram optimum, native supplier or kappa is claimed. + +PR1012's original identity is family-by-family: + + 8 k_f + h_f + i_f + 1 = 73. + +Here k_f counts actual data-register incidences, h_f sums helper widths hosted +on physical family f, and i_f is its actual idle rank. The plus-one belongs to +the family, not to one normalised call. The new audit tests this identity on +all selected rows and distinguishes aggregate mass from the local endpoint. + +## Source-derived ledger + +The canonical word provides every local start/final frame. Exact binary ranks +give endpoint increments: eight for each data role and the declared hosted +width for each helper. Both emitted orientations' ordinary climb masses must +equal these increments. The eight private centre occurrences add64 per call +without advancing ordinary live families. + +Two counting implementations agree. One accumulates data incidences, call +helper widths, matching literal pooled slots, and idle children per family. +The other starts with73 at each physical family and subtracts every actual +local endpoint increment and idle rank. Its remainder must be one everywhere. + +For W=14,336 and N=144 this gives + + ordinary paid mass = 72W = 1,032,192, + private centre mass = 64N = 9,216, + total paid mass = 1,041,408, + capacity = 73W = 1,046,528, + deficit = W - 64N = 5,120. + +The per-call local mass is5,586, so selected idle mass is +1,041,408 - 144*5,586 = 237,024. These are source-bound ledger consequences, +not an independent proof of the all-size compiler or actual subspace routing. +Equal frame dimensions alone do not establish equal physical operators. + +## Pooling and telescoping + +For any partition of physical families into groups G_j, summing gives + + sum_(f in G_j) [73 - 8k_f - h_f - i_f] = |G_j|. + +Repartitioning or averaging by calls preserves total W; it cannot create 2W. +This is additive conservation, NOT a per-call integer constraint. Refining a +paid advance into several pieces, or deferring a helper restoration into its +idle continuation, preserves total mass when the original endpoint remains +satisfied. The deferral mechanism retains PR1012's credit. + +Aggregate mass is weaker than these rows. Transfer one idle unit from f to g. +The global mass is unchanged, but their remainders become (2,0) instead of +(1,1). A histogram-only check cannot see the defect. The source verifier tests +this mutant, deletion of an idle unit, and simply claiming two credits on the +unchanged ledger. These reject for the expected family mismatch. + +## Exact PR3754 counterfactual boundary + +Keeping the selected local profile and private centre charge, a two-unpaid +formula would demand + + total_2 = 71W + 64N = 1,027,072, + idle_2 = total_2 - 144*5,586 = 222,688. + +It changes ordinary paid mass by exactly W=14,336. The integer partition +222,688=4,366*51+22 and per-call average13,918/9 are credited to PR3754 and the +previous aggregate/per-call work. They establish arithmetic admissibility +of that pooled WHAT-IF, not which original ordinary advances disappear. + +Thus the unchanged selected contract has one credit per physical family. +A different decoder or endpoint could supply a different law, but that needs +its own construction. This audit does not characterise every legally poolable +idle group, prove attainability of the pooled optimum, or justify a per-call +integrality premise merely from normalisation. + +## Distinct centre and ordinary resources + +Deleting all private centres removes9,216 rank units, not14,336 ordinary +coordinate advances. At the mass level, centre-free one-unpaid mass72W exceeds +the two-unpaid/unchanged-centre target71W+64N by5,120. The same saving cannot +silently be booked as both a deleted centre and a second unpaid ordinary +coordinate. This is not a complete moment comparison: ranks, routing and +additional charges still matter, and no realised net saving is asserted. + +## Verification and stopping decision + +The source-dependent check authenticates the original archive and three exact +members, then reconstructs local frame ranks, both emitted orientation invoices, +every call owner, all matching helper slots, and every idle child. It binds the +entire14,336-row ledger in the result hash. A subtractive second calculation +must give the same all-ones remainder. Groupings modulo1,9,16,73 test additivity, +not proposed physical pooling schedules. + +Eight synthetic controls cover exact rows, aggregation hiding local failure, +mass-neutral deferral, a legitimately changed endpoint, typed data, missing +and corrupt input, and equal-dimensional but different binary subspaces. +Normal and optimised runs are registered. Synthetic local evidence is distinct +from actual archive-dependent hosted replay, reported on the PR. + +NARROW: the next constructive question is a changed source or data endpoint +that removes the ordinary advance, with exact dirty inputs and a complete bill. +Another integer histogram at unsupported unpaid=2 does not supply it. No +universal impossibility of a second unpaid coordinate is proved. Physical +phases, subspace placement, movement, precision, restoration and all-size +supplier admission remain inherited or unknown, not zero-cost assumptions. + +## Credit and overlap + +Sagar Thakrar/PR1012 supplies the family identity and mass-neutral deferral; +DaysSky/PR442 and the idle-axis-hosting lineage supply inherited hosting. +Nick Petalas/PR3754 supplies pooled arithmetic feasibility of the hypothetical +mass. Arham Tahir/PR3747 and PR3737/3749 distinguish aggregate from unjustified +per-call integrality. Penguin for Maximus Putnam/PR1685 supplies the aggregate +integer optimum. Douglas Colkitt and the selected construction/compiler team +supply the ceiling model and sources. No new priority for these facts is claimed. +PR3561's restricted line-port toy is not treated as a universal native proof; +PR2203's actual paired-plane payload audit remains a separate implementation +obstruction. Retain all selected source notices and predecessor attribution. + +Separate counting implementations share the same assisted author and source. +No agents could be spawned in this session, and no independent human or formal +proof-kernel acceptance is claimed. No selected record or predecessor changes. diff --git a/research/selected-family-coverage-boundary/README.md b/research/selected-family-coverage-boundary/README.md new file mode 100644 index 0000000000..a32326c660 --- /dev/null +++ b/research/selected-family-coverage-boundary/README.md @@ -0,0 +1,53 @@ +# Selected family coverage and the two-unpaid premise + +User-assigned priority2, answering the physical accounting boundary in PR3754. +Clear1nsight with substantial OpenAI assistance. Apache-2.0. + +## Scope + +Reconstruct the actual selected #1094 family ledger behind PR1012's identity. +The one unpaid coordinate belongs to each physical family. Pooling or averaging +cannot create another credit on the unchanged endpoint. The hypothetical +unpaid=2 mass requires14,336 fewer ordinary advances; it is not achieved merely +by the valid pooled integer partition. Centre deletion and ordinary unpaid +credits are distinct resources. This is a source-bound contract audit, not a +new packing optimum or universal impossibility for changed decoders. + +PROOF.md states the exact conservation argument and scope. The verifier checks +all actual frame increments, emitted profiles, call owners, helper slots and +idle children, plus a second subtractive family ledger. Meaningful controls +show how equal aggregate mass can hide a local endpoint failure. + +## Verification and reproduction + +Eight generic controls pass locally on CPython3.13.5 normally and with -O. +The selected archive cannot be downloaded by this runtime because DNS is +unavailable. Actual source-dependent hosted replay is pending in this draft. + +```sh +python3.12 -I -B scripts/research_package.py --package research/selected-family-coverage-boundary +``` + +The verifier uses standard-library exact arithmetic and authenticates the +frozen archive/member hashes. Its --emit mode produces discovery output; the +final mode requires a matching committed RESULT.json. Source hashes and the +original task card are retained in SOURCES.json and TASK.json. + +## Open next questions and family gate + +Which changed source, endpoint or multi-coordinate native primitive legitimately +removes one more ordinary advance per physical family? State the exact new +frame/owner rows, arbitrary dirty-input endpoint and full execution costs before +optimising the unpaid=2 histogram. No such construction is supplied here. +NARROW until it exists. Physical subspace/operator equality, chronology, +precision, routing, restoration and the full supplier invoice remain open. + +Canonical main20ecf2891d80b5acf18d980b2164fb44ea7faa90 and revision6 were +refreshed before packaging. The three required root guidance files and family +gate were reread. Targeted PR/source overlap was checked; full Discussion access +was unavailable and an upstream claim returned403. No claim was published. +No main branch, frozen input, other contributor's PR or frontier is changed. + +PR1012, PR3754/3747/3737/3749/1685 and the retained selected sources keep full +credit as detailed in PROOF.md. This session could not spawn agents. Separate +implementation checks are not independent human or formal-kernel review. diff --git a/research/selected-family-coverage-boundary/SOURCES.json b/research/selected-family-coverage-boundary/SOURCES.json new file mode 100644 index 0000000000..8aaccef134 --- /dev/null +++ b/research/selected-family-coverage-boundary/SOURCES.json @@ -0,0 +1 @@ +{"schema_version":1,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","files":[{"path":"certificates/selected-result.json","usage":"provenance","git_blob":"b1fea0c94436b236cc2b7d41a7be032811b94c81","sha256":"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"},{"path":"docs/research/agent-task-catalog.json","usage":"provenance","git_blob":"67f085acd86acd7d4e03922d9cf4b26bca66fed5","sha256":"47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"},{"path":"research/community-frontier1094-audit/selected-replay.tar.gz","usage":"input","git_blob":"c24daf067f9c543421d89ca2eeaa4eb78a57fb6f","sha256":"f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6"}]} diff --git a/research/selected-family-coverage-boundary/TASK.json b/research/selected-family-coverage-boundary/TASK.json new file mode 100644 index 0000000000..38c5cebc91 --- /dev/null +++ b/research/selected-family-coverage-boundary/TASK.json @@ -0,0 +1 @@ +{"schema_version":1,"task_id":"coverage-law-change","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"coverage-law-change","question":"Can a template or call contract leave two or more unpaid coordinates per live family?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/idle-axis-hosting/PROOF.md","certificates/selected-result.json"],"methods":["State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.","Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template."],"acceptance_gate":"An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).","bottleneck_link":"The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.","allowed_variations":["One template change or one endpoint-contract change.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["coverage identity","unpaid coordinate","deficit law","W - 64N"]},"scope_status":"changed","actual_scope":"Source-bound selected family ledger audit answering PR3754's aggregation-versus-actual-contract question, with local conservation and centre/ordinary no-double-counting controls.","scope_change_reason":"User assigned two-unpaid feasibility. Existing pooled arithmetic is credited, not repeated as a new result. This binds the hypothetical mass to actual physical-family endpoint rows before further construction.","bottleneck_link":"A second unpaid coordinate requires a changed ordinary endpoint, not merely an integral averaged histogram.","budget_minutes":null,"stop_rule":"Finish the source-bound coverage bridge and explicit counterfactual controls. Do not construct dependent suppliers without a new endpoint and complete cost gate.","outcome":"partial","evidence":"Eight generic tests passed locally normally and with -O on CPython3.13.5. The complete selected archive-dependent family ledger awaits hosted execution.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance in proof and separate counting implementations. No spawned agents, independent human review or formal-kernel acceptance.","open_questions":[{"question":"What actual source or endpoint change removes one more ordinary coordinate advance per physical family?","why_it_matters":"Pooling preserves the original per-family deficit.","first_step":"Specify new frame/owner rows, the dirty-state implementation and complete costs before repricing unpaid=2.","blocked_by":"No replacement native endpoint, admissible source or full supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API checked at entry and before packaging, unchanged; shell DNS unavailable.","overlap":"PR1012 sources, PR3754/3747/1685, restricted3561 and actual2203 payload work read. Discussion/diff coverage incomplete.","claim":"Attempted upstream combined claim rejected403; not published or reserved.","preservation":"Selected sources and frontier unchanged; one additive directory."},"family_gate":{"decision":"narrow","proved":"Written additive conservation lemma and generic controls.","pending":"Actual selected source-dependent replay.","unknown":"A changed source/endpoint, native execution, physical subspaces, restoration, precision, hosting and full recursive costs."}} diff --git a/research/selected-family-coverage-boundary/VERIFY.json b/research/selected-family-coverage-boundary/VERIFY.json new file mode 100644 index 0000000000..38f4b220f6 --- /dev/null +++ b/research/selected-family-coverage-boundary/VERIFY.json @@ -0,0 +1 @@ +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Eight exact synthetic ledger and source-corruption controls."},{"argv":["{python}","-I","-O","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Synthetic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py","--emit"],"timeout_seconds":120,"checks":"Reconstruct actual selected family ledger from frames, call owners, slots and idle children; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/verify.py","--emit"],"timeout_seconds":120,"checks":"Fresh source-bound ledger and counterfactual controls under optimisation; discovery output."}]} diff --git a/research/selected-family-coverage-boundary/test_coverage.py b/research/selected-family-coverage-boundary/test_coverage.py new file mode 100644 index 0000000000..5552503a4b --- /dev/null +++ b/research/selected-family-coverage-boundary/test_coverage.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact family-ledger controls, not physical geometry or two-unpaid admission.""" +from pathlib import Path +from copy import deepcopy +import tempfile +import types +import unittest + +HERE=Path(__file__).resolve().parent +m=types.ModuleType('coverage_source'); m.__file__=str(HERE/'verify.py') +exec(compile((HERE/'verify.py').read_bytes(),m.__file__,'exec'),m.__dict__) + + +class Tests(unittest.TestCase): + def setUp(self): self.rows=[[0,2,12,44],[1,3,8,40],[2,4,9,31]] + + def test_complete_family_ledger(self): + self.assertIsNone(m.validate_family_rows(self.rows)) + self.assertEqual(m.aggregate_mass(self.rows,0),216) + + def test_aggregate_mass_does_not_imply_family_coverage(self): + rows=deepcopy(self.rows); rows[0][3]-=1; rows[1][3]+=1 + self.assertEqual(m.aggregate_mass(rows,0),m.aggregate_mass(self.rows,0)) + with self.assertRaises(ValueError): m.validate_family_rows(rows) + + def test_second_unpaid_is_not_relabelling(self): + with self.assertRaises(ValueError): m.validate_family_rows(self.rows,unpaid=2) + rows=deepcopy(self.rows) + for row in rows: row[3]-=1 + self.assertIsNone(m.validate_family_rows(rows,unpaid=2)) + self.assertEqual(m.aggregate_mass(self.rows,0)-m.aggregate_mass(rows,0),3) + with self.assertRaises(ValueError): m.validate_family_rows(rows) + + def test_refinement_and_deferral_telescope(self): + rows=deepcopy(self.rows) + for row in rows: row[2]-=3; row[3]+=3 + self.assertIsNone(m.validate_family_rows(rows)) + self.assertEqual(m.aggregate_mass(rows,0),m.aggregate_mass(self.rows,0)) + + def test_partition_conservation(self): + for mod in (1,2,3,7): + groups={} + for f,k,h,i in self.rows: groups[f%mod]=groups.get(f%mod,0)+73-8*k-h-i + self.assertEqual(sum(groups.values()),len(self.rows)) + + def test_typed_negative_guard(self): + with self.assertRaises(ValueError): m.validate_family_rows(self.rows,unpaid=True) + bad=deepcopy(self.rows); bad[0][2]=-1 + with self.assertRaises(ValueError): m.validate_family_rows(bad) + self.assertNotEqual(m.canon({'mass':1}),m.canon({'mass':True})) + + def test_coordinate_change_does_not_supply_endpoint(self): + # Equal dimension can describe different axis spaces. The ledger + # deliberately must not purport to verify these physical subspaces. + a=(1,2); b=(1,4) + self.assertEqual(m.binary_rank(a),m.binary_rank(b)); self.assertNotEqual(set(a),set(b)) + + def test_actual_loader_missing_and_corrupt(self): + with tempfile.TemporaryDirectory() as tmp: + with self.assertRaises(ValueError): m.load(Path(tmp)) + path=Path(tmp)/m.ARCHIVE; path.parent.mkdir(parents=True); path.write_bytes(b'corrupt') + with self.assertRaises(ValueError): m.load(Path(tmp)) + + +if __name__=='__main__': unittest.main() diff --git a/research/selected-family-coverage-boundary/verify.py b/research/selected-family-coverage-boundary/verify.py new file mode 100644 index 0000000000..069b41690e --- /dev/null +++ b/research/selected-family-coverage-boundary/verify.py @@ -0,0 +1,187 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Bind the two-unpaid premise to the selected per-family coverage contract. + +Clear1nsight with substantial OpenAI assistance. Credit Sagar Thakrar/PR1012 +for the coverage identity and Nick Petalas/PR3754 with PR3747/1685 for pooling. +This audits the actual selected ledger, not the legality of every new decoder. +""" +from __future__ import annotations +import argparse +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +import gzip +import json +from pathlib import Path +import tarfile + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +ARCHIVE='research/community-frontier1094-audit/selected-replay.tar.gz' +ARCHIVE_SHA='f1da80610bf33c58527f18ad63b4350d0b864e1d4486141ee17ac9bed4d529d6' +MEMBERS={ + 'global':('candidate/strict/global/hosted/GLOBAL-TEMPLATE.json.gz','2acf02b418078e37090495c601fe550448751d4f35912757b13a1f778efc7760'), + 'program':('candidate/strict/global/base/providers/gauge44/LOCAL-PROGRAMS.json.gz','241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a'), + 'word':('candidate/strict/global/base/providers/gauge44/CANONICAL-WORD.json.gz','16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219')} + + +def need(ok,message): + if not ok: raise ValueError(message) + + +def canon(value): + return json.dumps(value,sort_keys=True,separators=(',',':'),allow_nan=False).encode() + + +def digest(value): return sha256(canon(value)).hexdigest() + + +def load(root=ROOT): + path=root/ARCHIVE + need(path.is_file() and not path.is_symlink(),'regular archive') + need(sha256(path.read_bytes()).hexdigest()==ARCHIVE_SHA,'archive hash') + out={} + with tarfile.open(path) as archive: + for key,(name,expected) in MEMBERS.items(): + hits=[m for m in archive.getmembers() if m.name==name] + need(len(hits)==1 and hits[0].isfile(),'unique regular member') + raw=archive.extractfile(hits[0]).read() + need(sha256(raw).hexdigest()==expected,'member hash') + out[key]=json.loads(gzip.decompress(raw)) + return out + + +def binary_rank(vectors): + basis={} + for value in vectors: + need(type(value) is int and value>=0,'binary frame vector') + while value: + p=value.bit_length()-1 + if p not in basis: basis[p]=value; break + value ^= basis[p] + return len(basis) + + +def validate_family_rows(rows,m=73,unpaid=1): + need(type(unpaid) is int and unpaid>=0,'integer unpaid coordinate count') + for family,k,hosted,idle in rows: + need(all(type(x) is int and x>=0 for x in (family,k,hosted,idle)),'nonnegative family ledger') + need(8*k+hosted+idle+unpaid==m,'family coverage mismatch at '+str(family)) + + +def aggregate_mass(rows,centres): + return sum(8*k+h+i for f,k,h,i in rows)+centres + + +def run(data): + t,word,program=data['global'],data['word'],data['program'] + W,m,N=t['live'],t['m'],len(t['calls']) + need((W,m,N)==(14336,73,144),'selected dimensions') + need(len(t['local_providers'])==1,'one provider') + (pid,provider),=t['local_providers'].items() + v,R,widths=provider['v'],provider['R'],provider['widths'] + need(v==112 and len(widths)==R and 2*v+R==704,'selected provider arity') + frame_ranks=[binary_rank(f) for f in word['frames']] + increments=[frame_ranks[b]-frame_ranks[a] for a,b in zip(word['start'],word['final'])] + need(len(increments)==704 and increments[:224]==[8]*224,'data boundary increments') + need(increments[224:]==widths,'helper boundary widths') + local_profiles={} + centre_counts={} + for orientation in ('forward','backward'): + events=program[orientation] + prof=Counter(e[5] for e in events if e[0]=='climb' and e[5]>0) + centres=[e[4] for e in events if e[0]=='center'] + need(centres==[8]*8,'eight rank-eight centre occurrences') + need(sum(r*n for r,n in prof.items())==sum(increments),'ordinary climb mass equals endpoints') + prof.update(centres); local_profiles[orientation]=dict(sorted(prof.items())); centre_counts[orientation]=sum(centres) + need(local_profiles['forward']==local_profiles['backward'],'both local orientation invoices') + profile=local_profiles['forward']; local_mass=sum(r*n for r,n in profile.items()) + need(local_mass==5586,'selected local mass') + data_inc=Counter(); hosts=Counter(); call_slots=Counter(); call_counts=Counter() + for call in t['calls']: + need(call['provider_id']==pid,'provider dispatch') + need(call['local_program_sha256']==digest(program[call['orientation']]),'call/program binding') + owners=call['owners']; need(len(owners)==704 and len({o[0] for o in owners})==704,'owner injectivity') + call_counts[call['replica']]+=1 + for role,(family,route) in enumerate(owners): + need(0<=family0); mutant[at][3]-=1 + if label.startswith('moved'): mutant[(at+1)%W][3]+=1 + try: validate_family_rows(mutant,unpaid=unpaid) + except ValueError: controls.append(label) + else: raise ValueError('coverage mutant accepted') + return {'schema_version':1,'status':'PASS_SELECTED_FAMILY_COVERAGE_BOUNDARY','live':W,'calls':N,'m':m,'helper_roles':R, + 'data_step':8,'helper_width_mass':sum(widths),'local_profile':{str(k):v for k,v in profile.items()}, + 'local_mass':local_mass,'actual_paid_mass':total,'ordinary_paid_mass':total-centre_mass,'private_centre_mass':centre_mass, + 'actual_deficit':m*W-total,'idle_mass':sum(idle.values()),'idle_histogram':{str(k):v for k,v in sorted(idle_hist.items())}, + 'families_with_exactly_one_unpaid':W,'counterfactual_two_unpaid_failures':failed_two, + 'family_ledger_sha256':digest(rows),'residual_sha256':digest(residual),'grouping_controls':groups, + 'two_unpaid_target_mass':71*W+centre_mass,'extra_ordinary_mass_change_required':W, + 'two_unpaid_hypothetical_idle':hypothetical_idle,'pooled_partition':{'51':q,str(r):1}, + 'per_call_unpaid_two_idle':str(Fraction(hypothetical_idle,N)), + 'centre_free_vs_two_unpaid_mass_gap':W-centre_mass,'controls_rejected':controls, + 'changed_decoder_impossibility_claimed':False,'no_new_kappa':True} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__); parser.add_argument('--root',type=Path,default=ROOT) + parser.add_argument('--emit',action='store_true',help='Discovery output; skips committed receipt equality') + args=parser.parse_args() + result=run(load(args.root)); expected=HERE/'RESULT.json' + if not args.emit: + need(expected.is_file() and not expected.is_symlink(),'missing regular committed result') + need(canon(json.loads(expected.read_bytes()))==canon(result),'typed result mismatch') + print('RESULT_JSON='+canon(result).decode()); print(result['status']) + + +if __name__=='__main__': main() From 6bc9bdb8c5b669597b6808126c5ecff5ac07a9c9 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 10:35:17 +1100 Subject: [PATCH 3/9] research: strengthen the temporal gate to two discrete oracle choices Freeze the verified derivative receipt and add a strict causal feedback and secant certificate. The stronger gate concerns a programme uniform at scalar oracles +1 and -1; a single fixed native transform remains outside scope. --- research/centre-causal-tangent/RESULT.json | 1 + .../centre-causal-tangent/SECANT-PROOF.md | 79 +++++++++ research/centre-causal-tangent/VERIFY.json | 2 +- research/centre-causal-tangent/secant.py | 155 ++++++++++++++++++ 4 files changed, 236 insertions(+), 1 deletion(-) create mode 100644 research/centre-causal-tangent/RESULT.json create mode 100644 research/centre-causal-tangent/SECANT-PROOF.md create mode 100644 research/centre-causal-tangent/secant.py diff --git a/research/centre-causal-tangent/RESULT.json b/research/centre-causal-tangent/RESULT.json new file mode 100644 index 0000000000..8d8a789f52 --- /dev/null +++ b/research/centre-causal-tangent/RESULT.json @@ -0,0 +1 @@ +{"calls":144,"first_variation_rank":1152,"fixed_native_operator_bound_claimed":false,"half_share_576_rejected":true,"literal_dual_probes":[{"derivative_sha256":"4d48dde9bf90092035024c9f11e2458b342955745a7d503a85f35e1d4d88c0d7","nonzero_outputs":14316,"reciprocal":false,"scalar_operations":2835792},{"derivative_sha256":"933c5d14dec11ccaeb0fb3c63629b671974446800e12b562e4fc8dddc4d327ad","nonzero_outputs":14302,"reciprocal":true,"scalar_operations":2835792}],"live":14336,"rank_certificates":{"2147483647":{"response_rank":1152,"source_rank":1152},"2305843009213693951":{"response_rank":1152,"source_rank":1152}},"response_rows_sha256":"10681b41b6b1895a95f893dbf75e01ae164fe7bccb73a346e6c7db154c774e61","scalar_oracle_minimum":1152,"schedule_counts":{"bank_padding_cover_sweep":1,"bridge":144,"idle_cover_sweep":160,"local_cover_sweep":144,"terminal":16,"terminal_Y_translations":16,"translate_every_live_family":1},"schema_version":1,"sites":1152,"source_rows_sha256":"5c44d30669ff6d0abd456d15ae42f26aef21831490198ed7deb3a2dc3123ebca","status":"PASS_CENTRE_CAUSAL_TANGENT"} diff --git a/research/centre-causal-tangent/SECANT-PROOF.md b/research/centre-causal-tangent/SECANT-PROOF.md new file mode 100644 index 0000000000..70d26d5c56 --- /dev/null +++ b/research/centre-causal-tangent/SECANT-PROOF.md @@ -0,0 +1,79 @@ +# A discrete two-point strengthening + +Clear1nsight with substantial OpenAI assistance. Apache-2.0. + +The first-variation theorem requires correctness near z=1. The following +strengthening only requires the same fixed linear programme to work for two +scalar oracles, +1 and -1. It still does NOT prove a lower bound for one fixed +native Fourier operator whose coefficients and identities are known. + +## Causal feedback factorisation + +Use the exact source and final-response matrices C and B from PROOF.md. +Let K map additive centre-output errors at z=1 to later centre-input changes. +In chronological order K is strictly lower triangular, including changes +within a local call. Thus K is nilpotent. This is the same causal feedback +principle used in Tekalign/PR2814, applied here to the full input/output map. + +For centre multiplier z and delta=z-1, the vector e of innovations satisfies + + e = delta (C x + K e). + +Hence, with baseline endpoint F(1)=I, + + F(z)-I = B (I-delta K)^(-1) delta C. + +Since I-delta K is unitriangular, its determinant is one for every scalar delta. +For delta nonzero, its inverse times delta is invertible. B is injective and +C surjective on the1152-dimensional site space. Consequently + + rank(F(z)-I)=1152 for every z != 1. + +In particular rank(F(-1)-F(1))=1152. For the reciprocal forward/backward model, +z=-1 also assigns -1 to every centre, so the same two-point conclusion holds. +More generally the formula uses a diagonal Delta; invertibility requires its +entries nonzero. Only the common -2 case is claimed by the finite certificate. + +## Two-point query-rank theorem + +For two sequences of matrices M_t(-1), M_t(1), the telescoping product identity +expresses F(-1)-F(1) as the sum, over t, of + + P M_(s-1)(-1)...M_(t+1)(-1) + [M_t(-1)-M_t(1)] M_(t-1)(1)...M_0(1) J. + +Thus the rank difference is at most the sum of the gate-difference ranks. +Parameter-independent free maps contribute zero, and a single-register oracle +multiplication by z or its inverse contributes rank one. Any fixed causal linear +circuit correct for both oracle choices therefore needs at least1152 queries. +There is no continuity assumption. Both +1 and -1 satisfy z^4=1, so merely +restricting an otherwise unknown oracle to fourth roots of unity does not +permit generic half-sharing for this endpoint. + +This does not say a fixed known operator needs1152 recursive calls. Known +operator-dependent free maps, different required outputs, nonlinear algorithms, +larger-rank gates and costs outside this scalar query model remain separate. +The z^4 I example in PROOF.md has zero two-point difference and is correctly +NOT rejected by the secant bound, even though its derivative at1 is nonzero. + +## Bound finite checks + +secant.py reconstructs every local feedback row, composes them through the +actual owners and bridges, and verifies strict triangularity in the literal +centre order. It solves e=-2(Cx+Ke) on a dense signed rational fixture, and +compares all1152 innovations and all14336 final outputs against a separately +coded full scalar execution at z=-1. Every2,835,792 scalar instruction remains +present. The generic feedback/resolvent reconstruction and the literal point +interpreter do not share state-update routines. They share the pinned archive, +source parser and the credited mathematical semantics. + +A cycle mutation is rejected. Omitting K must change the actual selected output, +so the feedback control cannot pass by testing an already feed-forward zero K. +The full rank theorem follows from the written factorisation and certified +B/C ranks, not from the single dense fixture. No extra native/source/hosting +premise is discharged. No independent human or proof-kernel review is claimed. + +This is a refinement within the same conditional contract, not a selected +frontier change. Source inputs remain pinned at canonical20ecf289. The second +checkpoint found main unchanged; targeted centre/secant PR search found no +match, which is not exhaustive novelty evidence. diff --git a/research/centre-causal-tangent/VERIFY.json b/research/centre-causal-tangent/VERIFY.json index f5c855fac6..161342658b 100644 --- a/research/centre-causal-tangent/VERIFY.json +++ b/research/centre-causal-tangent/VERIFY.json @@ -1 +1 @@ -{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":60,"checks":"Eight exact generic theorem and boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":60,"checks":"Generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py","--emit"],"timeout_seconds":450,"checks":"Source-bound chronological factors, two prime-field rank certificates and two complete literal dual replays; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/verify.py","--emit"],"timeout_seconds":450,"checks":"Fresh optimised source-bound and literal dual replay; discovery output."}]} +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic theorem/boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":200,"checks":"Fresh source-bound derivative and complete dual-number replays, strictly matching the committed receipt."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":200,"checks":"Fresh optimised derivative and literal replay matching the same receipt."},{"argv":["{python}","-I","-B","{package}/secant.py","--emit"],"timeout_seconds":120,"checks":"Discrete two-point strengthening: exact feedback, all innovation cuts and literal minus-one endpoint; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/secant.py","--emit"],"timeout_seconds":120,"checks":"Optimised source-dependent discrete secant check; discovery output."}]} diff --git a/research/centre-causal-tangent/secant.py b/research/centre-causal-tangent/secant.py new file mode 100644 index 0000000000..c7163925a2 --- /dev/null +++ b/research/centre-causal-tangent/secant.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact two-point gate on scalar oracles +1 and -1, not one fixed native F. + +Clear1nsight, substantial OpenAI assistance. Causal feedback formula retains +Tekalign/PR2814 attribution. Main input/response ranks retain PR2622/2763 credit. +""" +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import argparse +import json +import types + +HERE=Path(__file__).resolve().parent +v=types.ModuleType('tangent_source'); v.__file__=str(HERE/'verify.py') +exec(compile((HERE/'verify.py').read_bytes(),v.__file__,'exec'),v.__dict__) + + +def local_feedback(program): + state={('L',i):{} for i in range(704)}; rows={}; order=[] + for e in program: + if e[0]=='scalar': + op=e[1]; kind,d=op[0],tuple(op[1]) + if kind=='clear': state[d]={} + elif kind=='copy': state[d]=dict(state[tuple(op[2])]) + elif kind=='scale': state[d]={k:x*Q(op[2],op[3]) for k,x in state[d].items()} + elif kind=='add': v.axpy(state[d],state[tuple(op[2])],Q(op[3],op[4])) + else: raise ValueError('unknown feedback scalar') + elif e[0]=='center': + k=e[1]; v.need(k not in rows,'unique feedback site') + rows[k]=dict(state['C',k]); order.append(k); v.axpy(state['C',k],{k:Q(1)}) + else: v.need(e[0] in v.LOCAL_SKIP,'feedback local event') + v.need(set(order)==set(range(8)),'feedback sites complete') + return rows,order + + +def feedback(data): + calls,_=v.bind(data) + local={o:v.local_model(data['program'][o]) for o in ('forward','backward')} + lf={o:local_feedback(data['program'][o]) for o in local} + state=[{} for _ in range(14336)]; K=[None]*1152; actual_order=[]; used=0 + for e in data['global']['execution_schedule']: + kind=e['kind'] + if kind=='local_cover_sweep': + c=calls[v.call_key(e)]; owners=[x[0] for x in c['owners']]; o=c['orientation'] + queries,_,impulses=local[o]; within,order=lf[o] + for k in order: + i=8*used+k; row={} + for r,q in queries[k].items(): v.axpy(row,state[owners[r]],q) + v.axpy(row,{8*used+j:q for j,q in within[k].items()}) + K[i]=row; actual_order.append(i) + for p in range(112): + d,s,q=(112+p,p,1) if o=='forward' else (p,112+p,-1) + v.axpy(state[owners[d]],state[owners[s]],Q(q)) + for r,row in enumerate(impulses): v.axpy(state[owners[r]],{8*used+k:q for k,q in row.items()}) + used+=1 + elif kind=='bridge': v.bridge((state,),e) + elif kind=='terminal': + for pair in range(4): + for p in range(112): + x=896*e['replica']+224*pair+p; y=x+112 + state[x],state[y]=state[y],{k:-q for k,q in state[x].items()} + else: v.need(kind in v.SKIP,'feedback global event') + triangular(K,actual_order) + return K,actual_order + + +def triangular(K,order): + v.need(sorted(order)==list(range(len(K))),'complete chronological permutation') + position={i:k for k,i in enumerate(order)} + v.need(all(row is not None and all(position[j] Date: Mon, 19 Oct 2026 10:38:56 +1100 Subject: [PATCH 4/9] research: freeze verified family coverage and test the portable receipt Retain the actual selected per-family ledger, distinguish pooled arithmetic from a second unpaid ordinary coordinate, and add real Git-free and command-line corruption controls. All original inputs remain unchanged. --- .../README.md | 109 ++++++++++++------ .../RESULT.json | 1 + .../TASK.json | 2 +- .../VERIFY.json | 2 +- .../publication.py | 92 +++++++++++++++ 5 files changed, 166 insertions(+), 40 deletions(-) create mode 100644 research/selected-family-coverage-boundary/RESULT.json create mode 100644 research/selected-family-coverage-boundary/publication.py diff --git a/research/selected-family-coverage-boundary/README.md b/research/selected-family-coverage-boundary/README.md index a32326c660..bbffce50ec 100644 --- a/research/selected-family-coverage-boundary/README.md +++ b/research/selected-family-coverage-boundary/README.md @@ -1,53 +1,86 @@ # Selected family coverage and the two-unpaid premise -User-assigned priority2, answering the physical accounting boundary in PR3754. -Clear1nsight with substantial OpenAI assistance. Apache-2.0. +A source-bound contract audit for the user-assigned priority2 in PR3754's +coverage-law stream. Clear1nsight with substantial OpenAI assistance. +Apache-2.0. This is not a new packing optimum, changed decoder, or supplier. -## Scope +## Result -Reconstruct the actual selected #1094 family ledger behind PR1012's identity. -The one unpaid coordinate belongs to each physical family. Pooling or averaging -cannot create another credit on the unchanged endpoint. The hypothetical -unpaid=2 mass requires14,336 fewer ordinary advances; it is not achieved merely -by the valid pooled integer partition. Centre deletion and ordinary unpaid -credits are distinct resources. This is a source-bound contract audit, not a -new packing optimum or universal impossibility for changed decoders. +The actual selected #1094 ledger has exactly one unpaid coordinate at every +one of14,336 physical families. This rebinds and credits PR1012's identity +`8*k_f + h_f + i_f + 1 = 73` to the selected original archive. Pooling or +normalising by calls cannot turn these same endpoint rows into two credits. -PROOF.md states the exact conservation argument and scope. The verifier checks -all actual frame increments, emitted profiles, call owners, helper slots and -idle children, plus a second subtractive family ledger. Meaningful controls -show how equal aggregate mass can hide a local endpoint failure. +The complete selected paid mass is1,041,408, including9,216 private-centre +rank units. An unpaid=2 formula with the same local profile and centre charge +requires14,336 fewer ordinary advances, giving target mass1,027,072. The valid +integer partition for hypothetical idle mass222,688 is credited to PR3754 and +its pooling predecessors. It does not explain how the missing ordinary +endpoint work is performed. Deleting centres and creating ordinary unpaid +coordinates are separately accounted; the same saving cannot be booked twice. -## Verification and reproduction +The audit checks every local endpoint rank, both emitted orientation profiles, +all call owners, exact helper slots and actual idle children. A second counting +implementation starts each family at73 and subtracts its actual advances. +A deliberate transfer of one idle unit preserves global mass but breaks two +local coverage rows. Thus aggregate arithmetic alone cannot certify these +unchanged physical-family endpoints. -Eight generic controls pass locally on CPython3.13.5 normally and with -O. -The selected archive cannot be downloaded by this runtime because DNS is -unavailable. Actual source-dependent hosted replay is pending in this draft. +PROOF.md states the exact conservation theorem and limitations. Equal-dimensional +frames need not be equal physical subspaces or operators. The actual compiler, +all-size routing and every possible alternative decoder are not certified. +In particular this does NOT prove that a changed endpoint cannot leave two +unpaid coordinates. + +## Executed evidence and reproduction + +At scientific head4878895a3a8ff339d7b9aa30f52389282ae9a9fc the actual registered +fork workflow passed on Ubuntu24.04.5 and CPython3.12.15: +https://github.com/Clear1nsight/integer-mult-bounds/actions/runs/39176163645 +Both normal and optimised source runs agreed exactly, eight generic tests passed +in both modes, and committed inputs stayed unchanged. This publication adds +the frozen RESULT.json, strict comparison, and an actual Git-free/CLI-control +hook. Its final exact-head results are recorded on the PR. ```sh python3.12 -I -B scripts/research_package.py --package research/selected-family-coverage-boundary ``` -The verifier uses standard-library exact arithmetic and authenticates the -frozen archive/member hashes. Its --emit mode produces discovery output; the -final mode requires a matching committed RESULT.json. Source hashes and the -original task card are retained in SOURCES.json and TASK.json. +Only the standard library is used. The original source archive and all three +members are authenticated. `verify.py --emit` remains an explicitly labelled +discovery option; registered replay does not use it. `publication.py` copies +only the package and declared archive, removes Git from PATH, executes the real +optimised verifier, and tests a Boolean receipt mutation plus missing/corrupted +sources in isolated copies. Its success must be inspected before claimed. + +Actual selected-source replay ran in hosted CI because local DNS was unavailable. +No actual source-dependent local run, native replay, or independent human/formal +proof-kernel acceptance is claimed. Separate counting methods share the source +and assisted author. No agent-spawning tool was available in this session. -## Open next questions and family gate +## Open next question and family gate Which changed source, endpoint or multi-coordinate native primitive legitimately -removes one more ordinary advance per physical family? State the exact new -frame/owner rows, arbitrary dirty-input endpoint and full execution costs before -optimising the unpaid=2 histogram. No such construction is supplied here. -NARROW until it exists. Physical subspace/operator equality, chronology, -precision, routing, restoration and the full supplier invoice remain open. - -Canonical main20ecf2891d80b5acf18d980b2164fb44ea7faa90 and revision6 were -refreshed before packaging. The three required root guidance files and family -gate were reread. Targeted PR/source overlap was checked; full Discussion access -was unavailable and an upstream claim returned403. No claim was published. -No main branch, frozen input, other contributor's PR or frontier is changed. - -PR1012, PR3754/3747/3737/3749/1685 and the retained selected sources keep full -credit as detailed in PROOF.md. This session could not spawn agents. Separate -implementation checks are not independent human or formal-kernel review. +removes one more ordinary coordinate advance per physical family? State the +exact new frame/owner rows, arbitrary dirty-input endpoint and full execution +costs before optimising the unpaid=2 histogram. No such construction is supplied. +The fixed-ledger question is COMPLETE; the construction decision remains NARROW +until those changed obligations and a favourable full budget exist. + +## Coordination and credit + +Canonical main20ecf2891d80b5acf18d980b2164fb44ea7faa90 and revision6 were refreshed +at entry and before the strengthened publication. AGENTS.md, autoresearch.md, +CONTRIBUTING.md and the family gate were reread. Relevant current PR/source +overlap was checked, but full Discussion/diff coverage was unavailable. The +upstream claim write returned403; no upstream claim was reserved. The fork +review record is https://github.com/Clear1nsight/integer-mult-bounds/pull/4 . +No main branch, frozen source, other contributor's PR or frontier was changed. + +Credit Sagar Thakrar/PR1012 for the family identity and deferral; Nick Petalas/ +PR3754 for the two-unpaid pooled counterfactual; Arham Tahir/PR3747 and PR3737/ +3749 for aggregate-versus-per-call distinctions; Penguin for Maximus Putnam/ +PR1685 for the integer optimum; DaysSky/PR442 and the selected hosting/compiler +lineage. PR3561's restricted line-port model and PR2203's different payload +obstruction are not treated as universal native impossibilities. PROOF.md +retains detailed attribution and scope. Substantial OpenAI assistance disclosed. diff --git a/research/selected-family-coverage-boundary/RESULT.json b/research/selected-family-coverage-boundary/RESULT.json new file mode 100644 index 0000000000..af594023ff --- /dev/null +++ b/research/selected-family-coverage-boundary/RESULT.json @@ -0,0 +1 @@ +{"actual_deficit":5120,"actual_paid_mass":1041408,"calls":144,"centre_free_vs_two_unpaid_mass_gap":5120,"changed_decoder_impossibility_claimed":false,"controls_rejected":["double_count_free_coordinate","deleted_idle_unit","moved_idle_unit_to_other_owner"],"counterfactual_two_unpaid_failures":14336,"data_step":8,"extra_ordinary_mass_change_required":14336,"families_with_exactly_one_unpaid":14336,"family_ledger_sha256":"246a837abd10dedf8b9af35a9c4c214aed160475e99ba987a76746d70bf2dd75","grouping_controls":[{"modulus":1,"partition_sha256":"7da47cbd63c97be54717693542a52f42b60613b96575c17028d0cca2f12dc8a8","total_unpaid":14336},{"modulus":9,"partition_sha256":"c72fa5fbc4c47dd2f9a8b916b095944c5d51c3d7913f8b8fa2f8048aebdc9dee","total_unpaid":14336},{"modulus":16,"partition_sha256":"7ae80f9feee71ccd050bfe26f5175d8555c29358a5a2b5f069c5141e3eb6feb1","total_unpaid":14336},{"modulus":73,"partition_sha256":"aaa70c515aad6875990d13f56582756644333370c746485756292bd337a768dc","total_unpaid":14336}],"helper_roles":480,"helper_width_mass":3730,"idle_histogram":{"1":2276,"3":377,"48":4866,"7":7},"idle_mass":237024,"live":14336,"local_mass":5586,"local_profile":{"1":2412,"2":418,"3":432,"4":142,"5":82,"8":8},"m":73,"no_new_kappa":true,"ordinary_paid_mass":1032192,"per_call_unpaid_two_idle":"13918/9","pooled_partition":{"22":1,"51":4366},"private_centre_mass":9216,"residual_sha256":"bbcdf1cee9d5c9ca226e50148b923531486d1d0d010b819ce66bd021253739df","schema_version":1,"status":"PASS_SELECTED_FAMILY_COVERAGE_BOUNDARY","two_unpaid_hypothetical_idle":222688,"two_unpaid_target_mass":1027072} diff --git a/research/selected-family-coverage-boundary/TASK.json b/research/selected-family-coverage-boundary/TASK.json index 38c5cebc91..c51a130ba5 100644 --- a/research/selected-family-coverage-boundary/TASK.json +++ b/research/selected-family-coverage-boundary/TASK.json @@ -1 +1 @@ -{"schema_version":1,"task_id":"coverage-law-change","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"coverage-law-change","question":"Can a template or call contract leave two or more unpaid coordinates per live family?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/idle-axis-hosting/PROOF.md","certificates/selected-result.json"],"methods":["State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.","Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template."],"acceptance_gate":"An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).","bottleneck_link":"The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.","allowed_variations":["One template change or one endpoint-contract change.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["coverage identity","unpaid coordinate","deficit law","W - 64N"]},"scope_status":"changed","actual_scope":"Source-bound selected family ledger audit answering PR3754's aggregation-versus-actual-contract question, with local conservation and centre/ordinary no-double-counting controls.","scope_change_reason":"User assigned two-unpaid feasibility. Existing pooled arithmetic is credited, not repeated as a new result. This binds the hypothetical mass to actual physical-family endpoint rows before further construction.","bottleneck_link":"A second unpaid coordinate requires a changed ordinary endpoint, not merely an integral averaged histogram.","budget_minutes":null,"stop_rule":"Finish the source-bound coverage bridge and explicit counterfactual controls. Do not construct dependent suppliers without a new endpoint and complete cost gate.","outcome":"partial","evidence":"Eight generic tests passed locally normally and with -O on CPython3.13.5. The complete selected archive-dependent family ledger awaits hosted execution.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance in proof and separate counting implementations. No spawned agents, independent human review or formal-kernel acceptance.","open_questions":[{"question":"What actual source or endpoint change removes one more ordinary coordinate advance per physical family?","why_it_matters":"Pooling preserves the original per-family deficit.","first_step":"Specify new frame/owner rows, the dirty-state implementation and complete costs before repricing unpaid=2.","blocked_by":"No replacement native endpoint, admissible source or full supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API checked at entry and before packaging, unchanged; shell DNS unavailable.","overlap":"PR1012 sources, PR3754/3747/1685, restricted3561 and actual2203 payload work read. Discussion/diff coverage incomplete.","claim":"Attempted upstream combined claim rejected403; not published or reserved.","preservation":"Selected sources and frontier unchanged; one additive directory."},"family_gate":{"decision":"narrow","proved":"Written additive conservation lemma and generic controls.","pending":"Actual selected source-dependent replay.","unknown":"A changed source/endpoint, native execution, physical subspaces, restoration, precision, hosting and full recursive costs."}} +{"schema_version":1,"task_id":"coverage-law-change","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"coverage-law-change","question":"Can a template or call contract leave two or more unpaid coordinates per live family?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/idle-axis-hosting/PROOF.md","certificates/selected-result.json"],"methods":["State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.","Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template."],"acceptance_gate":"An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).","bottleneck_link":"The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.","allowed_variations":["One template change or one endpoint-contract change.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["coverage identity","unpaid coordinate","deficit law","W - 64N"]},"scope_status":"changed","actual_scope":"Source-bound selected family ledger audit answering PR3754's aggregation-versus-actual-contract question, with local conservation and separate centre/ordinary budgets.","scope_change_reason":"User assigned two-unpaid feasibility. Prior pooled arithmetic is credited. This closes the specific unchanged selected-family contract bridge, not a new physical decoder or integer optimum.","bottleneck_link":"A second unpaid coordinate needs a changed ordinary endpoint, not merely an integral pooled histogram.","budget_minutes":null,"stop_rule":"Conclude the fixed-ledger contract gate; no dependent construction without a new endpoint and favourable full bill.","outcome":"completed","evidence":"At head4878895a3a8ff339d7b9aa30f52389282ae9a9fc, hosted run39176163645 passed both actual-archive modes, eight tests in each mode and unchanged-input checks. Every14336family has one unpaid coordinate; aggregate mass1041408 and centre mass9216 are source-derived. This publication freezes the exact receipt and registers Git-free/CLI controls; final execution is recorded on the PR.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance and separate counting implementations. No spawned agents, independent human or formal-kernel acceptance.","open_questions":[{"question":"Which actual source or endpoint change removes one more ordinary advance per family?","why_it_matters":"Pooling preserves the unchanged family conservation law.","first_step":"Specify new frame/owner rows, the dirty-state implementation and complete costs before repricing unpaid=2.","blocked_by":"No replacement native endpoint, admissible source or full supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API checked at entry and again before finalisation, unchanged. Frozen inputs retained.","overlap":"Read PR1012 and selected archive semantics, PR3754/3747/1685, restricted3561 and actual2203. Full Discussion/diff coverage unavailable.","claim":"Upstream claim write rejected403; no upstream reservation.","fork_pr":"https://github.com/Clear1nsight/integer-mult-bounds/pull/4","preservation":"Original source bytes, main branches and selected record unchanged."},"family_gate":{"decision":"narrow","status":"fixed-ledger result complete","proved":"Source-bound ordinary/centre ledger and scoped additive conservation.","unknown":"Changed endpoint, native subspaces, physical execution, dirty restoration, precision, hosting and complete supplier cost."}} diff --git a/research/selected-family-coverage-boundary/VERIFY.json b/research/selected-family-coverage-boundary/VERIFY.json index 38f4b220f6..d1dedd5e42 100644 --- a/research/selected-family-coverage-boundary/VERIFY.json +++ b/research/selected-family-coverage-boundary/VERIFY.json @@ -1 +1 @@ -{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Eight exact synthetic ledger and source-corruption controls."},{"argv":["{python}","-I","-O","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Synthetic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py","--emit"],"timeout_seconds":120,"checks":"Reconstruct actual selected family ledger from frames, call owners, slots and idle children; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/verify.py","--emit"],"timeout_seconds":120,"checks":"Fresh source-bound ledger and counterfactual controls under optimisation; discovery output."}]} +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Eight exact synthetic ledger and source-corruption controls."},{"argv":["{python}","-I","-O","-B","{package}/test_coverage.py"],"timeout_seconds":60,"checks":"Synthetic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":120,"checks":"Reconstruct actual selected family ledger and strictly compare the committed receipt."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":120,"checks":"Fresh optimised source-bound ledger matching the same committed receipt."},{"argv":["{python}","-I","-B","{package}/publication.py"],"timeout_seconds":120,"checks":"Actual Git-free optimised replay, unchanged exported bytes/modes and three real CLI rejection controls."}]} diff --git a/research/selected-family-coverage-boundary/publication.py b/research/selected-family-coverage-boundary/publication.py new file mode 100644 index 0000000000..6f93467002 --- /dev/null +++ b/research/selected-family-coverage-boundary/publication.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Actual Git-free replay and CLI failure controls for this package. + +Clear1nsight with substantial OpenAI assistance. Copies only this package and +its declared source archive into an isolated temporary tree. No original input +is edited. This verifies portability and rejection, not native semantics. +""" +from hashlib import sha256 +from pathlib import Path +import json +import os +import shutil +import stat +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +ARCHIVE = 'research/community-frontier1094-audit/selected-replay.tar.gz' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def inventory(root): + return {str(path.relative_to(root)): [sha256(path.read_bytes()).hexdigest(), + stat.S_IMODE(path.stat().st_mode)] + for path in sorted(root.rglob('*')) if path.is_file()} + + +def execute(package, env, success, reason=None): + run = subprocess.run([sys.executable, '-I', '-O', '-B', str(package/'verify.py')], + cwd=package.parents[1], env=env, capture_output=True, + text=True, timeout=150) + if success: + need(run.returncode == 0, 'portable replay failed: '+run.stderr[-2000:]) + lines = [line[12:] for line in run.stdout.splitlines() if line.startswith('RESULT_JSON=')] + need(len(lines) == 1, 'one portable scientific result') + canonical = json.dumps(json.loads(lines[0]), sort_keys=True, separators=(',', ':')) + return sha256(canonical.encode()).hexdigest() + need(run.returncode != 0 and reason in run.stderr, 'CLI mutant not rejected by expected guard') + return None + + +def main(): + need((ROOT/ARCHIVE).is_file(), 'original source archive required') + with tempfile.TemporaryDirectory(prefix='research-portable-') as temp: + root = Path(temp) + package = root/'research'/HERE.name + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns('__pycache__','*.pyc')) + source = root/ARCHIVE + source.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(ROOT/ARCHIVE, source) + need(not (root/'.git').exists(), 'export has no Git metadata') + env = dict(os.environ, PATH='', PYTHONDONTWRITEBYTECODE='1') + need(shutil.which('git', path=env['PATH']) is None, 'Git unavailable to replay') + before = inventory(root) + receipt = execute(package, env, True) + need(before == inventory(root), 'portable replay changed exported bytes or modes') + expected = package/'RESULT.json' + original_result = expected.read_bytes() + value = json.loads(original_result) + need(value['schema_version'] == 1, 'version-one receipt') + value['schema_version'] = True + expected.write_text(json.dumps(value)) + execute(package, env, False, 'typed result mismatch') + expected.write_bytes(original_result) + held = source.with_name(source.name+'.held') + source.rename(held) + try: + execute(package, env, False, 'regular') + finally: + held.rename(source) + with source.open('r+b') as stream: + first = stream.read(1) + stream.seek(0) + stream.write(bytes([first[0] ^ 1])) + try: + execute(package, env, False, 'archive hash') + finally: + shutil.copy2(ROOT/ARCHIVE, source) + need(before == inventory(root), 'controls did not restore their isolated snapshot') + print('PASS_GIT_FREE_PUBLICATION package='+HERE.name+' files='+str(len(before))+ + ' canonical_receipt_sha256='+receipt+' cli_rejections=3 bytes_and_modes_unchanged=true') + + +if __name__ == '__main__': + main() From dcc8ba0290c371ba34f7a0c3c8b22cb3ffd2f511 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 10:43:29 +1100 Subject: [PATCH 5/9] research: freeze discrete centre-sharing certificate and portable checks Record both source-bound rank certificates and the exact causal secant receipt. Add finite two-point controls and Git-free command-line corruption checks. The uniform scalar-oracle conclusion does not claim a fixed native Fourier lower bound. --- research/centre-causal-tangent/README.md | 133 ++++++++++++------ research/centre-causal-tangent/SECANT.json | 1 + research/centre-causal-tangent/TASK.json | 2 +- research/centre-causal-tangent/VERIFY.json | 2 +- research/centre-causal-tangent/publication.py | 76 ++++++++++ research/centre-causal-tangent/test_secant.py | 86 +++++++++++ 6 files changed, 257 insertions(+), 43 deletions(-) create mode 100644 research/centre-causal-tangent/SECANT.json create mode 100644 research/centre-causal-tangent/publication.py create mode 100644 research/centre-causal-tangent/test_secant.py diff --git a/research/centre-causal-tangent/README.md b/research/centre-causal-tangent/README.md index 1249f40c03..88f23816d5 100644 --- a/research/centre-causal-tangent/README.md +++ b/research/centre-causal-tangent/README.md @@ -1,56 +1,107 @@ -# Generic causal centre-sharing gate +# Causal centre sharing needs operator-specific structure -User-assigned continuation of priority 1 in the PR3147/3828 stream. -Clear1nsight with substantial OpenAI assistance. Apache-2.0. +User-assigned priority1 in the PR3147/3828 research stream. Clear1nsight with +substantial OpenAI assistance. Apache-2.0. A scoped scalar-oracle theorem, +not a native sharing construction or a new multiplication exponent. -## Scope and result +## Completed mathematical result -PROOF.md gives a first-variation rank gate for the COMPLETE selected scalar -projected endpoint after replacing each centre by a common parameter z, -or z/z^(-1) according to orientation. If the two source-derived ranks pass, -its boundary derivative has rank1,152. Any finite causal linear replacement -with parameter-independent free maps and rank-one oracle calls then needs -at least1,152 such calls. Generic half-sharing at576 is ruled out. +Replace each centre operation in the complete selected scalar projection by +an unknown common multiplier z. The full boundary transfer F(z) has -This is NOT a native Fourier-call lower bound. A fixed-root-of-unity example -shows exactly why the derivative argument does not apply to a fixed native -operator. No physical sharing circuit, supplier saving or new kappa is claimed. -The source/history ranks are credited to PR2622/2763, not claimed as new. + rank F'(1) = 1,152, + rank(F(-1)-F(1)) = 1,152. -## Verification and reproduction +The first statement blocks generic linear half-sharing near z=1. The stronger +second statement only requires a replacement to work for BOTH scalar-oracle +choices +1 and -1. With oracle-independent free maps, any finite fixed causal +linear circuit requires at least1,152 rank-one oracle invocations. Arbitrary +fixed linear recoding, finite workspace and singular clears are permitted. +The result also covers z/z^(-1) according to forward/backward orientation. +A576-query uniform replacement is impossible in this exact class. -Eight generic controls passed locally on CPython3.13.5 in normal and optimised -modes. The selected archive is not available to the local runtime because DNS -is unavailable. Actual source-dependent execution is pending in the existing -registered Python3.12 workflow; draft status remains until inspected. +Neither statement proves a recursive-call lower bound for a SINGLE KNOWN native +Fourier operator. Nonlinear/adaptive algorithms, oracle-dependent free maps, +different required outputs and larger-rank primitives are outside the model. +The fixed fourth-power example explicitly shows why a derivative bound cannot +be transferred to a fixed finite-order operator. The secant bound correctly +assigns that example zero two-point rank. + +PROOF.md gives the time-expanded sheaf and derivative argument. SECANT-PROOF.md +gives the stronger discrete theorem. Causality yields the exact formula + + F(z)-I = B (I-(z-1)K)^(-1) (z-1) C. + +The source matrix C is onto the1,152-site space, final-response B is injective, +and feedback K is strictly lower triangular in actual chronological order. +All source/rank facts retain PR2622/2763 credit; causal feedback retains PR2814 +credit. The new implication is the explicit uniform-oracle query bound with +its model-discrimination controls, not rediscovery of the earlier ranks. + +## Source-dependent evidence + +At head6bc9bdb8c5b669597b6808126c5ecff5ac07a9c9 the registered fork workflow passed +all original-source derivative and discrete checks normally and under-O: +https://github.com/Clear1nsight/integer-mult-bounds/actions/runs/39177162360 +The final publication adds frozen SECANT.json, five generic secant tests and +real Git-free/CLI controls. Its exact-head execution is recorded on the PR. + +The programme has144 calls,1,152 centre occurrences,144 paired bridges and +14,336 ordinary outputs. Both C/B ranks are certified at two primes. The +feedback matrix has66,146 nonzero coefficients. Each of two dense dual-number +runs and the separate literal-minus-one run executes all2,835,792 scalar +instructions. The minus-one replay matches all1,152 innovation cuts and all +14,336 output coordinates. Omitting feedback changes14,330 final outputs in +that fixture; inserting a causal cycle is rejected. + +The constant-frame scalar semantics are inherited. Climbs, adapters, idle and +address operations are explicitly projected to identity. Finite dense probes +support code correctness; the written rank/factorisation proofs establish the +all-input scalar conclusions under these hypotheses. + +## Reproduction ```sh python3.12 -I -B scripts/research_package.py --package research/centre-causal-tangent ``` -The primary derives all formal source/error rows and exact modular ranks. -A separate full dual-number interpreter checks dense signed input on every -archived scalar instruction and both sign conventions. These share the parser -and archived mathematical source, not the local/bridge/end-state routines. -The direct `--emit` option produces discovery output. Final replay without -that flag requires strict equality with a committed RESULT.json. +The standard-library hook executes thirteen generic tests in both modes, both +source-dependent mathematical replays in both modes, then actual Git-free +replays and four command-line corruption controls. RESULT.json and SECANT.json +are strictly compared, without discovery --emit flags. Original sources stay +unchanged. The portable hook checks exported bytes and permission modes. + +Actual selected-archive execution was hosted on Ubuntu24.04.5/CPython3.12.15 +because local DNS was unavailable. Local CPython3.13.5 ran generic tests, not +the original archive. Separate full literal interpreters share the source +parser and assisted author, but not the primary local/bridge update routines. +No spawned agents, independent human or formal proof-kernel review is claimed. -## Open next questions and gate +## Open next question and decision -Can an actual fixed native-operator identity evade the generic model and meet -the complete required endpoint, including arbitrary dirty inputs and cleanup? -Start with one identity that fails generic z but holds for the actual native -operator, then charge all source, frame, ownership, precision and return costs. -No such circuit or favourable full bill is supplied. NARROW until that boundary -is specified; another abstract kernel census would not answer it. +NARROW / COMPLETE for uniform scalar-oracle sharing. A productive native route +must identify a relation specific to the actual fixed operators, not assumed +valid for both scalar signs. Start with one candidate identity, name all +required source/dirty-return/output states and its legal frame interval, then +charge all acquisition, conversion, restoration, hosting and precision costs. +None is supplied here. This is an explicit remaining opportunity, not a claim +that a profitable native programme has been found or that all sharing is closed. -Canonical main is pinned at20ecf2891d80b5acf18d980b2164fb44ea7faa90, revision6. +## Coordination and predecessor credit + +Canonical base20ecf2891d80b5acf18d980b2164fb44ea7faa90, priority revision6, was +refreshed at entry, before packaging and before the discrete refinement. AGENTS.md, autoresearch.md, CONTRIBUTING.md and the family gate were reread. -Targeted live overlap included1012/2622/2763/2814/3147/3754/3797/3828. Full -Discussion access was unavailable, and the attempted upstream claim returned403. -No claim was published or reserved. No main branch, frozen input or frontier is -changed. No separate agent, independent human or proof-kernel review is claimed. - -Predecessor attribution and exact mathematical boundaries are in PROOF.md. -Ross Richardson's PR3797 independently covers the prior fixed-block full-kernel -result and is explicitly credited rather than repeated in this contribution. +Targeted live overlap was checked; complete Discussion/diff coverage was +unavailable. The upstream claim returned403 and was not published. The fork +record is https://github.com/Clear1nsight/integer-mult-bounds/pull/3 . +No main branch, selected frontier, predecessor source or other PR was changed. + +Credit Sagar Thakrar/PR2199 after Adam Gall/PR1918; ywz65/PR2622 and PR2763's +bridge-source audit; Tekalign/PR2814 after Arham Tahir/PR2799; David Charbonneau/ +PR3147; and the selected Rohan Arun/Jeremy Kothe/Hao Yan/Aaron Wang/native/compiler +lineage. PR3151 and PR3194 retain distinct circle/history obstructions. Ross +Richardson's PR3797 independently establishes the prior fixed-block full-kernel +result and is credited alongside Matarener/PR3656; our PR3828 is not repeated. +Classical sheaf theory retains Hansen/Ghrist attribution in PROOF.md. No +literature-wide novelty or new native tariff is claimed. diff --git a/research/centre-causal-tangent/SECANT.json b/research/centre-causal-tangent/SECANT.json new file mode 100644 index 0000000000..9a1d65e745 --- /dev/null +++ b/research/centre-causal-tangent/SECANT.json @@ -0,0 +1 @@ +{"changed_outputs":14336,"chronological_order_sha256":"9daeb95e433380bf25baf88b96eb2354af2d8175b998f19072a8f247f7836746","controls":["cyclic_feedback_rejected","missing_feedback_detected"],"feedback_nonzeros":66146,"feedback_sha256":"e27b07bc9ba8023c864535f6b753574dc3fe4b480b1496c5828923d175877ace","fixed_single_native_operator_lower_bound":false,"literal_scalar_operations":2835792,"minimum_uniform_sign_oracle_queries":1152,"minus_one_innovations_sha256":"fa3ab27c0d29b170de18d1698503fa656d5bf5df46f1c2c0927e2387a9616829","minus_one_output_sha256":"aada502e49ded43e41992e95a1a595bf9ad7e9304d20d4b8b791fbfaa9fcd237","omitted_feedback_differing_outputs":14330,"schema_version":1,"secant_rank":1152,"sites":1152,"status":"PASS_CENTRE_TWO_POINT_SECANT"} diff --git a/research/centre-causal-tangent/TASK.json b/research/centre-causal-tangent/TASK.json index a0fd43673b..35b2822189 100644 --- a/research/centre-causal-tangent/TASK.json +++ b/research/centre-causal-tangent/TASK.json @@ -1 +1 @@ -{"schema_version":1,"task_id":"centre-path-sharing","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"centre-path-sharing","question":"Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt","certificates/selected-result.json"],"methods":["Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.","Prove a lower bound on copied information per call for the selected decoder contract."],"acceptance_gate":"Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).","bottleneck_link":"The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.","allowed_variations":["One sharing pattern across a fixed number of calls.","One reduced copied-total contract for the existing decoder.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Removing copies without a replacement contract for the decoder's copied totals.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["centre path","copied totals","private temporary","shared centre","batching"]},"scope_status":"changed","actual_scope":"First-variation rank gate for the selected complete scalar projected transfer under a common or reciprocal generic centre parameter, with a fixed-operator counterexample.","scope_change_reason":"User assigned temporal sheaves and cross-call sharing. The new implication combines credited source/response ranks with an arbitrary causal linear oracle rank budget. It deliberately does not extend that bound to the fixed native Fourier operator.","bottleneck_link":"Tests whether generic temporal recoding can remove half the centre oracle calls before spending effort on a physical schedule.","budget_minutes":null,"stop_rule":"Finish one parameterised contract gate and its source-bound checks. No native construction expansion without an explicit changed endpoint and fully paid cost ledger.","outcome":"partial","evidence":"Eight generic tests passed locally normally and with -O on CPython3.13.5. The two archive-dependent ranks and literal dual-number comparisons await hosted execution.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance; separate implementations, no spawned agents, independent human review or formal-kernel acceptance.","open_questions":[{"question":"Can a fixed native operator identity evade the generic parametric rank gate?","why_it_matters":"The fixed native transform need not agree with a family near z=1.","first_step":"Specify one fixed-operator identity with every required input, output, frame and restoration condition, and its complete cost.","blocked_by":"No qualifying native sharing circuit or favourable supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API checked at entry and again before packaging, unchanged. Shell network unavailable.","overlap":"Targeted live PR and source reads including2622/2763/2814/3147/3754/3797/3828; incomplete Discussion/diff coverage.","claim":"Upstream claim comment rejected403; not published and no reservation.","preservation":"Frozen archive and predecessor code unchanged; isolated additive package only."},"family_gate":{"decision":"narrow","proved":"Written generic product-rule rank theorem and synthetic controls.","pending":"Actual selected source-dependent replay.","unknown":"Fixed native sharing, physical access, frames, precision, dirty restoration, hosting and full recursive costs."}} +{"schema_version":1,"task_id":"centre-path-sharing","priority_revision":6,"base_commit":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","original_card":{"id":"centre-path-sharing","question":"Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?","starting_points":["docs/research/research-family-status.md","research/complex-local-word-ceiling/README.md","research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt","certificates/selected-result.json"],"methods":["Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.","Prove a lower bound on copied information per call for the selected decoder contract."],"acceptance_gate":"Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.","first_step":{"command":["python3","-B","research/complex-local-word-ceiling/verify.py"],"expected":"PASS_COMPLEX_LOCAL_WORD_CEILING","inspect":"Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.","scope":"Positive control and planning budget only; this is not a new construction or full cold replay."},"first_experiment":"Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).","bottleneck_link":"The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.","allowed_variations":["One sharing pattern across a fixed number of calls.","One reduced copied-total contract for the existing decoder.","If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."],"scope_change_triggers":["Removing copies without a replacement contract for the decoder's copied totals.","Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."],"overlap_terms":["centre path","copied totals","private temporary","shared centre","batching"]},"scope_status":"changed","actual_scope":"Complete projected boundary derivative and discrete secant rank gates against uniform causal linear scalar-oracle sharing, with fixed-native-operator limitations.","scope_change_reason":"User assigned temporal sheaves. Combining credited source/response ranks with causal product differences closes a generic half-sharing contract; it does not imply a fixed native Fourier lower bound.","bottleneck_link":"Separates generic recoding, which cannot halve the oracle calls, from genuinely fixed-operator native opportunities.","budget_minutes":null,"stop_rule":"Conclude the scalar-oracle gate and source checks; no native implementation expansion without an operator-specific identity and favourable complete bill.","outcome":"completed","evidence":"Run39177162360 at head6bc9bdb8c5b669597b6808126c5ecff5ac07a9c9 passed normal and optimised derivative and secant replays. Both source and response ranks are1152; feedback has66146 coefficients; all1152 cuts and14336 minus-one outputs match a literal2835792-instruction replay. Missing feedback changes14330 outputs. This publication freezes both receipts and adds generic secant and Git-free/CLI checks; final evidence is recorded on the PR.","author":"Clear1nsight","ai_assistance":"Substantial OpenAI assistance, separate literal implementations; no spawned agents, independent human or formal-kernel review.","open_questions":[{"question":"Can a relation specific to the actual fixed native operators realise cheaper sharing?","why_it_matters":"A fixed known operator need not satisfy the uniform scalar-sign contract.","first_step":"Specify one native identity with all required dirty-input/output/frame/return conditions and complete costs before constructing a sharing circuit.","blocked_by":"No qualifying native identity, priced acquisition/restoration or full supplier invoice is supplied."}],"coordination":{"canonical_main":"20ecf2891d80b5acf18d980b2164fb44ea7faa90","priority_revision":6,"checkpoint":"Canonical API refreshed at entry, packaging and before discrete strengthening, unchanged; frozen inputs preserved.","overlap":"Relevant PR2622/2763/2814/3147/3754/3797/3828 inspected and targeted secant search found no match. Full Discussion/diff coverage unavailable; no novelty guarantee.","claim":"Upstream combined claim write rejected403, not published and no reservation.","fork_pr":"https://github.com/Clear1nsight/integer-mult-bounds/pull/3","preservation":"Only isolated package changes; no main, selected record or predecessor edits."},"family_gate":{"decision":"narrow","status":"uniform scalar-oracle result complete","proved":"Scoped derivative/secant query-rank theorem with source-derived ranks and causal coefficients.","unknown":"Fixed native sharing, physical access, frames, precision, dirty restoration, hosting and full recursive invoice."}} diff --git a/research/centre-causal-tangent/VERIFY.json b/research/centre-causal-tangent/VERIFY.json index 161342658b..9b9398de1f 100644 --- a/research/centre-causal-tangent/VERIFY.json +++ b/research/centre-causal-tangent/VERIFY.json @@ -1 +1 @@ -{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic theorem/boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":200,"checks":"Fresh source-bound derivative and complete dual-number replays, strictly matching the committed receipt."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":200,"checks":"Fresh optimised derivative and literal replay matching the same receipt."},{"argv":["{python}","-I","-B","{package}/secant.py","--emit"],"timeout_seconds":120,"checks":"Discrete two-point strengthening: exact feedback, all innovation cuts and literal minus-one endpoint; discovery output."},{"argv":["{python}","-I","-O","-B","{package}/secant.py","--emit"],"timeout_seconds":120,"checks":"Optimised source-dependent discrete secant check; discovery output."}]} +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic derivative theorem/boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five exact two-point product, feedback and boundary controls, including28 noncommuting words."},{"argv":["{python}","-I","-O","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five two-point controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Source-dependent derivative certificate and complete dual replays matching the committed result."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Optimised derivative replay matching the same committed result."},{"argv":["{python}","-I","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Exact causal feedback and all literal minus-one cuts/outputs matching the committed secant receipt."},{"argv":["{python}","-I","-O","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Optimised discrete source-dependent replay matching the same committed receipt."},{"argv":["{python}","-I","-B","{package}/publication.py"],"timeout_seconds":300,"checks":"Actual Git-free optimised derivative and secant replay, four real CLI rejections, unchanged exported bytes and modes."}]} diff --git a/research/centre-causal-tangent/publication.py b/research/centre-causal-tangent/publication.py new file mode 100644 index 0000000000..98e5fa52fc --- /dev/null +++ b/research/centre-causal-tangent/publication.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Actual Git-free derivative/secant replay and CLI corruption controls. + +Clear1nsight with substantial OpenAI assistance. Only isolated copies change. +This is portability and rejection evidence, not native supplier admission. +""" +from hashlib import sha256 +from pathlib import Path +import json +import os +import shutil +import stat +import subprocess +import sys +import tempfile + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +ARCHIVE='research/community-frontier1094-audit/selected-replay.tar.gz' + + +def need(ok,message): + if not ok: raise ValueError(message) + + +def inventory(root): + return {str(p.relative_to(root)):[sha256(p.read_bytes()).hexdigest(),stat.S_IMODE(p.stat().st_mode)] + for p in sorted(root.rglob('*')) if p.is_file()} + + +def execute(package,env,script,success,reason=None): + run=subprocess.run([sys.executable,'-I','-O','-B',str(package/script)],cwd=package.parents[1], + env=env,capture_output=True,text=True,timeout=150) + if success: + need(run.returncode==0,'portable replay failed: '+run.stderr[-2000:]) + prefix='RESULT_JSON=' if script=='verify.py' else 'SECANT_JSON=' + lines=[line[len(prefix):] for line in run.stdout.splitlines() if line.startswith(prefix)] + need(len(lines)==1,'one substantive portable receipt') + raw=json.dumps(json.loads(lines[0]),sort_keys=True,separators=(',',':')).encode() + return sha256(raw).hexdigest() + need(run.returncode!=0 and reason in run.stderr,'CLI mutation did not fail at the expected guard') + return None + + +def main(): + need((ROOT/ARCHIVE).is_file(),'original archive required') + with tempfile.TemporaryDirectory(prefix='causal-portable-') as tmp: + root=Path(tmp); package=root/'research'/HERE.name + shutil.copytree(HERE,package,ignore=shutil.ignore_patterns('__pycache__','*.pyc')) + source=root/ARCHIVE; source.parent.mkdir(parents=True,exist_ok=True); shutil.copy2(ROOT/ARCHIVE,source) + env=dict(os.environ,PATH='',PYTHONDONTWRITEBYTECODE='1') + need(not (root/'.git').exists() and shutil.which('git',path='') is None,'Git unavailable') + before=inventory(root) + hashes={script:execute(package,env,script,True) for script in ('verify.py','secant.py')} + need(before==inventory(root),'portable replay changed exported bytes or modes') + for filename,script,reason in (('RESULT.json','verify.py','typed result mismatch'), + ('SECANT.json','secant.py','typed secant receipt differs')): + path=package/filename; saved=path.read_bytes(); value=json.loads(saved) + need(value['schema_version']==1,'version-one scientific receipt') + value['schema_version']=True; path.write_text(json.dumps(value)) + try: execute(package,env,script,False,reason) + finally: path.write_bytes(saved) + held=source.with_name(source.name+'.held'); source.rename(held) + try: execute(package,env,'verify.py',False,'regular selected archive') + finally: held.rename(source) + with source.open('r+b') as stream: + first=stream.read(1); stream.seek(0); stream.write(bytes([first[0]^1])) + try: execute(package,env,'verify.py',False,'selected archive hash') + finally: shutil.copy2(ROOT/ARCHIVE,source) + need(before==inventory(root),'corruption controls failed to restore their private copies') + print('PASS_GIT_FREE_CAUSAL_PUBLICATION files='+str(len(before))+' cli_rejections=4 bytes_and_modes_unchanged=true') + print('PUBLICATION_RECEIPTS='+json.dumps(hashes,sort_keys=True)) + + +if __name__=='__main__': main() diff --git a/research/centre-causal-tangent/test_secant.py b/research/centre-causal-tangent/test_secant.py new file mode 100644 index 0000000000..23ceb33ef7 --- /dev/null +++ b/research/centre-causal-tangent/test_secant.py @@ -0,0 +1,86 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Small exact two-point tests; no native operator or source admission. + +Clear1nsight, substantial OpenAI assistance. +""" +from fractions import Fraction as Q +from pathlib import Path +import types +import unittest + +HERE=Path(__file__).resolve().parent + +def module(name,filename): + m=types.ModuleType(name); m.__file__=str(HERE/filename) + exec(compile((HERE/filename).read_bytes(),m.__file__,'exec'),m.__dict__) + return m + +t=module('small_tangent','test_tangent.py') +s=module('small_secant','secant.py') + + +def sub(a,b): return [[x-y for x,y in zip(r,q)] for r,q in zip(a,b)] + +def chain(gates,n): + out=t.ident(n) + for gate in gates: out=t.mm(gate,out) + return out + + +class Tests(unittest.TestCase): + def test_two_point_telescoping_noncommuting_words(self): + cases=0 + for n in range(2,6): + for count in range(1,2*n+1): + plus=[]; minus=[]; tariff=0 + for j in range(count): + shear=t.ident(n); shear[j%n][(j+1)%n]=Q(j+1,j+2) + plus.append(shear); minus.append(shear) + gate=t.ident(n); gate[j%n][j%n]=-1 + plus.append(t.ident(n)); minus.append(gate); tariff+=1 + difference=sub(chain(minus,n),chain(plus,n)) + reconstructed=[[Q(0)]*n for _ in range(n)] + for j in range(len(plus)): + term=t.mm(chain(minus[j+1:],n),t.mm(sub(minus[j],plus[j]),chain(plus[:j],n))) + reconstructed=t.plus(reconstructed,term) + self.assertEqual(difference,reconstructed) + self.assertLessEqual(t.rk(difference),tariff) + cases+=1 + self.assertEqual(cases,28) + + def test_tight_uniform_sign_query_bound(self): + for n in range(2,7): + gates=[] + for i in range(n): + gate=t.ident(n); gate[i][i]=-1; gates.append(gate) + self.assertEqual(chain(gates,n),[[-x for x in row] for row in t.ident(n)]) + self.assertEqual(t.rk(sub(chain(gates,n),t.ident(n))),n) + + def test_fixed_fourth_power_has_zero_secant(self): + for n in range(2,6): + sign=[[-x for x in r] for r in t.ident(n)] + self.assertEqual(chain([sign]*4,n),t.ident(n)) + self.assertEqual(t.rk(sub(chain([sign]*4,n),t.ident(n))),0) + + def test_causal_resolvent_on_reordered_sites(self): + K=[{2:Q(2)},{0:Q(3),2:Q(1)},{}]; order=[2,0,1] + for delta in (Q(-2),Q(1),Q(3,2)): + columns=[] + for j in range(3): + rhs=[Q(int(i==j)) for i in range(3)] + e=s.solve(K,order,rhs,delta) + self.assertEqual([e[i]-delta*sum((q*e[k] for k,q in K[i].items()),Q(0)) + for i in range(3)], [delta*x for x in rhs]) + columns.append(e) + self.assertEqual(t.rk(list(map(list,zip(*columns)))),3) + with self.assertRaises(ValueError): s.triangular(K,[0,1,2]) + with self.assertRaises(ValueError): s.triangular(K,[2,0,0]) + + def test_weaker_output_reduces_secant_rank(self): + full=[[Q(-2)*x for x in row] for row in t.ident(4)] + self.assertEqual(t.rk(full),4) + self.assertEqual(t.rk(full[:2]),2) + + +if __name__=='__main__': unittest.main() From 13ed1fedba61fa228cb963b7ffdb028d05913f57 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 11:48:19 +1100 Subject: [PATCH 6/9] Update README.md --- research/centre-causal-tangent/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/centre-causal-tangent/README.md b/research/centre-causal-tangent/README.md index 88f23816d5..33d114c07d 100644 --- a/research/centre-causal-tangent/README.md +++ b/research/centre-causal-tangent/README.md @@ -77,7 +77,7 @@ the original archive. Separate full literal interpreters share the source parser and assisted author, but not the primary local/bridge update routines. No spawned agents, independent human or formal proof-kernel review is claimed. -## Open next question and decision +## Open next questions NARROW / COMPLETE for uniform scalar-oracle sharing. A productive native route must identify a relation specific to the actual fixed operators, not assumed From bde850a60006a55f2a4fe83d21954454500c17b7 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 11:48:50 +1100 Subject: [PATCH 7/9] Update section header in README.md --- research/selected-family-coverage-boundary/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/selected-family-coverage-boundary/README.md b/research/selected-family-coverage-boundary/README.md index bbffce50ec..e60c4fc683 100644 --- a/research/selected-family-coverage-boundary/README.md +++ b/research/selected-family-coverage-boundary/README.md @@ -58,7 +58,7 @@ No actual source-dependent local run, native replay, or independent human/formal proof-kernel acceptance is claimed. Separate counting methods share the source and assisted author. No agent-spawning tool was available in this session. -## Open next question and family gate +## Open next questions Which changed source, endpoint or multi-coordinate native primitive legitimately removes one more ordinary coordinate advance per physical family? State the From b613b3ba72834d88f0b81c2ebe11a4c54aa0433b Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 11:54:27 +1100 Subject: [PATCH 8/9] ci: keep centre causal tangent replay within eight-command limit --- research/centre-causal-tangent/VERIFY.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/research/centre-causal-tangent/VERIFY.json b/research/centre-causal-tangent/VERIFY.json index 9b9398de1f..533246ae97 100644 --- a/research/centre-causal-tangent/VERIFY.json +++ b/research/centre-causal-tangent/VERIFY.json @@ -1 +1 @@ -{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic derivative theorem/boundary controls."},{"argv":["{python}","-I","-O","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic controls under optimisation."},{"argv":["{python}","-I","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five exact two-point product, feedback and boundary controls, including28 noncommuting words."},{"argv":["{python}","-I","-O","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five two-point controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Source-dependent derivative certificate and complete dual replays matching the committed result."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Optimised derivative replay matching the same committed result."},{"argv":["{python}","-I","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Exact causal feedback and all literal minus-one cuts/outputs matching the committed secant receipt."},{"argv":["{python}","-I","-O","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Optimised discrete source-dependent replay matching the same committed receipt."},{"argv":["{python}","-I","-B","{package}/publication.py"],"timeout_seconds":300,"checks":"Actual Git-free optimised derivative and secant replay, four real CLI rejections, unchanged exported bytes and modes."}]} +{"schema_version":1,"status":"ready","python":"3.12","requirements":[],"inputs":["research/community-frontier1094-audit/selected-replay.tar.gz"],"commands":[{"argv":["{python}","-I","-B","{package}/test_tangent.py"],"timeout_seconds":30,"checks":"Eight generic derivative theorem/boundary controls."},{"argv":["{python}","-I","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five exact two-point product, feedback and boundary controls, including28 noncommuting words."},{"argv":["{python}","-I","-O","-B","{package}/test_secant.py"],"timeout_seconds":30,"checks":"Five two-point controls under optimisation."},{"argv":["{python}","-I","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Source-dependent derivative certificate and complete dual replays matching the committed result."},{"argv":["{python}","-I","-O","-B","{package}/verify.py"],"timeout_seconds":180,"checks":"Optimised derivative replay matching the same committed result."},{"argv":["{python}","-I","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Exact causal feedback and all literal minus-one cuts/outputs matching the committed secant receipt."},{"argv":["{python}","-I","-O","-B","{package}/secant.py"],"timeout_seconds":120,"checks":"Optimised discrete source-dependent replay matching the same committed receipt."},{"argv":["{python}","-I","-B","{package}/publication.py"],"timeout_seconds":300,"checks":"Actual Git-free optimised derivative and secant replay, four real CLI rejections, unchanged exported bytes and modes."}]} From 0349f5dea762151bf11c647386240883fc6c1190 Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 19 Oct 2026 15:12:27 +1100 Subject: [PATCH 9/9] fix(ci): initialise P112 temp directory within a step Resolve RUNNER_TEMP at step scope and retain the existing manual trigger, repository gate, replay commands and pass criteria. Prepared with substantial OpenAI assistance. --- .github/workflows/p112-common-slice.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/p112-common-slice.yml b/.github/workflows/p112-common-slice.yml index 37f99ca573..48047f61c4 100644 --- a/.github/workflows/p112-common-slice.yml +++ b/.github/workflows/p112-common-slice.yml @@ -15,9 +15,9 @@ jobs: if: github.repository == 'CrocSwap/integer-mult-bounds' runs-on: ubuntu-24.04 timeout-minutes: 20 - env: - TMPDIR: ${{ runner.temp }}/p112-common-slice steps: + - name: Initialise P112 work directory + run: echo "TMPDIR=$RUNNER_TEMP/p112-common-slice" >> "$GITHUB_ENV" - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: fetch-depth: 0