diff --git a/.github/workflows/register-alignment.yml b/.github/workflows/register-alignment.yml new file mode 100644 index 000000000..e8d30be7f --- /dev/null +++ b/.github/workflows/register-alignment.yml @@ -0,0 +1,75 @@ +name: Register alignment checks + +'on': + pull_request: + paths: + - 'reviews/register_alignment_20260930/**' + - '.github/workflows/register-alignment.yml' + - 'frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md' + - 'frontiers/three_fronts_20260924/RN_COUNT_INTERFACE.md' + - 'coefficients/side24_v1/PROOF.md' + - 'frontiers/remote_window_20260924/PROOF.md' + - 'frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md' + - 'frontiers/full_price_20260924/PROOF.md' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'reviews/pr22_fixed_annulus_nonauthor_20260925/**' + - 'reviews/p15_full_price_nonauthor_20260926/**' + - 'reviews/side24_v1_coefficient_claude_20260929/**' + - 'frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md' + - 'reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md' + - 'frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md' + - 'frontiers/downstream_gate_20260925/GRAPH.json' + - 'frontiers/downstream_gate_20260925/hard_gate.py' + - 'PROOF_INDEX.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-and-probe: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify sources, replay both modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('reviews/register_alignment_20260930').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + expected_names = sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']) + if present != expected_names: + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + script = str(root / 'alignment_check.py') + expected = (root / 'RESULTS.json').read_bytes() + mutants = ['allow-symlink', 'no-hash', 'stale-fingerprint', 'drop-review-source', 'controlling-true', 'executed-flag', 'skip-interface-premise', 'holder-reversed', 'baseline-drift', 'duplicate-drift', 'region-unlinked', 'review-metadata-only'] + for flags in (['-B', '-S'], ['-B', '-O', '-S']): + out = subprocess.run([sys.executable, *flags, script], + check=True, capture_output=True, timeout=300).stdout + if out != expected: + raise RuntimeError('output differs from RESULTS.json under ' + ' '.join(flags)) + for m in mutants: + rc = subprocess.run([sys.executable, *flags, script, '--mutant', m], + capture_output=True, timeout=300).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'mathematical_acceptance': False})) + PY + git diff --exit-code diff --git a/.github/workflows/two-scale-cluster-geometry.yml b/.github/workflows/two-scale-cluster-geometry.yml index b0ac3a4fe..5dae60249 100644 --- a/.github/workflows/two-scale-cluster-geometry.yml +++ b/.github/workflows/two-scale-cluster-geometry.yml @@ -1,6 +1,11 @@ name: Two-scale cluster geometry checks 'on': + push: + branches: ['main'] + paths: + - 'frontiers/two_scale_cluster_geometry_20260929/**' + - '.github/workflows/two-scale-cluster-geometry.yml' pull_request: paths: - 'frontiers/two_scale_cluster_geometry_20260929/**' diff --git a/frontiers/two_scale_cluster_geometry_20260929/MANIFEST.json b/frontiers/two_scale_cluster_geometry_20260929/MANIFEST.json index 89b7780e9..5fd85bd38 100644 --- a/frontiers/two_scale_cluster_geometry_20260929/MANIFEST.json +++ b/frontiers/two_scale_cluster_geometry_20260929/MANIFEST.json @@ -11,9 +11,9 @@ }, { "path": "README.md", - "bytes": 3850, - "sha256": "4e2de660b46fa3c0107a06062de42ee581bade186daac35d666bbfa4a1f95aa3", - "git_blob": "8ee02224f4a5edeec0050fb54c3cc36f85c1070b" + "bytes": 5636, + "sha256": "80e419ca23cfc4083957dcd5708fd77c82316dd65222691b54e5f30afeb11506", + "git_blob": "4036b28db7484aa85868afb9443a28f7cceedee3" }, { "path": "RECONNAISSANCE.md", @@ -27,11 +27,17 @@ "sha256": "3277199a22d6f187354e6f912361648e737bc8aa65107d1d7863a099c176ca8d", "git_blob": "99678cd670b9f8fee2f02d73fdb091705b825491" }, + { + "path": "REVIEW_RECORD.json", + "bytes": 4226, + "sha256": "958d2e1ae8ea5d034d0d87efce6cde9be57ebb9d7c0b671e69d3d6598a6675ca", + "git_blob": "a4b0fb99c24e2edf41973ea2a5e5176584602855" + }, { "path": "REVIEW_RECORD.md", - "bytes": 5121, - "sha256": "5295c373a16b6557584e1a633e28fd5962f3e96023945bcc068819e83a0d2cad", - "git_blob": "9f7c7f6fc59ead440258887eb113135ab1dc3463" + "bytes": 6732, + "sha256": "af1540308f37220e6592b700bf42181205b1d4588a040a5c151bf0a6f861e728", + "git_blob": "31896de23fc56822c184375d0dc2b1c7e27fcae4" }, { "path": "SOURCES.json", @@ -59,9 +65,9 @@ }, { "path": "test_custody.py", - "bytes": 7574, - "sha256": "f46073d3ff276cd0fdc571bf76e1cda8e0e4b20d93f3f7ab52a43d936258b325", - "git_blob": "d055261a2ff56d038fcf1ce803e0167c0e04d95b" + "bytes": 13368, + "sha256": "70ff39e53dd2d763e3ddf28affddedb7468c410e95565e9d0854e393f200de31", + "git_blob": "631ebf653ea760ae6cc01afd46c23b0eb893c046" }, { "path": "test_geometry.py", @@ -71,9 +77,9 @@ }, { "path": "verify.py", - "bytes": 6002, - "sha256": "335dd00fabb70db04498a84eef926266faa9f34486458724d3b0655d10b4f4ca", - "git_blob": "e401a78a1a28200f3f7e473b9260f36919ab69f8" + "bytes": 8457, + "sha256": "152a41410fbf4774368e40900b9b988505f263d574c632fe5fcdae999a0ca6ef", + "git_blob": "6ecc60a58f8f77ee59eaa4c276e5b4ae17beedb4" } ] } diff --git a/frontiers/two_scale_cluster_geometry_20260929/README.md b/frontiers/two_scale_cluster_geometry_20260929/README.md index 8ee02224f..4036b28db 100644 --- a/frontiers/two_scale_cluster_geometry_20260929/README.md +++ b/frontiers/two_scale_cluster_geometry_20260929/README.md @@ -65,3 +65,32 @@ source identity to be a commit object, not merely a forty-hex tree-ish name. Fou real-Git red/green regressions cover forged/legitimate replacement bindings and tree/tag substitution. Both mathematical manuscripts and all mathematical inputs remain byte-identical to the initial reviewed head. + +## Current proof-to-review custody replay + +The earlier 52-test count describes the preceding custody repair. The current +replay runs 61 unit tests in each Python mode, including nine additional test +methods for proof and review bindings. The verifier requires both manuscripts, +the source/result declarations, both review records, the executable checker and +verifier, and both test modules. Regenerating MANIFEST.json cannot silently omit +these files or move an old review to different proof bytes. + +REVIEW_RECORD.json records the actual A/B/C native IDs, COMMENTED states, raw +review-body byte counts and SHA256 digests, exact reviewed commit, proof mapping, +conditional scopes and exposure. The verifier anchors the entire frozen record +and the accepted manuscript/source identities outside the regenerable inventory. +Intentional future mathematical changes require reviewed updates to those +anchors and the review record. Both current manuscripts, SOURCES.json, +RESULTS.json and geometry.py remain unchanged. + +This is an offline consistency check. Its successful summary explicitly reports +remote_review_authenticity_checked=false and mathematical_acceptance=false. +The native bodies were actually fetched during integration preflight; the local +CLI does not fetch them or authenticate a remote reviewer. In --local-only mode, +the source declaration's frozen bytes are still checked, while the historical +Git objects remain excluded and source_pins_checked=false. + +The same workflow now also runs for main pushes affecting this packet or its own +workflow, providing a scoped post-merge replay route. Prior PR/manual coverage +was not itself a verifier defect. Hosted success must bind the actual candidate +or merge commit; this local note supplies no CI result or mathematical vote. diff --git a/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.json b/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.json new file mode 100644 index 000000000..a4b0fb99c --- /dev/null +++ b/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.json @@ -0,0 +1,77 @@ +{ + "schema": "math166-scoped-review-binding-v1", + "scientific_effect": "NONE", + "mathematical_acceptance": false, + "remote_review_authenticity_checked": false, + "reviewed_commit": "7c82252533c3fe14ee262f7f87c0549c10968592", + "proofs": [ + { + "path": "TWO_SCALE_LAW.md", + "bytes": 17139, + "sha256": "e81d7fe09d25c3266eb8e62922756f54761d7f74d692fb35d9a8071fffd73769", + "git_blob": "a32fd5f7d941bbe1fe943df045b1e0fbec8d691c" + }, + { + "path": "RADIAL_TAIL.md", + "bytes": 12533, + "sha256": "250897858c8b314c0ff85ec1860a725efacfdae0ff7409fced4cadf7bfb85973", + "git_blob": "0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4" + } + ], + "source_manifest": { + "path": "SOURCES.json", + "bytes": 2923, + "sha256": "de09c2cf3c9082a09d168f451f78a1a60b150f9f55c0c6b9bfe94ac26652dfe0", + "git_blob": "59d11113e208965fefeaadd1bd5866585e77dc82" + }, + "reviews": [ + { + "slice": "A", + "native_review_id": 5360227991, + "native_state": "COMMENTED", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/166#pullrequestreview-5360227991", + "submitted_at": "2026-09-30T00:52:00Z", + "reviewed_commit": "7c82252533c3fe14ee262f7f87c0549c10968592", + "proof_path": "TWO_SCALE_LAW.md", + "body_bytes": 7840, + "body_sha256": "c63efc292d7cf209e2770419cc159276897d0ba955c32ee1d2af88c8aa7f0ed8", + "reported_disposition": "ACCEPT at the stated conditional scope", + "scope": "Theorem T, Theorem L, ordered-pair law L3, sampling/order of limits and spatial-TV obstruction V1; conditional on exact imported source interfaces, without a rate or parent revalidation." + }, + { + "slice": "B", + "native_review_id": 5360178611, + "native_state": "COMMENTED", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/166#pullrequestreview-5360178611", + "submitted_at": "2026-09-30T00:42:15Z", + "reviewed_commit": "7c82252533c3fe14ee262f7f87c0549c10968592", + "proof_path": "RADIAL_TAIL.md", + "body_bytes": 7631, + "body_sha256": "3042d958b769b0a9ada1359b6f8d9461c090060fe5057cff795c99b6c6c2894d", + "reported_disposition": "ACCEPT at the stated conditional scope", + "scope": "RADIAL_TAIL R4-R13: the already-formed limiting microscopic point-intensity tail, full coefficient and moment boundary; conditional on SC/CUB, with r tending to zero before radius tends to infinity." + }, + { + "slice": "C", + "native_review_id": 5360216551, + "native_state": "COMMENTED", + "url": "https://github.com/d6g8k5htny-coder/Math-/pull/166#pullrequestreview-5360216551", + "submitted_at": "2026-09-30T00:49:42Z", + "reviewed_commit": "7c82252533c3fe14ee262f7f87c0549c10968592", + "proof_path": "RADIAL_TAIL.md", + "body_bytes": 4277, + "body_sha256": "9a2c89c6e0c122fc75cc96a2b6392b47ab33bc47feb072b9f2a56315c527df84", + "reported_disposition": "ACCEPT at the stated conditional scope", + "scope": "RADIAL_TAIL H1-H4: extreme marks under point-intensity sampling of the already-formed microscopic measure, not a uniformly sampled configuration or finite-r global law.", + "proof_binding_note": "The native C review refers to B's same full Git blob and an abbreviated SHA256. The integration preflight matched the complete proof bytes at the native reviewed commit; this record does not claim C printed a fresh full digest." + } + ], + "exposure": { + "reviewer_provider": "Anthropic", + "reviewer_model_attribution": "Claude", + "same_session_for_all_three": true, + "organizational_independence_credit": 0, + "notes": "Actual native review bodies were read back by the integration preflight. These are three disjoint scopes from one provider-distinct session, not three independent votes. Parent proofs remain imported; no new analytic review is supplied by this custody repair." + }, + "binding_policy": "The verifier pins this complete record and the accepted proof/source byte identities. Regenerating MANIFEST.json cannot transfer these old reviews to changed mathematics. An intentional future update requires reviewed changes to the bindings and verifier anchors. Offline replay does not contact GitHub or authenticate a remote reviewer." +} diff --git a/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.md b/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.md index 9f7c7f6fc..31896de23 100644 --- a/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.md +++ b/frontiers/two_scale_cluster_geometry_20260929/REVIEW_RECORD.md @@ -90,3 +90,28 @@ source run36652196578 and full downstream/formal run36652196938 both succeeded at the repair commit. A later metadata successor still needs fresh current-head checks; no old-head run is automatically rebound. The mathematical files, geometry.py, source pins and RESULTS.json have not changed. + +## Current integration custody repair + +At b8b028ea0a3f45aa8d2640b339977a04154909a4, independent full-CLI fixtures showed +that changing either manuscript, or removing either manuscript, still passed +after honestly regenerating MANIFEST.json. The ordinary unresigned mutation +correctly failed. These were inventory/review-binding defects, not mathematical +counterexamples. The original reviewed manuscripts remain unchanged. + +The current repair requires the proof/review declarations and every executable +or test module used by the advertised replay. It binds both current manuscripts +and SOURCES.json to fixed accepted identities and pins the complete additive +REVIEW_RECORD.json, including actual native review body identities. A co-edit of +a manuscript, review metadata and manifest cannot rebind an old review merely by +re-signing the mutable inventory. Nine new regression methods cover these cases; +the current suite contains 61 tests per Python mode. Existing exact geometry, +eight semantic mutants and Git replacement/commit-type controls remain intact. + +The A/B/C records above retain their original conditional scope and exposure. +C's native proof identity cross-references B's full blob and gives an abbreviated +digest; actual bytes at the native reviewed commit were independently matched +in preflight. The machine-readable record makes that distinction explicit. +Offline validation authenticates local byte relationships only: it grants no +remote-review authentication, mathematical acceptance or independence credit. +Fresh engineering review, current-head CI and integration remain separate gates. diff --git a/frontiers/two_scale_cluster_geometry_20260929/test_custody.py b/frontiers/two_scale_cluster_geometry_20260929/test_custody.py index d055261a2..631ebf653 100644 --- a/frontiers/two_scale_cluster_geometry_20260929/test_custody.py +++ b/frontiers/two_scale_cluster_geometry_20260929/test_custody.py @@ -3,6 +3,7 @@ import hashlib import json from pathlib import Path +import shutil import subprocess import tempfile import unittest @@ -141,15 +142,20 @@ def test_annotated_tag_sha_is_not_a_commit(self): def inventory_fixture(self): temp=tempfile.TemporaryDirectory();self.addCleanup(temp.cleanup) - root=Path(temp.name);data=b'packet fixture\n' + root=Path(temp.name) + for path in Path(v.__file__).parent.iterdir(): + if path.is_file():shutil.copyfile(path,root/path.name) + data=b'packet fixture\n' (root/'note.md').write_bytes(data) entry=self.fingerprint('note.md',data) - (root/'MANIFEST.json').write_text(json.dumps({'files':[entry]})) + entries=[self.fingerprint(p.name,p.read_bytes()) for p in sorted(root.iterdir()) + if p.name!='MANIFEST.json'] + (root/'MANIFEST.json').write_text(json.dumps({'files':entries})) return root,entry def test_valid_packet(self): root,entry=self.inventory_fixture() - self.assertEqual(v.verify_inventory(root),1) + self.assertEqual(v.verify_inventory(root),len(list(root.iterdir()))-1) def test_changed_packet(self): root,entry=self.inventory_fixture();(root/'note.md').write_text('changed') @@ -170,4 +176,112 @@ def test_manifest_symlink(self): with self.assertRaises(ValueError):v.verify_inventory(root) +class PacketReviewBindingTests(unittest.TestCase): + """Re-signing the inventory must not transfer an old review to new prose.""" + def setUp(self): + temp=tempfile.TemporaryDirectory();self.addCleanup(temp.cleanup) + self.root=Path(temp.name) + for path in Path(v.__file__).parent.iterdir(): + if path.is_file():shutil.copyfile(path,self.root/path.name) + self.resign() + + def resign(self): + entries=[CustodyTests.fingerprint(p.name,p.read_bytes()) + for p in sorted(self.root.iterdir()) if p.name!='MANIFEST.json'] + (self.root/'MANIFEST.json').write_text(json.dumps({'files':entries})) + + def test_current_reviewed_packet(self): + self.assertEqual(v.verify_inventory(self.root),len(list(self.root.iterdir()))-1) + + def test_resigned_manuscript_change(self): + for name in ('TWO_SCALE_LAW.md','RADIAL_TAIL.md'): + with self.subTest(path=name): + path=self.root/name;original=path.read_bytes() + path.write_bytes(original+b'\nUnreviewed replacement conclusion.\n') + self.resign() + with self.assertRaises(ValueError):v.verify_inventory(self.root) + path.write_bytes(original) + + def test_resigned_required_leaf_removal(self): + for name in ('TWO_SCALE_LAW.md','RADIAL_TAIL.md','SOURCES.json', + 'RESULTS.json','REVIEW_RECORD.md','REVIEW_RECORD.json', + 'geometry.py','verify.py','test_geometry.py','test_custody.py'): + with self.subTest(path=name): + path=self.root/name;original=path.read_bytes();path.unlink() + self.resign() + with self.assertRaises(ValueError):v.verify_inventory(self.root) + path.write_bytes(original) + + def test_resigned_source_declaration_change(self): + path=self.root/'SOURCES.json' + data=json.loads(path.read_text());data['sources'][0]['commit']='0'*40 + path.write_text(json.dumps(data));self.resign() + with self.assertRaises(ValueError):v.verify_inventory(self.root) + + def record(self): + return json.loads((self.root/'REVIEW_RECORD.json').read_text()) + + def write_record(self,record): + (self.root/'REVIEW_RECORD.json').write_text(json.dumps(record));self.resign() + + def test_resigned_proof_and_review_coedit(self): + record=self.record() + for name in ('TWO_SCALE_LAW.md','RADIAL_TAIL.md'): + with self.subTest(path=name): + path=self.root/name;original=path.read_bytes() + path.write_bytes(original+b'\nUnreviewed replacement conclusion.\n') + changed=copy.deepcopy(record) + for i,proof in enumerate(changed['proofs']): + if proof['path']==name: + changed['proofs'][i]=CustodyTests.fingerprint(name,path.read_bytes()) + self.write_record(changed) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + path.write_bytes(original) + + def test_missing_duplicate_or_swapped_reviews(self): + original=self.record() + records=[] + missing=copy.deepcopy(original);missing['reviews'].pop();records.append(missing) + duplicate=copy.deepcopy(original);duplicate['reviews'][1]=duplicate['reviews'][0] + records.append(duplicate) + swapped=copy.deepcopy(original) + swapped['reviews'][0]['proof_path']='RADIAL_TAIL.md';records.append(swapped) + for record in records: + with self.subTest(reviews=record['reviews']): + self.write_record(record) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + + def test_stale_commit_id_or_body_binding(self): + original=self.record() + for field,value in (('reviewed_commit','0'*40),('native_review_id',5360227992), + ('body_sha256','0'*64),('body_bytes',7841), + ('native_state','APPROVED')): + with self.subTest(field=field): + record=copy.deepcopy(original);record['reviews'][0][field]=value + self.write_record(record) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + + def test_no_inferred_authentication_or_independence(self): + original=self.record() + for field in ('remote_review_authenticity_checked','mathematical_acceptance'): + with self.subTest(field=field): + record=copy.deepcopy(original);record[field]=True;self.write_record(record) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + record=copy.deepcopy(original);record['exposure']['organizational_independence_credit']=1 + self.write_record(record) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + + def test_duplicate_json_or_wrong_identity_type(self): + original=self.record() + for value in (True,'17139',None): + with self.subTest(value=value): + record=copy.deepcopy(original);record['proofs'][0]['bytes']=value + self.write_record(record) + with self.assertRaises(ValueError):v.verify_inventory(self.root) + path=self.root/'REVIEW_RECORD.json' + path.write_text('{"schema":"forged","schema":"math166-scoped-review-binding-v1"}') + self.resign() + with self.assertRaises(ValueError):v.verify_inventory(self.root) + + if __name__=='__main__':unittest.main() diff --git a/frontiers/two_scale_cluster_geometry_20260929/verify.py b/frontiers/two_scale_cluster_geometry_20260929/verify.py index e401a78a1..6ecc60a58 100644 --- a/frontiers/two_scale_cluster_geometry_20260929/verify.py +++ b/frontiers/two_scale_cluster_geometry_20260929/verify.py @@ -12,6 +12,31 @@ import sys SOURCE_IDS = frozenset(('SC','CUB','RM','C6','P','D5')) +REQUIRED_PACKET_FILES = frozenset(('TWO_SCALE_LAW.md','RADIAL_TAIL.md','SOURCES.json', + 'RESULTS.json','REVIEW_RECORD.md','REVIEW_RECORD.json', + 'geometry.py','verify.py','test_geometry.py','test_custody.py')) +# These anchors are deliberately outside the regenerable MANIFEST.json. Updating +# mathematics requires a reviewed change to these anchors and the native-review +# record; re-signing an inventory cannot transfer an old review to new bytes. +ACCEPTED_FILES = ( + {'path':'TWO_SCALE_LAW.md','bytes':17139, + 'sha256':'e81d7fe09d25c3266eb8e62922756f54761d7f74d692fb35d9a8071fffd73769', + 'git_blob':'a32fd5f7d941bbe1fe943df045b1e0fbec8d691c'}, + {'path':'RADIAL_TAIL.md','bytes':12533, + 'sha256':'250897858c8b314c0ff85ec1860a725efacfdae0ff7409fced4cadf7bfb85973', + 'git_blob':'0f14417ef7038b9c6f50e4b01e393a58b7b5e3a4'}, + {'path':'SOURCES.json','bytes':2923, + 'sha256':'de09c2cf3c9082a09d168f451f78a1a60b150f9f55c0c6b9bfe94ac26652dfe0', + 'git_blob':'59d11113e208965fefeaadd1bd5866585e77dc82'}, +) +# Pins the entire local record, including actual A/B/C IDs, native COMMENTED +# states, review-body hashes, proof mappings, conditional scopes and exposure. +# This authenticates a frozen local record, not GitHub or the reviewer's identity. +FROZEN_REVIEW_RECORD = { + 'path':'REVIEW_RECORD.json','bytes':4226, + 'sha256':'958d2e1ae8ea5d034d0d87efce6cde9be57ebb9d7c0b671e69d3d6598a6675ca', + 'git_blob':'a4b0fb99c24e2edf41973ea2a5e5176584602855', +} MUTANTS = ('omit-jet-factor-two','omit-z-reflection','power-ten','wrong-cusp', 'height-reversed','wrong-window','wrong-k-power','half-root-jacobian') @@ -92,12 +117,28 @@ def verify_sources(root): return len(entries) +def verify_review_bindings(root): + record=read_json(root/'REVIEW_RECORD.json') + identity((root/'REVIEW_RECORD.json').read_bytes(),FROZEN_REVIEW_RECORD) + if (record['proofs']!=list(ACCEPTED_FILES[:2]) or + record['source_manifest']!=ACCEPTED_FILES[2]): + raise ValueError('review proof/source mapping mismatch') + for entry in ACCEPTED_FILES: + path=root/entry['path'] + if path.is_symlink() or not path.is_file(): + raise ValueError('regular reviewed source required: '+entry['path']) + identity(path.read_bytes(),entry) + return len(record['reviews']) + + def verify_inventory(root): entries=read_json(root/'MANIFEST.json')['files'] if not isinstance(entries,list) or not entries:raise ValueError('empty packet inventory') names=[e['path'] for e in entries] if len(set(names))!=len(names) or 'MANIFEST.json' in names: raise ValueError('duplicate or self-referential packet inventory') + if not REQUIRED_PACKET_FILES.issubset(names): + raise ValueError('missing required proof or review packet leaf') if sorted(p.name for p in root.iterdir())!=sorted(names+['MANIFEST.json']): raise ValueError('packet inventory mismatch') for entry in entries: @@ -106,6 +147,7 @@ def verify_inventory(root): if len(pure.parts)!=1 or path.is_symlink() or not path.is_file(): raise ValueError('flat regular packet leaf required') identity(path.read_bytes(),entry) + verify_review_bindings(root) return len(entries) @@ -131,6 +173,8 @@ def main(): verify_inventory(root) print(json.dumps({'passed':True,'packet_leaves':count,'source_count':source_count, 'source_pins_checked':not args.local_only,'scientific_effect':'NONE', + 'review_bindings_checked':True,'review_count':3, + 'remote_review_authenticity_checked':False, 'mathematical_acceptance':False},sort_keys=True)) diff --git a/reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md b/reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md new file mode 100644 index 000000000..2be80e35b --- /dev/null +++ b/reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md @@ -0,0 +1,265 @@ +# External review comments preserved for REGISTER-ALIGNMENT-20260930-v1 + +**Object:** REGISTER-ALIGNMENT-EXTERNAL-REVIEWS-20260930-v1 (component of the alignment record; source of the proposed +graph node `math.align-component.external-issue-reviews`). +**What this is.** The four nonauthor review comments and three owner reconciliation comments on GitHub issues of +`d6g8k5htny-coder/main` that the D2, D3, D4 and D6 rows of `RECONCILIATION.md` §2 cite, read back on 30 September 2026 +through the session's GitHub connector and transcribed here with their identity fields (comment id, URL, posting +account, provider and session named in the body, `created_at`, `updated_at`). The Cursor "Open in Web / Open in Cursor" +HTML footer appended to the four `cursor[bot]` comments is omitted; everything else is reproduced as returned. +**Status of this evidence.** An issue comment is a mutable external object: this file preserves what was read, it does +not make the comment immutable, and an offline check cannot re-authenticate it (the packet checker is stdlib-only and +has no network). What the checker binds is this file's bytes (the SHA256 fingerprint of the node) and the presence of +the quoted verdict lines in it (`VERDICTS`). OpenAI nonauthor review 5360327058 on Math-#167 reports having directly +authenticated comments 5841270276, 5841782206, 5841269490 and 5841783172 against GitHub. The canonical claim manifest +`claims/LANDING_CLAIMS.json` cites the same issues as the review objects of `lifetime-remainder` (main#67), +`side24-coefficient` (main#65), `rn-fixed-remote-window` (main#76) and `p15-full-price` (main#74). No Cursor agent was +contacted or restarted (owner stop of 27 September 2026); only published comments are cited. Same GitHub account +throughout; zero organizational-independence credit. + +## Index + +| # | Object | Issue | Comment | Posted by | Provider / session named | `created_at` | `updated_at` | Verdict line | +|---|---|---|---|---|---|---|---|---| +| 1 | D2 `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md` (blob `247b3ecf`, SHA256 `380b7d0a…`) | main#67 | 5841270276 | `cursor[bot]` | xAI, Grok 4.7 (`grok-4.7-high-fast`), Cursor cloud session `bc-81faa729-b944-48d7-991e-0411ea4e3f90` | 2026-09-25T23:59:05Z | 2026-09-26T00:07:25Z | R1–R3 ACCEPT, R4 ACCEPT for (R12), R5–R6 IMPORTED-OPEN | +| 2 | D2, same blob | main#67 | 5841782206 | `cursor[bot]` | xAI, Grok 4.7, Cursor cloud session `bc-dfbce246-8a04-471f-8d9b-8909a2e4eaa0` | 2026-09-26T01:04:21Z | 2026-09-26T01:07:56Z | "R5 and R6 are **ACCEPT**. Theorem R is accepted at its stated O(1) remainder scope." | +| 3 | D3 `coefficients/side24_v1/PROOF.md` (SHA256 `c06daccc…`, commit `e329fba1`) | main#65 | 5841269490 | `cursor[bot]` | Cursor cloud agent, Grok 4.7 (`grok-4.7-high-fast`), run `bc-be5dc8d9-8a69-4ca9-983b-af79d710c1c1` | 2026-09-25T23:58:59Z | 2026-09-26T00:09:32Z | "All six coefficient interfaces check out. The disposition is **COEFFICIENT-CALC-REVIEWED / PARENT-IMPORTED-OPEN**." | +| 4 | D3 reconciliation | main#65 | 5841779222 | `d6g8k5htny-coder` (owner) | — | 2026-09-26T01:03:54Z | 2026-09-26T01:03:54Z | "Closing #65 as the coefficient-review work package." | +| 5 | D4 `frontiers/remote_window_20260924/PROOF.md` (SHA256 `a332bae9…`, commit `191ea7d5`) | main#76 | 5841783172 | `cursor[bot]` | Cursor cloud session `bc-593a8246-91d3-4d99-90bc-7448dff875dc`; identified as the xAI/Grok review by the owner's reconciliation 5841861362 | 2026-09-26T01:04:29Z | 2026-09-26T01:12:36Z | "This accepts only the fixed-ρ and fixed-η interfaces below. It does not accept a full RN or 24-jet theorem." Items 1–7 ACCEPT | +| 6 | D4 reconciliation | main#76 | 5841861362 | `d6g8k5htny-coder` (owner) | — | 2026-09-26T01:15:52Z | 2026-09-26T01:15:52Z | "returns ACCEPT on all seven fixed-rho/fixed-eta interfaces … Closing #76 as the fixed-remote REVIEW work package only." | +| 7 | D6 reconciliation (the analytic review itself is the in-repo file `reviews/p15_full_price_nonauthor_20260926/REVIEW.md`) | main#74 | 5842112010 | `d6g8k5htny-coder` (owner) | — | 2026-09-26T01:48:31Z | 2026-09-26T01:48:31Z | "D6 ANALYTIC REVIEW COMPLETE … Closing #74 as the D6 review work package" | + +## 1. main#67 comment 5841270276 (D2, xAI review, R1–R6) + +URL: https://github.com/d6g8k5htny-coder/main/issues/67#issuecomment-5841270276 · posted by `cursor[bot]` · created 2026-09-25T23:59:05Z · updated 2026-09-26T00:07:25Z + +`````text +R1, R2, R3, and the cap-loss bound in R4 check. R5 and R6 stay IMPORTED-OPEN: their density and count conclusions still require open #63 interfaces. No counterexample turned up in the new estimates. Nothing here accepts issue #63 or promotes a status. + +**Reviewer.** xAI, Grok 4.7 (`grok-4.7-high-fast`), Cursor cloud session `bc-81faa729-b944-48d7-991e-0411ea4e3f90`. This is not an OpenAI session. Finite tests were not run and are not used as evidence. + +**Sources read.** Successor `LIFETIME-BOUNDED-REMAINDER-20260924-v1`: Math- `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, blob `247b3ecf80bfbe896948d5d489b2d5842a81c481`, 17734 bytes, SHA256 `380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a`. That blob is unchanged from commit `8a13ee977530` through Math- `232a182fee316d2bb428b7351b5c5caae3b8cc2e`, and it is the file at `9b5fb7fa0ce3271afb4168dbada4893a53eaf307`. Parent #63: Drive `1foDgiDi4XIKOfbrZEE8dWKV_BkZU8LIb`, 40261 bytes, SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7`. Cap statement read for the event shape only: Drive `1BnPods7Lf-ECdD34noQihZcEfcqpy7R5`, 15160 bytes. + +## Dependency crosswalk + +| New step | Uses from #63 / cap | Disposition of that import | +|---|---|---| +| R1 coupling | §2 Fourier summability; §3 uniform positive-definiteness of the contact covariance on a fixed band | Read and used. This is not an acceptance of Theorems A–C. | +| R2 determinant lemmas | None beyond symmetric-matrix algebra | No parent probability. | +| R3 densities | §3 joint nonsingularity of `(U_r, A_M)`, target-independent | Same limited import as R1. | +| R4 bound `(R12)` | Parent (6.2), re-derived here; cap event `λ > (4/(3k)) r M_3^2`, `r M_4 ≤ 3k/10` | Integral bound stands on its own. | +| `A_r(1-p_r) ≤ B_r` | Cap global-elder conclusion; parent §8 Morse/Borel | **IMPORTED-OPEN** | +| R5–R6 densities `ν` | §9 Borel marked Kac–Rice; §10 radial ledger; §14 far `O(1)`; `c` named as (15.2) via §15 | **IMPORTED-OPEN** | + +## Verdicts + +**R1 — ACCEPT.** Centered rules meet the contact jet at order `r^2`. The fourth axial row is `f_xxx + (r^2/40) f^{(5)} + O(r^4)`. With `|v_r − v_0| ≤ C k r^2` and `Σ_r − Σ_0 = O(r^2)`, the common regression coupling satisfies `‖F_r − F_0‖_{L^p(C^q)} ≤ C_{p,q} r^2 (1+|b|+k)`. + +**R2 — ACCEPT.** For `K_t = [[α, √t βᵀ], [√t β, A]]`, `det K_t = α det A − t βᵀ adj(A) β` holds on singular `A`. If the indices differ, the affine determinant vanishes in between, so `|F_j(K_r) − F_j(K_0)| ≤ r |βᵀ adj(A) β|`. A direct Lipschitz bound on the `√r` entries would lose a square root; this cancellation keeps the later intensity error `O(r(k+r))`. Endpoint comparison with `diag(±6k, A_0)` then gives `(R10)` and `(R11)`. + +**R3 — ACCEPT.** Along the linear path in covariance and target, `Σ` stays uniformly positive and `|v(θ)|^2` stays coercive in `b^2+k^2`. Differentiating the Gaussian density produces a trace `O(r^2)`, a quadratic `O(r^2 P^2)`, and a target term `O(r^2 k P)`. Integrating `|dπ/dθ|` gives `(R5)` without a small-log restriction. The joint bound `(R13)` is the same uniformly nondegenerate Gaussian density at `(v_r, A)`. + +**R4 — ACCEPT for `(R12)`.** Both soft factors in parent (6.2) were re-derived, including the saddle factor `λ_1 + (3/2) r h`. Depth failure has width `O((r/k) U^2)`. The `λ_1` integral is `(D^3/3) δ^3 U^6 + (E D^2/2) r δ^2 U^5`, and `r δ^2 = k δ^3`. For `m=1`, failure sits in `{λ ≤ 4 D δ T^2} ∪ {λ > 1/(4 D δ)}`; the far piece and the `M_4` piece are fourth-moment Markov bounds, and `δ ≤ 1` turns `δ^4` into `δ^3`. The comparison `A_r(1−p_r) ≤ B_r` stays **IMPORTED-OPEN**. + +**R5 — IMPORTED-OPEN.** Conditional on `(R11)` and the parent intensity `r A_r dr db dk dσ`, the cutoff arithmetic is right. The missing mass `k < a = ℓ/r_0^3` is `O(a^{7/3})`. The two error monomials are `k^{−2/3} r k = ℓ^{1/3}` and `k^{−2/3} r^2 = ℓ^{2/3} k^{−4/3}`; the second, cut at `a`, is `O(ℓ^{1/3})`. Replacing `a` by `0` makes `∫ k^{−4/3} dk` diverge. The split `η = ℓ^{1/6}` makes `δ ≤ ℓ^{1/9}` on `k ≥ η`, and both loss pieces are `O(ℓ^{7/18})` inside the scaled density. Passage from these Gaussian integrals to `ν_cand` and `ν_eld` still requires open §8, §9, and §10. + +**R6 — IMPORTED-OPEN.** Given the `O(1)` density bound on `0 < ℓ ≤ ℓ_*`, `∫_0^t ν = (3/2) c t^{2/3} + O(t)` and the nonselected count is `O(t)`. For `q > −2/3` one also has `q > −1`, so `∫_0^t ℓ^q O(1) dℓ = O(t^{q+1})` and `(R20)` is the correct integration of that bound. The far `O(1)` that puts the unrestricted densities on the whole torus is parent §14 and remains open. The individual threshold `p < 2/3` and the nonselected range `p < 1` match these exponents. +````` + +## 2. main#67 comment 5841782206 (D2, xAI delta review, R5–R6 ACCEPT) + +URL: https://github.com/d6g8k5htny-coder/main/issues/67#issuecomment-5841782206 · posted by `cursor[bot]` · created 2026-09-26T01:04:21Z · updated 2026-09-26T01:07:56Z + +`````text +R5 and R6 are **ACCEPT**. Theorem R is accepted at its stated O(1) remainder scope. The parent imports left open in comment 5841270276 are the five interfaces accepted in #63 comment 5841570965. No successor-specific gap turned up. I did not replay R1–R4 and I did not edit the proof. + +**Reviewer.** xAI, Grok 4.7 (`grok-4.7-high-fast`), Cursor cloud session `bc-dfbce246-8a04-471f-8d9b-8909a2e4eaa0`. This delta uses the arithmetic already recorded in comment 5841270276 (session `bc-81faa729`) and the parent acceptance in comment 5841570965 (session `bc-ce4bf0bc`). Same provider family as those two reviews. This is not an OpenAI session. Finite tests were not run. + +**Immutable D2 source, re-read and hashed.** Math- `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, blob `247b3ecf80bfbe896948d5d489b2d5842a81c481`, 17734 bytes, SHA256 `380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a`. Parent bytes checked against that citation: Math- blob `dfed3b8d318a3ab1950957f393307733a4bef3f2`, 40261 bytes, SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7`. + +## Import mapping + +| Prior open import | Where #63 comment 5841570965 accepts it | What R5/R6 use it for | +|---|---|---| +| `1-p_r ≤ Q^W(G_r^c)`, hence `A_r(1-p_r) ≤ B_r` | D1-A §8, lines 215–217 and 276–296. The cap event is the same pair `λ_min(-A_M) > (4/(3k)) r M_3^2` and `r M_4 ≤ 3k/10`. D1-A concludes `1-p_r ≤ Q^W(G_r^c)` for the embedded small-`r` cylinder, with `0 < Z_r < ∞`. | With D1-C’s `A_r = 12 π_r (Z_r/r^2)` and `B_r = 12 π_r E_Q[(W/r^2) 1_{G_r^c}]`, this is the comparison in successor §5. The quantitative bound on `B_r` remains the already checked `(R12)`. | +| §9 Borel marked Kac–Rice | D1-B, lines 298–308. Intensity equals the full-pin density times `E_Q[W]`; the selected intensity is that quantity times `p_r`. | Passage from the Gaussian integrands to `ν_cand` and `ν_eld`. | +| §10 radial ledger | D1-C, lines 88–94 and 310–335. `r A_r dr db dk dσ` with ordinary sphere area and no role-order `1/2`, and `A_r = 12 π_r (Z_r/r^2)`. | Successor §6. The lifetime Jacobian `r (dr/dℓ) = (1/3) k^{-2/3} ℓ^{-1/3}` turns that measure into `ℓ^{1/3} ν = ∫ A/(3 k^{2/3})`. | +| §14 far `O(1)` | D1-D, lines 386–445, equation (14.1): `0 ≤ ν_eld^far(ℓ) ≤ ν_cand^far(ℓ) ≤ C` for `0 < ℓ ≤ 1`. | Successor §7, added to `(R16)`–`(R18)` to reach `(R1)` on `0 < ℓ ≤ ℓ_*`. | +| `c` as (15.2) | D1-E, lines 447–480. | Successor §1 and §6. `A_0 = 12 π_0 z_0`, so `∫ A_0/(3 k^{2/3}) = 4 ∫ k^{-2/3} π_0 z_0`, which is parent (13.6). D1-E reduces that integral to (15.2). | + +The cutoff arithmetic recorded in comment 5841270276 still stands: missing mass `k < ℓ/r_0^3` is `O(a^{7/3})`; the monomials `k^{-2/3} r k` and `k^{-2/3} r^2` are both `O(ℓ^{1/3})` once the lower cutoff is kept; the split `η = ℓ^{1/6}` makes both pairing-loss pieces `O(ℓ^{7/18})` inside the scaled density. Given the resulting `O(1)` density bound, `∫_0^t ν = (3/2) c t^{2/3} + O(t)`, the nonselected count is `O(t)`, and `(R20)` is the same integration for `q > -2/3`. + +R5 and R6 take the elder comparison and the integral definition of `c`. They do not take the parent’s uniform `C r^3` selection bound (1.1), and they do not take the dominated-convergence route to `p_r → 1`. Successor §1 and §6 already replace that route by `(R11)` and `(R12)`. The §§2–§7 chain is outside this delta. + +## Scope of the acceptance + +Theorem R is the existential statement: some `ℓ_* > 0` and some finite `C` give + +`|ν_cand(ℓ) - c ℓ^{-1/3}| ≤ C`, `0 ≤ ν_cand(ℓ) - ν_eld(ℓ) ≤ C`, and `|ν_eld(ℓ) - c ℓ^{-1/3}| ≤ C` + +for `0 < ℓ ≤ ℓ_*`, with `c` equal to parent (15.2). That includes `(R16)`, `(R18)`, `(R19)`, and `(R20)`. + +A numerical value of `C` or `ℓ_*`, convergence of the bounded remainder, a second coefficient, an RN expected-critical-count estimate, and a 24-jet certificate are outside this verdict. Scientific status of those separate items is unchanged. +````` + +## 3. main#65 comment 5841269490 (D3, xAI coefficient review, C1–C6) + +URL: https://github.com/d6g8k5htny-coder/main/issues/65#issuecomment-5841269490 · posted by `cursor[bot]` · created 2026-09-25T23:58:59Z · updated 2026-09-26T00:09:32Z + +`````text +All six coefficient interfaces check out. The disposition is **COEFFICIENT-CALC-REVIEWED / PARENT-IMPORTED-OPEN**. This is a same-session nonauthor check of the stated expression, and parent issue #63 is still open. + +Provider/model/session: Cursor cloud agent, Grok 4.7 (`grok-4.7-high-fast`), run `bc-be5dc8d9-8a69-4ca9-983b-af79d710c1c1`, https://cursor.com/agents/bc-be5dc8d9-8a69-4ca9-983b-af79d710c1c1. Source exposure: public `Math-` commit `e329fba1e927a12dbb4f0d1556f85f39284d17a9`, directory `coefficients/side24_v1/`; parent Drive proof `UNIFORM_MATRIX_CAP_AND_LIFETIME.md` (40,261 bytes, SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7`) only to transcribe (15.2) and recheck its scalar integral; NIST DLMF 5.11; issue #63’s displayed formula. No Vault99 reading, no source edits, no child agents. Local interpreter: CPython 3.12.3. + +## Interfaces + +| Interface | Result | +|---|---| +| C1 negative-cone moment \(D_1=4/3\) | **VERIFIED** | +| C2 \(D_2=29/6-\sqrt{6}\), negative-definite cone retained | **VERIFIED** | +| C3 angular / all-direction reduction | **VERIFIED** | +| C4 SIDE24 image / periodization bound | **VERIFIED** | +| C5 covariance / Schur transfer | **VERIFIED** | +| C6 outward Gamma / Stirling arithmetic | **VERIFIED** | + +**C1.** For the reference \(K_\infty(z)=\exp(-|z|^2/2)\), \(\mathrm{Cov}(H_{ij},H_{kl})=\delta_{ij}\delta_{kl}+\delta_{ik}\delta_{jl}+\delta_{il}\delta_{jk}\) and \(\mathrm{Cov}(V)=\mathrm{diag}(3,1,\ldots,1)\). Conditioning the transverse entry on \(V=0\) gives variance \(8/3\). The \(1\times1\) negative cone is \(A<0\), and \(A^2\) is even, so \(D_1=\tfrac12\cdot\tfrac83=\tfrac43\). + +**C2.** For \(m=2\), \(A=\begin{pmatrix}s+x&y\\y&s-x\end{pmatrix}\) with independent \(s,x,y\), \(\mathrm{Var}(s)=5/3\), \(\mathrm{Var}(x)=\mathrm{Var}(y)=1\). Both eigenvalues are negative exactly on \(s<-R\), \(R=\sqrt{x^2+y^2}\). With \(R^2\) of density \(e^{-z/2}/2\), +\[ +\int_0^a(a-z)^2 e^{-z/2}\,dz/2=a^2-4a+8-8e^{-a/2}. +\] +Symmetry then gives +\[ +D_2=\tfrac12\bigl(\tfrac{25}3-\tfrac{20}3+8-8\sqrt{3/8}\bigr)=\tfrac{29}6-\sqrt6, +\] +using \(E[s^4]=25/3\) and \(E[e^{-s^2/2}]=\sqrt{3/8}\). The identity \(4\sqrt{3/8}=\sqrt6\) is the square check \(16\cdot(3/8)=6\). Half the untruncated determinant-square moment is exactly \(29/6\); the cone cutoff is the \(-\sqrt6\) term. + +**C3.** Parent (15.2) is +\[ +c_{d,L}=\frac{\Gamma(7/6)}{24^{1/3}\sqrt\pi}\int_{S^{d-1}}p_G(0)\,p_{V_u}(0)\,\tau_u^{4/3}D_u\,d\sigma(u). +\] +The scalar identity was recomputed from the parent’s intermediate factors: \(4\cdot(6\kappa)^2=144\) and \(k^{-2/3}\cdot k^2=k^{4/3}\), then +\[ +144\int_0^\infty k^{4/3}\varphi_\tau(12k)\,dk=\Gamma(7/6)\,\tau^{4/3}/(24^{1/3}\sqrt\pi). +\] +For the isotropic reference, \(\tau^2=6\), \(p_G(0)p_V(0)=(2\pi)^{-d}/\sqrt3\), and \(|S^1|=2\pi\), \(|S^2|=4\pi\). Those areas equal \(2^{d-1}\pi\) for \(d=2,3\), and \(6^{2/3}/24^{1/3}=(3/2)^{1/3}\), which is formula (1). The same multiplicative bound holds in every orthonormal frame, so the sphere integral keeps it. + +**C4.** Coordinate partials of \(\varphi(x)=\exp(-|x|^2/2)\) factor as Hermite products. For every multi-index of order at most 6 and every \(|y|\ge24\), +\[ +\prod_i|He_{\alpha_i}(y_i)|\le76\,|y|^6. +\] +The check covered all 84 multi-indices in \(d\le3\); the worst ratio to \(76\cdot24^6\) is about \(0.0135\), on the pure sixth derivative. At the origin the same partials are at most 15. The lattice estimate +\[ +\sum_{n\neq0}|n|^6 e^{-288|n|^2}\le1458\,e^{-288} +\] +holds, and the degree-20 Taylor sum for \(e^{288/125}\) is greater than 10, so \(e^{-288}<10^{-125}\). Therefore +\[ +E=1458(76\cdot24^6+15)\cdot10^{-125}=21175738586478\cdot10^{-125}, +\] +and \(60E<10^{-108}\). + +**C5.** Entrywise differences are at most \(2E\) after the \(\sqrt2\) duplication on off-diagonal Hessian coordinates. In dimension at most 10 the spectral norm is at most \(20E\). The reference odd block \(\begin{pmatrix}1&-3\\-3&15\end{pmatrix}\) shifted by \(I/3\) has leading minor \(2/3\) and determinant \(7/9\), and \((23/3)^2-58=7/9>0\), so its smaller eigenvalue exceeds \(1/3\). Hessian eigenvalues are \(2\) and \(d+2\). Thus \(C_{\mathrm{ref}}\ge I/3\) and \((1-\varepsilon)C_{\mathrm{ref}}\le C_{24}\le(1+\varepsilon)C_{\mathrm{ref}}\) at \(\varepsilon=10^{-108}\). Schur complements are infima of the quadratic form, so the sandwich passes to \(\tau^2\) and to \(A\mid V=0\). The Gaussian density comparison and the degree-\(2m\) cone scaling then give integrand powers \(a=m+2/3+n/2\), \(b=d+n/2\). For \(d=3\), \(a+2b=79/6<14\) and \(2a+b=77/6<13\), and \(32\varepsilon<10^{-106}\). + +**C6.** Bernoulli numbers \(B_2,\ldots,B_{22}\) match the \(B_1=-1/2\) recurrence, including \(B_{22}=854513/138>0\). DLMF 5.11(ii) puts the positive-real remainder after the \(B_{20}\) term between 0 and the first omitted \(B_{22}\) term; the code encloses that way, then removes 32 logarithms from \(z=199/6\) by DLMF 5.5(i). An independent Stirling shift by 48, with a separate Machin/atan log/exp implementation, landed inside the package interval for \(\Gamma(7/6)\), width about \(1.4\cdot10^{-31}\), midpoint \(0.9277193336300392\). The \(10^{-106}\) allowance is applied to an already valid enclosure of \(c_{d,\mathrm{ref}}\). Author tests: `python3 -m unittest test_coefficient.py` in that directory, **30 runs, 0 failures**. The 20-digit outward endpoints are the published ones: +\[ +0.073406919306034271030`, because the conditional law of the transverse Hessian has full support on an open negative-definite ball. Remote conditioning changes the law inside the numerator expectation and leaves this denominator in place. The height split uses Lebesgue `dt` on the window. The factor `12` that appears in the unconditional pin intensity is absent from this conditional count. + +4. **Contact kernel and `O(k r^4 |E|)` remainder — ACCEPT.** `Λ_j` in (13) is continuous on the stated compact sets, finite, and bounded above and below by positive constants. Positivity uses the joint conditional support of `(A_0,H_x)` and keeps their dependence inside the expectation. The density error is `O(r^2)` and the endpoint-weight error is `O(r)`, so the Kac–Rice integrand differs from `Λ_j` by `O(r)`. Integration over a window of length `k r^3` gives the `O(k r^4 |E|)` count remainder, which is (2). The matching lower bound is for the expectation on a fixed positive-volume set. Markov is applied only from that expectation to the probability upper bound. + +5. **Fixed-separation factorial moments — ACCEPT.** For each fixed `m≥2` and `η>0`, one endpoint weight and one normalizer are used. There are `m+2` determinant factors. The ordered mean is `(k r^3)^m C_m+O(r^{3m+1})`, with a joint contact kernel. Each unordered `η`-separated `m`-set contributes `m!` ordered tuples, so its probability is at most `E[T]/m! = O(r^{3m})`. A separated pair is `O(r^6)`. + +6. **Selector and height-window mapping — ACCEPT for the implication in §7 only.** A `0/1` selector is dominated by `N_{r,j}(E)` when its type, location, and value conditions imply (1): index `j`, location in a Borel subset of the fixed `D_ρ`, and height strictly between the pinned heights. Boundary heights have expected count zero. No historical RN witness predicate, inner-wedge cell, whitened-jet cell, or all-cell partition is shown to imply (1). Those objects stay outside this acceptance. Ambient Lebesgue measure `dx` is the coordinate system of (14); a polar or scaled chart has to carry its own Jacobian. + +7. **Uncovered complement — ACCEPT as stated in §7.** The regions that remain open are exactly the ones listed in the crosswalk below. `ρ` and `η` stay fixed. + +## Region crosswalk + +| Region | This note | +|---|---| +| Fixed `D_ρ`, height in `(b-k r^3,b)`, index `j` | Theorem A and numerator (14) | +| Fixed `η>0`, ordered `m`-tuples of index `j` in that window | (15); probability ≤ `E[T]/m!` | +| Mesoscopic neighborhood `x=ry` | Open. Distance to the pins tends to zero | +| Pin collision, witness within `O(r)` of `M` or `S` | Open. Same distance restriction | +| Intermediate annulus, a multiple of `r` out to a shrinking cutoff, including `r≪\|x‖≪ρ` | Open. Compactness constants are not claimed there | +| Witness collision, mutual separation tending to zero | Open. (15) stops at fixed `η` | +| Remote critical points with no shrinking height window | Open. The factor `r^3` is the window length | +| Legacy all-cell, 24-jet, `ENV-RESCOV` through `CH-LIFT`, fixed-`r` inner wedge | Open. §7 requires a separate proof that the legacy selector implies (1). `STATUS_RN_UNIF` still records those carriers as absent | +| Probability lower bound, Poisson law, numerical `C` or `r_*`, elder selection | Not conclusions of this argument | + +## Checks and one citation correction + +I recomputed the pin Jacobian, the target `v_r`, the axial coefficient `r^2/40` on `s^5`, and the Hermite values `α_M=-6k`, `α_S=6k`, `f_xxx=12k`. The local exact suite, 28 tests, passed under Python 3. Those tests check finite algebra. They do not evaluate `Λ_j`. + +The operative Kac–Rice input is Theorem 6.1, Remark 8, and §7.1 of arXiv:2304.07424v3: the weight may depend on an extra field, the critical-point Jacobian is `|det Hess|` once, and the height split is the joint density in `dt`. In that HTML, Theorem 7.1 is the i.i.d. sum model, and the critical-point discussion is §7.1 rather than §8.1. The formula in (12) matches Theorem 6.1 and §7.1. A later bibliographic edit can retarget the sentence in §8; that mismatch is not a false step in the count. +````` + +## 6. main#76 comment 5841861362 (D4, owner reconciliation) + +URL: https://github.com/d6g8k5htny-coder/main/issues/76#issuecomment-5841861362 · posted by `d6g8k5htny-coder` (owner) · created 2026-09-26T01:15:52Z · updated 2026-09-26T01:15:52Z + +`````text +D4 REVIEW DELIVERY RECONCILED. The complete proof is in Math at `frontiers/remote_window_20260924/PROOF.md`, and the fresh xAI/Grok review on this issue returns ACCEPT on all seven fixed-rho/fixed-eta interfaces: conditioned covariance, all three determinant factors and O(k r^5) numerator, original endpoint normalizer, contact-kernel remainder, fixed-separation factorial moments, selector/window mapping, and the explicit uncovered complement. Closing #76 as the fixed-remote REVIEW work package only. This does not shrink rho or eta and does not close mesoscopic, pin, intermediate, or shrinking witness-collision regions. +````` + +## 7. main#74 comment 5842112010 (D6, owner reconciliation of the in-repo review) + +URL: https://github.com/d6g8k5htny-coder/main/issues/74#issuecomment-5842112010 · posted by `d6g8k5htny-coder` (owner) · created 2026-09-26T01:48:31Z · updated 2026-09-26T01:48:31Z + +`````text +D6 ANALYTIC REVIEW COMPLETE. The full proof is in Math at `frontiers/full_price_20260924/PROOF.md`, and merged Math PR63 records a cross-provider nonauthor ACCEPT on all six requested slices: hazard/separate concavity, odd-majority worst case, global independence/hazard direction, realized-family cover, sharpness, and demand-one boundary. Exact accepted scope is the realized disjoint capacity/clutter family with d_i>=2, every independent probability, prices c_v<=phi(p_v), same palette K>=K_H(d), and rho*=1/(3-log(3e-2)). The p=1 strictness sentence is corrected to interior 1/2=rho and between-pin height" + }, + "proposed": { + "classification": "PROVED_REVIEWED", + "controlling": false, + "fingerprint": "dist>=rho and between-pin height", + "source": null, + "scope": "the fixed-remote region at the D4 scope: dist >= rho from the pins, between-pin height window", + "explicit_limits": "as the covering node", + "review_disposition": "ACCEPT", + "review_sources": [ + { + "ref": "main#76 comment 5841783172", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "covering theorem accepted at this exact region scope; region crosswalk table" + } + ], + "coverage_source": "math.rn-fixed-remote-window", + "notes": "PROVED_REVIEWED region: covered by math.rn-fixed-remote-window (required covered_by edge; coverage_source retained). Register alignment v1.3." + }, + "required_premises_after": [ + "math.rn-fixed-remote-window" + ], + "notes": "Covered by a PROVED_REVIEWED node after the previous transition; coverage_source retained and a required covered_by edge added so that a change to the covering proof reaches the region (Codex 4139807558; OpenAI 5360327058 item 1). The current hard gate reports PROVED_REVIEWED regions in its own proved_reviewed_regions bucket since ec6db8c (Math-#151), so the earlier region-reporting complaint (Codex 4139807545) is superseded." + }, + { + "node": "math.rn-fixed-annulus-window", + "kind": "candidate", + "current": { + "classification": "AUTHOR_SIDE_CANDIDATE", + "fingerprint": "081abc13c5e66342c13df2af2bd6b114f320486f" + }, + "proposed": { + "classification": "PROVED_REVIEWED", + "controlling": false, + "fingerprint": "1fd9fe7141e464fd1c09ebf0318d8a701729c9c61ea24f73f7e20a9cf10c552b", + "source": "frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md", + "scope": "d = 2; fixed L; fixed scaled annulus 1 < A0 <= |y| <= B0 < infinity; compact positive gaps k_- > 0; all frames; between-pin height window (live node scope)", + "explicit_limits": "no global D5/RN/JETMOD, k -> 0, d >= 3, pin-neighborhood, intermediate-scale, collision, or elder-selection closure; excludes PR28 and later blobs", + "review_disposition": "ACCEPT", + "review_sources": [ + { + "ref": "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "ACCEPT at the exact scoped theorem (covariance floor, cutoff r^(1/24), rare target density, conditioned C^3 sixth moment, ...)", + "binds": "commit 2804dc1, blob 081abc13, SHA256 1fd9fe71" + } + ], + "notes": "PROVED_REVIEWED at the fixed d = 2 scaled-annulus window scope; see explicit_limits. Evidence: pr22 review record; consumed S6-S21 stitching input with its review. Single nonauthor provider. Register alignment v1.3." + }, + "required_premises_after": [ + "math.rn-count-interface", + "math.align-component.pr22-annulus-review", + "math.align-component.two-scale-addendum" + ], + "notes": "Fingerprint kind changes from git blob 081abc13 (current) to SHA256, matching the other component nodes; same bytes. Single nonauthor provider. Its consumed S6-S21 stitching input (TWO_SCALE_ADDENDUM.md) and that input's review are component nodes since v1.3 (Codex 4139807567; OpenAI 5360327058 item 2)." + }, + { + "node": "math.rn-region.fixed-annulus-window", + "kind": "region", + "current": { + "classification": "COVERED_BY_CANDIDATE", + "fingerprint": "fixed-d2-annulus-between-pin-window-reviewed" + }, + "proposed": { + "classification": "PROVED_REVIEWED", + "controlling": false, + "fingerprint": "fixed-d2-annulus-between-pin-window-reviewed", + "source": null, + "scope": "the fixed d = 2 scaled annulus at the covering node's exact declared scope", + "explicit_limits": "as the covering node", + "review_disposition": "ACCEPT", + "review_sources": [ + { + "ref": "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "covering theorem accepted at this exact scope" + } + ], + "coverage_source": "math.rn-fixed-annulus-window", + "notes": "PROVED_REVIEWED region: covered by math.rn-fixed-annulus-window (required covered_by edge; coverage_source retained). Register alignment v1.3." + }, + "required_premises_after": [ + "math.rn-fixed-annulus-window" + ], + "notes": "Covered by a PROVED_REVIEWED node after the previous transition; coverage_source retained and a required covered_by edge added (as for the fixed-remote region)." + }, + { + "node": "math.p15-full-price", + "kind": "candidate", + "current": { + "classification": "AUTHOR_SIDE_CANDIDATE", + "fingerprint": "full-price-20260924" + }, + "proposed": { + "classification": "PROVED_REVIEWED", + "controlling": false, + "fingerprint": "87521901ca8e5405b4d1e47f1deb1cd0326affbd6f5967b53c4178590da993f9", + "source": "frontiers/full_price_20260924/PROOF.md", + "scope": "realized disjoint capacity/clutter family with d_i >= 2, all independent probabilities, c_v <= phi(p_v), same palette K >= K_H(d), sharp rho* = 1/(3 - log(3e-2)) (STATUS D6 row)", + "explicit_limits": "demand one remains an obstruction; no arbitrary-downset or unrestricted prize-problem extension", + "review_disposition": "ACCEPT", + "review_sources": [ + { + "ref": "reviews/p15_full_price_nonauthor_20260926/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor (Math- issue 57, merged Math-#63)", + "verdict": "ACCEPT on all six slices", + "binds": "blob 582180e4, SHA256 87521901" + }, + { + "ref": "main#74 comment 5842112010", + "provider": "owner", + "verdict": "D6 analytic review complete; #74 closed as the D6 review work package" + } + ], + "notes": "PROVED_REVIEWED on the realized family with d_i >= 2; see explicit_limits. Evidence: p15 review record, consumed setwise interfaces of P15_REALIZED_COVERS.md, main#74 reconciliation (external record node). Single nonauthor provider. Register alignment v1.3." + }, + "required_premises_after": [ + "math.align-component.external-issue-reviews", + "math.align-component.p15-review", + "math.align-component.p15-realized-covers-setwise" + ], + "notes": "Fingerprint changes from the label full-price-20260924 to SHA256; the live note 'review open' is stale against the merged review record. Single nonauthor provider. The consumed setwise interfaces (P1), (P2), Theorem P2 of P15_REALIZED_COVERS.md are a component node since v1.3, at the D6 review's scope only." + } + ], + "execution_order": [ + "0. create the component nodes and edges of proposed_graph_nodes / proposed_graph_edges (review records, consumed sources, covered_by, the interface's two live premises); they are evidence records and change no classification of an existing node", + "1. math.rn-count-interface -> PROVED_REVIEWED (premise of 4 and 6)", + "2. math.lifetime-remainder and math.side24-coefficient -> PROVED_REVIEWED (premise D1 is live PROVED_REVIEWED)", + "3. Math-#151 is on main (ec6db8c): the D4 bytes are carried by two live nodes (math.rn-fixed-remote-window AUTHOR_SIDE_CANDIDATE; math.d5-component.remote-window-proof PROVED_REVIEWED; same fingerprint, same main#76 review); execute math.rn-fixed-remote-window -> PROVED_REVIEWED, then math.rn-region.fixed-remote; collapsing the component node onto the live node is an optional one-edge follow-up", + "4. math.rn-fixed-annulus-window -> PROVED_REVIEWED (fingerprint to SHA256), then math.rn-region.fixed-annulus-window", + "5. math.p15-full-price -> PROVED_REVIEWED (fingerprint to SHA256)", + "6. regenerate the hard gate's manifest/results per frontiers/downstream_gate_20260925/README.md; run git_transition_audit base->head; expect promotion_permission false and no controlling node", + "executing lane: non-Claude; this record executes nothing; a lane that wants a second provider on the single-provider rows (D2, D4, D5-annulus, D6) asks for it before step 2-5" + ], + "not_proposed": [ + "math.rn-region.mesoscopic-scaled-annulus, pin-collision, intermediate-r-to-rho: Math-#151 (D5 fold)", + "math.rn-region.witness-collision and its residual: Math-#160", + "math.rn-mesoscopic-reduction (legacy PR7 route), eng.* controls, hist.* predicates: unchanged", + "any controlling flag, STATUS, PROOF_INDEX, SELECTOR_REGION or catalog edit" + ], + "independence_caveat": "All cited nonauthor reviews except D3's second read and the interface review are xAI/Grok via Cursor cloud sessions on the shared account; no organizational independence. The D1 precedent for PROVED_REVIEWED used xAI plus Anthropic reads. No Cursor agent is restarted or contacted (owner stop 2026-09-27); only published comments are cited.", + "declarative": true, + "executed": false, + "review_record": [ + { + "lane": "xAI", + "id": 5901912476, + "kind": "inventory read", + "at": "670e4ae", + "verdict": "ACCEPT as declarative inventory; HOLD execution until Math-#151 Cut A is on current tip; execute #151 first, then this alignment", + "hold_precondition_math_151": "satisfied: Math-#151 merged at ec6db8c (2026-09-30T00:56:58Z)" + }, + { + "lane": "xAI/Grok (Lucas)", + "id": 5360240245, + "kind": "review", + "at": "670e4ae", + "verdict": "ACCEPT at classification-lag scope; HOLD execution until #151 on main and single-provider rows recorded as such; interface flip conditional on this packet's Anthropic note, not an xAI re-read", + "hold_precondition_math_151": "satisfied: Math-#151 merged at ec6db8c (2026-09-30T00:56:58Z)" + }, + { + "lane": "OpenAI/ChatGPT", + "id": 5360320845, + "kind": "source-custody and RN-interface review", + "at": "f2250bf", + "verdict": "historical lag and logical-interface inequalities sound at stated scopes; AMEND REQUIRED before the proposal is represented as a complete executable evidence-bound fold: (1) review bytes not carried by the graph, production read_snapshot reads node.source only; (2) N4/N5 checks are floating, relabel; (3) the interface is not a quantitative rate; N6 may be recorded via the canonical-kernel interface", + "answered_by": "v1.3: review records and consumed sources as fingerprinted component nodes with required edges; external comments preserved in EXTERNAL_REVIEWS.md and labelled mutable; PROPAGATION two-commit cases; INTERFACE exact/numerical labels; interface scope narrowed with its premises as edges" + }, + { + "lane": "OpenAI/Codex (delegated)", + "id": 5360327058, + "kind": "engineering/interface review", + "at": "f2250bf", + "verdict": "ACCEPT the bounded historical inventory; AMEND the executable proposal; HOLD execution: (1) covering-proof loss does not reach the promoted regions; (2) TWO_SCALE_ADDENDUM, P15_REALIZED_COVERS, the interface's consumed C6-Palm/cap items are not tracked; (3) apply() drops explicit_limits and keeps stale notes; region-reporting complaint superseded on main; D2/D3/D4 comments directly authenticated", + "answered_by": "v1.3: covered_by edges; consumed-source component nodes; interface premises as edges to the live D1 node and cap component (Lemma 5.1 cited, not consumed); apply() carries explicit_limits, replacement notes and review_basis; PROPAGATION regressions; the superseded complaint recorded, not replayed" + }, + { + "lane": "OpenAI/Codex (bot review 5360253242)", + "id": "4139807545/4139807551/4139807558/4139807562/4139807567", + "kind": "review threads", + "at": "670e4ae", + "verdict": "region reporting (superseded on main); stale notes on apply; region-to-covering-proof dependency; authenticate external verdicts; track consumed source dependencies", + "answered_by": "v1.3 (all five); 4139807545 by Math-#151's hard_gate.py proved_reviewed_regions bucket, recorded in the region transition notes" + } + ], + "revision": { + "version": "v1.3", + "applies": [ + "xAI 5901912476 and 5360240245 recorded; #151-first ordering of the D4 flips made explicit", + "re-verified at ec6db8c (Math-#151 merged); live D4 duplicate bound (D4_DUPLICATE check, duplicate-drift mutant); HOLD precondition on Math-#151 recorded as met", + "OpenAI 5360320845 and 5360327058 and Codex threads 4139807545-67: eight review-record / consumed-source component nodes and sixteen required edges (edges_unchanged false); covered_by edges from regions; interface premises as edges to the live D1 node and cap component and its scope narrowed; apply() carries explicit_limits, replacement notes, review_basis; PROPAGATION check with nine two-commit cases and mutants region-unlinked / review-metadata-only; INTERFACE exact versus numerical labels; RN_COUNT_INTERFACE_REVIEW.md evidence labels; EXTERNAL_REVIEWS.md preserved and labelled mutable" + ], + "unchanged": "the eight classifications and every scope exclusion; the ten original inventory identities" + }, + "reverified_at": "ec6db8c (Math- main after Math-#151 merged 2026-09-30T00:56:58Z; the ten inventoried sources and the eight live nodes unchanged; math.d5-component.remote-window-proof live as PROVED_REVIEWED with fingerprint a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7 beside math.rn-fixed-remote-window at AUTHOR_SIDE_CANDIDATE)", + "live_duplicate": { + "node": "math.d5-component.remote-window-proof", + "since": "ec6db8c (Math-#151)", + "classification": "PROVED_REVIEWED", + "controlling": false, + "fingerprint": "a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7", + "source": "frontiers/remote_window_20260924/PROOF.md", + "component_of": "math.d5-pin-neighborhood-first-moment", + "review_basis": "STATUS D4 (main#76, external), nonauthor, ACCEPT, full", + "relation_to_this_record": "same bytes and same review as the math.rn-fixed-remote-window transition; the flip aligns the older node with it; collapsing the pair is a one-edge follow-up for the executing lane, not proposed here", + "check": "D4_DUPLICATE; mutant duplicate-drift" + }, + "proposed_graph_nodes": [ + { + "id": "math.align-component.rn-interface-review", + "layer": "D4", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.rn-count-interface", + "component_role": "review_record", + "author_provider": "Anthropic (nonauthor; session 017Mi3hx)", + "fingerprint": "52d9038a3f27335d3c219babec785984e00b77f28d7cd7b390477c0bc6a749d1", + "source": "reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md", + "scope": "ACCEPT at the logical-interface scope: (N1)-(N5) and the section 3 counterexamples self-contained; (N6)-(N7) and section 5 as formula-level implications conditional on the parent regression law / section 9 convention and the cap support source", + "review_basis": [ + { + "review": "reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md", + "provider": "Anthropic", + "verdict": "ACCEPT at the logical-interface scope", + "depth": "full at that scope; exact rational checks plus labelled floating-point corroborations in alignment_check.py" + } + ], + "notes": "This packet's own review record; a nonauthor read by a second provider was not available at v1.3 (xAI 5360240245 did not re-read the note)." + }, + { + "id": "math.align-component.external-issue-reviews", + "layer": "D2", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": null, + "components_of": [ + "math.lifetime-remainder", + "math.side24-coefficient", + "math.rn-fixed-remote-window", + "math.p15-full-price" + ], + "component_role": "review_record_external", + "author_provider": "xAI/Grok 4.7 via Cursor (posted by cursor[bot]) and owner reconciliations; transcribed by Anthropic from the GitHub API read-back of 2026-09-30", + "fingerprint": "fa6677f16f688352f3fc9b1703d39324fe57a3b2bf61960591f524f858e99c9d", + "source": "reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md", + "scope": "seven main-repository issue comments: main#67 5841270276 and 5841782206 (D2), main#65 5841269490 and 5841779222 (D3), main#76 5841783172 and 5841861362 (D4), main#74 5842112010 (D6), with comment id, URL, posting account, created_at, updated_at and body", + "review_basis": [ + { + "review": "main#67 comment 5841270276", + "provider": "xAI/Grok 4.7 via Cursor (session bc-81faa729)", + "verdict": "R1-R3 ACCEPT, R4 ACCEPT for (R12), R5-R6 IMPORTED-OPEN", + "created_at": "2026-09-25T23:59:05Z", + "updated_at": "2026-09-26T00:07:25Z" + }, + { + "review": "main#67 comment 5841782206", + "provider": "xAI/Grok 4.7 via Cursor (session bc-dfbce246)", + "verdict": "R5 and R6 ACCEPT; Theorem R accepted at its stated O(1) remainder scope", + "created_at": "2026-09-26T01:04:21Z", + "updated_at": "2026-09-26T01:07:56Z" + }, + { + "review": "main#65 comment 5841269490", + "provider": "xAI/Grok 4.7 via Cursor (run bc-be5dc8d9)", + "verdict": "C1-C6 VERIFIED; COEFFICIENT-CALC-REVIEWED / PARENT-IMPORTED-OPEN", + "created_at": "2026-09-25T23:58:59Z", + "updated_at": "2026-09-26T00:09:32Z" + }, + { + "review": "main#65 comment 5841779222", + "provider": "owner", + "verdict": "reconciliation; #65 closed as the coefficient-review work package", + "created_at": "2026-09-26T01:03:54Z" + }, + { + "review": "main#76 comment 5841783172", + "provider": "xAI/Grok via Cursor (session bc-593a8246; provider named by the owner's reconciliation)", + "verdict": "items 1-7 ACCEPT at fixed-rho/fixed-eta scope; not a full RN or 24-jet theorem", + "created_at": "2026-09-26T01:04:29Z", + "updated_at": "2026-09-26T01:12:36Z" + }, + { + "review": "main#76 comment 5841861362", + "provider": "owner", + "verdict": "reconciliation; ACCEPT on all seven interfaces; #76 closed as the fixed-remote REVIEW work package only", + "created_at": "2026-09-26T01:15:52Z" + }, + { + "review": "main#74 comment 5842112010", + "provider": "owner", + "verdict": "D6 ANALYTIC REVIEW COMPLETE; cross-provider nonauthor ACCEPT on all six slices (the review itself is reviews/p15_full_price_nonauthor_20260926/REVIEW.md); #74 closed", + "created_at": "2026-09-26T01:48:31Z" + } + ], + "authentication": "mutable external evidence, read back through the session's GitHub connector and transcribed; not byte-authenticated offline (stdlib checker, no network); OpenAI 5360327058 reports direct authentication of 5841270276, 5841782206, 5841269490 and 5841783172; claims/LANDING_CLAIMS.json cites the same issues as review objects", + "notes": "One node for one byte object (this file); loss-only: any edit to the record revalidates D2, D3, D4 and D6." + }, + { + "id": "math.align-component.side24-review-claude", + "layer": "D3", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.side24-coefficient", + "component_role": "review_record", + "author_provider": "Anthropic (session 01NMeKE)", + "fingerprint": "258c414c46be93142ee552cfa4c32c03dd89b6bf7b0b470334f152e1e0a57eef", + "source": "reviews/side24_v1_coefficient_claude_20260929/REVIEW.md", + "scope": "second-provider read of coefficients/side24_v1/PROOF.md: ACCEPT at the arithmetic-enclosure scope", + "review_basis": [ + { + "review": "reviews/side24_v1_coefficient_claude_20260929/REVIEW.md", + "provider": "Anthropic", + "verdict": "ACCEPT at the arithmetic-enclosure scope", + "depth": "full at that scope" + } + ], + "notes": "Makes D3 the two-provider row (with main#65 5841269490)." + }, + { + "id": "math.align-component.pr22-annulus-review", + "layer": "D5", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.rn-fixed-annulus-window", + "component_role": "review_record", + "author_provider": "xAI/Grok 4.7 via Cursor", + "fingerprint": "29a0c6d00ce739baf1d29a3163977d8e707e2079e216fba4fee3669cebec127d", + "source": "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md", + "scope": "ACCEPT of FIXED_ANNULUS_CANDIDATE.md (blob 081abc13, SHA256 1fd9fe71) at the exact scoped theorem: covariance floor, cutoff r^{1/24}, rare target, conditioned C^3 sixth moment, inner two-scale stitching; PR28 and later blobs excluded", + "review_basis": [ + { + "review": "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "ACCEPT at the exact scoped theorem", + "depth": "full" + } + ], + "notes": "Single nonauthor provider." + }, + { + "id": "math.align-component.two-scale-addendum", + "layer": "D5", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.rn-fixed-annulus-window", + "component_role": "consumed_proof", + "author_provider": "OpenAI", + "fingerprint": "079f9399aef401d58749b3684f3acbb7f49ffdcbcac9f501b79e06c28a7f4e7d", + "source": "frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md", + "scope": "S6-S21 and (S3)-(S5): the inner two-scale stitching input (S4) consumed by FIXED_ANNULUS_CANDIDATE.md for |t| < h_r on A <= |u| <= B (claims/LANDING_CLAIMS.json dependency two-scale-s6-s21)", + "review_basis": [ + { + "review": "reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "ACCEPT S6-S21 and (S3)-(S5) at blob 89cae3a9", + "depth": "full" + }, + { + "review": "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "inner two-scale stitching ACCEPT; the addendum read as the imported inner bound, not re-derived", + "depth": "gluing step" + } + ], + "notes": "The addendum's own review record is the next node; the addendum requires it." + }, + { + "id": "math.align-component.two-scale-review", + "layer": "D5", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.align-component.two-scale-addendum", + "component_role": "review_record", + "author_provider": "xAI/Grok 4.7 via Cursor (session bc-ff620630)", + "fingerprint": "04cf4c986f29ac7ac33b3cc87feac23f3cf494e0c1b3bf4476e4e6666de46574", + "source": "reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md", + "scope": "ACCEPT of TWO_SCALE_ADDENDUM.md S6-S21 and (S3)-(S5) at blob 89cae3a9 (Math- PR34, commit bc7d7545)", + "review_basis": [ + { + "review": "reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "ACCEPT", + "depth": "full" + } + ], + "notes": "Single nonauthor provider." + }, + { + "id": "math.align-component.p15-review", + "layer": "D6", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.p15-full-price", + "component_role": "review_record", + "author_provider": "xAI/Grok 4.7 via Cursor (Math- issue 57 lane)", + "fingerprint": "691ea0db5c0f073326c9f7208c9804c6f5d0daf92ba7467529c9d57e08b15eb7", + "source": "reviews/p15_full_price_nonauthor_20260926/REVIEW.md", + "scope": "ACCEPT of Theorem F on the realized disjoint capacity/clutter family (six slices) at blob 582180e4, SHA256 87521901; checked the setwise (P1), (P2), Theorem P2 dependency of P15_REALIZED_COVERS.md", + "review_basis": [ + { + "review": "reviews/p15_full_price_nonauthor_20260926/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "ACCEPT Theorem F on the realized family", + "depth": "full" + } + ], + "notes": "Single nonauthor provider; owner reconciliation main#74 5842112010 is in the external record." + }, + { + "id": "math.align-component.p15-realized-covers-setwise", + "layer": "D6", + "kind": "reading_rule_component", + "classification": "PROVED_REVIEWED", + "controlling": false, + "component_of": "math.p15-full-price", + "component_role": "consumed_interface", + "author_provider": "OpenAI", + "fingerprint": "c0dbb821fb57b685a20cc321e4074456f39a9697f3104afd1f728e4732179bb9", + "source": "frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md", + "scope": "setwise interfaces only: realized-family definition (P1), actual local restrictions (P2) and Theorem P2 full-block cover at K >= K_H(d), as consumed by Theorem F with d_i >= 2 (claims/LANDING_CLAIMS.json dependency p15-realized-covers:setwise-interfaces); the note's c_v <= p_v price theorem and any broader P15 statement are not included", + "review_basis": [ + { + "review": "reviews/p15_full_price_nonauthor_20260926/REVIEW.md", + "provider": "xAI/Grok 4.7 via Cursor", + "verdict": "read as the cited setwise dependency and checked for the local restriction and the full-block cover; the c_v <= p_v price theorem not accepted", + "depth": "setwise interfaces" + } + ], + "notes": "The realized-covers claim itself stays HOLD_WITH_DOMAIN in the claim manifest; only the consumed setwise interfaces are represented here, at the D6 review's scope." + } + ], + "proposed_graph_edges": [ + { + "from": "math.rn-count-interface", + "to": "math.align-component.rn-interface-review", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.rn-count-interface", + "to": "math.uniform-matrix-cap-lifetime", + "required": true, + "relation": "uses_parent_regression_law_and_section9_convention" + }, + { + "from": "math.rn-count-interface", + "to": "math.d1-component.marked-cylinder-cap", + "required": true, + "relation": "consumes_cap_support_scope_section5" + }, + { + "from": "math.lifetime-remainder", + "to": "math.align-component.external-issue-reviews", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.side24-coefficient", + "to": "math.align-component.external-issue-reviews", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.side24-coefficient", + "to": "math.align-component.side24-review-claude", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.rn-fixed-remote-window", + "to": "math.align-component.external-issue-reviews", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.rn-region.fixed-remote", + "to": "math.rn-fixed-remote-window", + "required": true, + "relation": "covered_by" + }, + { + "from": "math.rn-fixed-annulus-window", + "to": "math.align-component.pr22-annulus-review", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.rn-fixed-annulus-window", + "to": "math.align-component.two-scale-addendum", + "required": true, + "relation": "consumes_s6_s21_stitching_input" + }, + { + "from": "math.align-component.two-scale-addendum", + "to": "math.align-component.two-scale-review", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.rn-region.fixed-annulus-window", + "to": "math.rn-fixed-annulus-window", + "required": true, + "relation": "covered_by" + }, + { + "from": "math.p15-full-price", + "to": "math.align-component.external-issue-reviews", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.p15-full-price", + "to": "math.align-component.p15-review", + "required": true, + "relation": "requires_evidence" + }, + { + "from": "math.p15-full-price", + "to": "math.align-component.p15-realized-covers-setwise", + "required": true, + "relation": "consumes_setwise_interfaces_P1_P2_TheoremP2" + }, + { + "from": "math.align-component.p15-realized-covers-setwise", + "to": "math.align-component.p15-review", + "required": true, + "relation": "requires_evidence" + } + ], + "nodes_added": 8, + "edges_added": 16, + "edges_removed": 0, + "external_evidence": { + "file": "reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md", + "sha256": "fa6677f16f688352f3fc9b1703d39324fe57a3b2bf61960591f524f858e99c9d", + "node": "math.align-component.external-issue-reviews", + "status": "mutable external evidence, read back on 2026-09-30 through the session's GitHub connector and transcribed with comment id, URL, posting account, created_at, updated_at and body (Cursor footer HTML omitted); not byte-authenticated offline; OpenAI 5360327058 reports direct authentication of 5841270276, 5841782206, 5841269490 and 5841783172; this is not an additional review and not an additional provider" + } +} diff --git a/reviews/register_alignment_20260930/RECONCILIATION.md b/reviews/register_alignment_20260930/RECONCILIATION.md new file mode 100644 index 000000000..ece9655fd --- /dev/null +++ b/reviews/register_alignment_20260930/RECONCILIATION.md @@ -0,0 +1,270 @@ +# Register alignment — graph nodes for the accepted STATUS rows D2, D3, D4, D5-annulus and D6 + +**Object:** REGISTER-ALIGNMENT-20260930-v1. +**Reconciler:** Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3`. +**Read at:** Math- `main` `aa288385af9392c509233c25a0f4012c9ba023e5` (30 September 2026); main `STATUS.md` at `7bbbdc9`. +Re-verified at `ec6db8c` (Math-#151 merged, 30 September 00:56Z): the ten inventoried sources and the eight live nodes of +§4 are unchanged; the live graph now also carries `math.d5-component.remote-window-proof` (`PROVED_REVIEWED`, fingerprint +`a332bae9…`, `review_basis` "STATUS D4 (main#76, external)") beside the still-`AUTHOR_SIDE_CANDIDATE` +`math.rn-fixed-remote-window`: the D4 dual-node inconsistency is now live, and the `D4_DUPLICATE` check binds it. +**Revision:** v1.1 records the two xAI reads of `670e4ae` and makes the Math-#151-first ordering of the D4 flips +explicit; transitions unchanged. v1.2 re-verifies at `ec6db8c` after Math-#151 merged, binds the now-live duplicate D4 +node (`D4_DUPLICATE` check, `duplicate-drift` mutant) and records that the HOLD's Math-#151 precondition is met; +transitions unchanged. v1.3 answers the two OpenAI AMEND reviews (5360320845, 5360327058) and the five Codex threads +(4139807545–67): review records and consumed sources become fingerprinted component nodes with required edges, regions +gain `covered_by` edges, `apply()` carries scope exclusions and replacement notes, a nine-case `PROPAGATION` check replays +two-commit source mutations through the production reverse-impact rule, the interface's promoted scope is narrowed to +self-contained inequalities plus conditional implications with its consumed premises as edges, the interface evidence +labels separate exact from floating-point checks, and the external issue comments are preserved in `EXTERNAL_REVIEWS.md` +and labelled as mutable evidence; the eight classifications are unchanged. +**Effect:** register reconciliation, **declarative only**. This record introduces **no new mathematical claim**. It binds +five objects that the register already lists as accepted to their exact bytes, quotes the nonauthor verdicts that +accepted them, records that their live graph nodes still carry the pre-review classification, and proposes the node +transitions in machine-readable form (`PROPOSED_TRANSITIONS.json`, `"executed": false`). It carries one bounded +nonauthor review (`RN_COUNT_INTERFACE_REVIEW.md`) of the RN count-interface note, the only unreviewed required premise +in these chains. Execution of any `GRAPH.json` change is a separate act for a **non-Claude lane**. `lemma_closed`, +prizes and premises are untouched. Scientific effect: NONE. + +## 0. Exposure, stated first + +- Every lane shares one GitHub account; no organizational independence is claimed anywhere below. +- I authored none of the six sources inventoried in §2 (all six are OpenAI / ChatGPT notes). I authored + `reviews/d1_chain_reconciliation_20260928/` (Math-#126), the record that moved the D1 parent node + `math.uniform-matrix-cap-lifetime` to `PROVED_REVIEWED`; the D2 and D3 nodes require that node. I authored + `reviews/d5_reconciliation_20260929/` (Math-#138), executed by Math-#151, which handles the mesoscopic, pin-collision + and intermediate regions; none of those is re-proposed here. +- Reviews cited: D2, D4, the D5 fixed annulus and D6 each rest on **one** nonauthor provider, xAI / Grok 4.7 running in + Cursor cloud sessions on 25–26 September. D3 has two providers (xAI; Anthropic, session `01NMeKE…`, in-repo record). + The count-interface review in §3 is by this session. No Cursor agent is restarted or contacted (owner stop of + 27 September); only their published comments are cited, with the byte identities they state. +- **Precedent and caveat.** The D1 node moved to `PROVED_REVIEWED` on xAI plus Anthropic reads. Four of the five flips + proposed here rest on a single provider. The executing lane may ask for a second read before flipping any of them; + this record binds what exists and says so per row. STATUS already records all five as accepted at scope. + +**Verdicts on this record.** xAI inventory read 5901912476 and xAI/Grok (Lucas) review 5360240245, both at `670e4ae`: +**ACCEPT as a declarative inventory of already-accepted STATUS scopes** (classification lag, not new mathematics; no +edge, node, controlling, prize or `lemma_closed` change; single-provider caveat correctly stated; the D3 row is the +two-provider one), with **HOLD on execution** until Math-#151 is on main so that the D4 dual-node inconsistency is +resolved in one direction, and with the single-provider rows recorded as such by the executing lane. Neither read +re-read the count-interface note: that flip rests on this packet's Anthropic review alone. Both say: do not touch +witness-collision here, do not enlarge any scope, do not treat this as a prize or Boolean fold. This record agrees +on every point; v1.1 makes the #151-first ordering explicit in §4 and `execution_order`. Math-#151 merged at `ec6db8c` +(30 September 00:56Z; main#207 closed at 00:57Z), so the first HOLD condition is met; the second, that the executing +lane record the single-provider rows as such, is already stated per row in §4 and in `PROPOSED_TRANSITIONS.json` and is +that lane's to carry out. + +OpenAI source-custody / RN-interface review 5360320845 and OpenAI-Codex engineering review 5360327058 (both at `f2250bf`, +with Codex threads 4139807545/51/58/62/67 at `670e4ae`): **the historical classification lag and the logical-interface +inequalities are sound at their stated scopes; AMEND the executable proposal; HOLD execution.** Their findings: the +acceptance evidence lived only in `review_sources` metadata, which the production loss-only audit +(`git_transition_audit.read_snapshot`, `node.source` only) never sees; a covering-proof change did not reach the promoted +regions; the annulus's `TWO_SCALE_ADDENDUM.md`, D6's `P15_REALIZED_COVERS.md` and the interface's consumed cap / parent +items were not tracked; `apply()` dropped `explicit_limits` and kept stale notes; the (N4)/(N5) checks were floating +point while labelled exact; external issue-comment verdicts were quoted, not preserved. v1.3 answers each (§4, §6; the +eight classifications and scope exclusions unchanged). The region-reporting complaint (4139807545) is superseded on main +since `ec6db8c` (`hard_gate.d4_region_complement` has a `proved_reviewed_regions` bucket) and is not replayed. Neither +OpenAI read is a new mathematical acceptance of the six sources; both keep the single-provider caveat. + +## 1. The lag + +The main `STATUS.md` accepted-scope table (rows D1–D4, D6) and `PROOF_INDEX.md` "Reviewed scoped results" list these +objects as reviewed. The downstream graph does not: + +| Object | STATUS / PROOF_INDEX | Live node | Live classification | Live fingerprint | +|---|---|---|---|---| +| D2 Theorem R | accepted, `O(1)` remainder scope | `math.lifetime-remainder` | `AUTHOR_SIDE_CANDIDATE` (in-node `review_disposition: ACCEPT`) | SHA256 `380b7d0a…` = current | +| D3 SIDE24 coefficient | accepted, `d = 2, 3` arithmetic | `math.side24-coefficient` | `AUTHOR_SIDE_CANDIDATE` (in-node `ACCEPT`) | SHA256 `c06daccc…` = current | +| D4 fixed-remote theorem | accepted, fixed `ρ`, `η` | `math.rn-fixed-remote-window` | `AUTHOR_SIDE_CANDIDATE`; region `math.rn-region.fixed-remote` `COVERED_BY_CANDIDATE` | SHA256 `a332bae9…` = current | +| D5 fixed-annulus window | PROOF_INDEX reviewed row | `math.rn-fixed-annulus-window` | `AUTHOR_SIDE_CANDIDATE` (in-node `ACCEPT`); region `math.rn-region.fixed-annulus-window` `COVERED_BY_CANDIDATE` | git blob `081abc13…` = current | +| D6 P15 full price | accepted, realized family | `math.p15-full-price` | `AUTHOR_SIDE_CANDIDATE`, note "review open" | label `full-price-20260924` | +| (premise) RN count interface | — | `math.rn-count-interface` | `AUTHOR_SIDE_CANDIDATE`, unreviewed | SHA256 `aa993f52…` = current | + +Why it matters: the hard gate's rule is "Only `PROVED_REVIEWED` satisfies a still-required positive premise" +(`frontiers/downstream_gate_20260925/README.md`). As long as these nodes stay author-side, the fixed-remote region is +"covered by candidate" only, and D2, D3, D4 and D6 satisfy no downstream premise, although their STATUS rows are +accepted. The register is also internally inconsistent on D4: since `ec6db8c` the live graph carries +`math.d5-component.remote-window-proof` (Math-#151, executing the D5 proposal of Math-#138) for the same bytes as +`PROVED_REVIEWED`, with `review_basis` "STATUS D4 (main#76, external), nonauthor, ACCEPT, full", beside +`math.rn-fixed-remote-window` at `AUTHOR_SIDE_CANDIDATE`. The same review either suffices for those bytes or it does +not; this record proposes that it does, on the older live node, so that the two agree; collapsing the pair is a +separate one-edge follow-up for the executing lane (§7). The `D4_DUPLICATE` check binds the duplicate's classification, +fingerprint, source and review basis to the D4 transition. + +## 2. Bindings: what each review bound, and what the bytes are now + +All six sources, and the two consumed sources and the addendum's review added in v1.3, are unchanged since their landing +commits. Identities of all fifteen inventoried files (six sources, the D1 parent, four in-repo reviews, two consumed +sources, this packet's two review records) are checked by `alignment_check.py` (`IDENTITIES`); the quoted verdict lines +are checked as substrings where the review is in this repository (`VERDICTS`). The issue-comment reviews are preserved +as a transcribed read-back in `EXTERNAL_REVIEWS.md` (comment id, URL, posting account, timestamps, body) and are +labelled there as mutable external evidence that an offline check cannot re-authenticate; OpenAI 5360327058 reports +having directly authenticated the D2, D3 and D4 comments. + +| Object | Source now | Review binding (quoted) | Verdict (quoted) | +|---|---|---|---| +| D2 | `frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md`, 17734 B, SHA256 `380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a`, blob `247b3ecf80bfbe896948d5d489b2d5842a81c481` | main#67 5841270276: "blob `247b3ecf80bfbe896948d5d489b2d5842a81c481`, 17734 bytes, SHA256 `380b7d0a…`"; 5841782206 re-read "and hashed" the same blob | 5841270276: "R1 — ACCEPT … R2 — ACCEPT … R3 — ACCEPT … R4 — ACCEPT for (R12) … R5 — IMPORTED-OPEN … R6 — IMPORTED-OPEN"; 5841782206: "R5 and R6 are **ACCEPT**. Theorem R is accepted at its stated O(1) remainder scope." The imports are mapped to #63 comment 5841570965 (D1-A…E), the review that the D1 reconciliation binds. | +| D3 | `coefficients/side24_v1/PROOF.md`, 10272 B, SHA256 `c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769`, blob `44b66f04f89fcd87383b3603fa69f1feb64cdddd` | main#65 5841269490: "commit `e329fba1…`, directory `coefficients/side24_v1/`", "`PROOF.md` 10272 bytes, SHA256 `c06daccc…`" | "All six coefficient interfaces check out. The disposition is **COEFFICIENT-CALC-REVIEWED / PARENT-IMPORTED-OPEN**." Second provider: `reviews/side24_v1_coefficient_claude_20260929/REVIEW.md` (blob `665d1683f33a7180957923c3cb2abce8ade235d1`): "Overall: **ACCEPT at the arithmetic-enclosure scope**". Owner reconciliation 5841779222 closed the package. The parent import is now the live `PROVED_REVIEWED` D1 node. | +| D4 | `frontiers/remote_window_20260924/PROOF.md`, 18355 B, SHA256 `a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7`, blob `b383bfcc88ec4ad497dff01fb6640e429ba24a84` | main#76 5841783172: "at commit `191ea7d541a486736ba7bbddfd4eac25a6c4567b` … 18355 bytes, SHA256 `a332bae9…`" | "This accepts only the fixed-ρ and fixed-η interfaces below. It does not accept a full RN or 24-jet theorem." Items 1–7: conditional covariance ACCEPT; three determinant factors and `O(k r⁵)` numerator ACCEPT; original endpoint normalizer ACCEPT; contact kernel and `O(k r⁴ ‖E‖)` remainder ACCEPT; fixed-separation factorial moments ACCEPT; selector/window mapping ACCEPT for the §7 implication only; uncovered complement ACCEPT as stated. Owner 5841861362: "returns ACCEPT on all seven fixed-rho/fixed-eta interfaces … Closing #76 as the fixed-remote REVIEW work package only." | +| D5 annulus | `frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md`, 17646 B, SHA256 `1fd9fe7141e464fd1c09ebf0318d8a701729c9c61ea24f73f7e20a9cf10c552b`, blob `081abc13c5e66342c13df2af2bd6b114f320486f` | `reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md` (blob `1f153966dae48d10574db0d272f75d08ca3a8b23`): "Immutable commit `2804dc1d…`", "Blob `081abc13…`", "SHA256 `1fd9fe71…`" | rows "Covariance floor … **ACCEPT**", "Cutoff `r^{1/24}` **ACCEPT**", "Rare target in the full joint gradient/height density **ACCEPT**", "Conditioned `C^3` sixth moment **ACCEPT**", at the exact scoped theorem; PR28 and later blobs excluded. | +| D6 | `frontiers/full_price_20260924/PROOF.md`, 11352 B, SHA256 `87521901ca8e5405b4d1e47f1deb1cd0326affbd6f5967b53c4178590da993f9`, blob `582180e41dca0ad815ad0f18574df42040912149` | `reviews/p15_full_price_nonauthor_20260926/REVIEW.md` (blob `07db19f826763b8faa7414ba2e403d9c45bc0b6e`): "Blob `582180e4…`", "SHA256 `87521901…`" | six rows **ACCEPT** (hazard transform and separate concavity; odd-majority worst case; global hazard direction and independence; full-block cover; sharpness; demand-one boundary). Owner 5842112010: "D6 ANALYTIC REVIEW COMPLETE … Closing #74 as the D6 review work package". | +| premise | `frontiers/three_fronts_20260924/RN_COUNT_INTERFACE.md`, 8938 B, SHA256 `aa993f5217bd70e6d1060402d121ab659f6582a098e29042c67585a345a8e3ab`, blob `371fd6d17920f2eb3b1c5ec30297acf6daf1d385` | this packet, `RN_COUNT_INTERFACE_REVIEW.md` | ACCEPT at the logical-interface scope (§3); its consumed formulation was reconstructed inside the D4 review (items 2–3). | +| D1 parent (premise of D2, D3) | `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, 40261 B, SHA256 `9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7` | live node `math.uniform-matrix-cap-lifetime`, `PROVED_REVIEWED`, four required reading-rule components (Math-#126) | not re-reviewed; checked live (`BASELINE`). | +| consumed by D5 annulus | `frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md`, 15902 B, SHA256 `079f9399aef401d58749b3684f3acbb7f49ffdcbcac9f501b79e06c28a7f4e7d`, blob `89cae3a9734f2ec7172cd0b6b0b3af3ddd355d73` | `reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md` (10073 B, SHA256 `04cf4c98…`, blob `89882516`): "blob `89cae3a9…`, 15902 bytes, SHA256 `079f9399…`"; the pr22 review: "Read as the imported inner bound, not re-derived: `TWO_SCALE_ADDENDUM.md` blob `89cae3a9…`" | S6–S21 and (S3)–(S5) **ACCEPT** (xAI, Math- PR34); pr22 row "Inner two-scale stitching **ACCEPT**". Component nodes `…two-scale-addendum`, `…two-scale-review` (§4). | +| consumed by D6 | `frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md`, 11467 B, SHA256 `c0dbb821fb57b685a20cc321e4074456f39a9697f3104afd1f728e4732179bb9`, blob `173881916ccd0e738bdb41279e835e78e520fcbc` | the p15 review: "Read as the cited setwise dependency, and checked for the local restriction and the full-block cover: … SHA256 `c0dbb821…`. That is the digest named in the proof. The check uses (P1), (P2), and Theorem P2 there. It does not accept that note's `c_v<=p_v` price theorem" | setwise interfaces only, at the D6 review's scope. Component node `…p15-realized-covers-setwise` (§4). | +| external comments (D2, D3, D4, D6) | `reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md` (this packet) | seven comments with id, account, `created_at`, `updated_at`, body; the four `cursor[bot]` reviews and three owner reconciliations | preserved read-back; mutable external evidence, labelled. Component node `…external-issue-reviews` (§4). | + +## 3. The count-interface note + +`RN_COUNT_INTERFACE_REVIEW.md` reviews `RN-COUNT-INTERFACE-20260924-v1` at the scope the note itself states: the Hölder +implications (N1)–(N3), the two counterexamples of its §3 and the layer-cake bound (N5), the marked Kac–Rice formula +(N6)–(N7) as a formula, and the support statement of §5. Verdict: **ACCEPT at the logical-interface scope**; it is not +an expected-count rate and is not treated as one. The finite parts are checked in `INTERFACE` in two labelled parts: exact rational arithmetic (Hölder on finite rational +distributions for `p = 2, 3`; the exponent identity of (N2); the (N3) identity; the single-`p` sharp example at +`r = 2^(−pm)`, where `E N^p = 1` and `E N = r^(3−3/p)` exactly) and floating-point numerical corroborations of arguments +proved in the review (the (N4) example's moments and the located maximum of `(t+1)^p e^(−3t)`; the identity +`∫ min(q, A e^(−t/B)) dt = B q [1 + log(A/q)]` by Simpson quadrature; the uniform tail `P(N_r > t) ≤ e³ e^(−3t)` of the +(N4) example on a grid); OpenAI 5360320845 item 2 asked for exactly this separation. The note's consumed premises are the +parent's regression law and §9 Borel-mark convention (live node `math.uniform-matrix-cap-lifetime`, with its four +reading-rule components) and the cap support source of §5 (live node `math.d1-component.marked-cylinder-cap`, SHA256 +`0bf922b9…`, the digest the note quotes); both are required edges of the proposal, and the promoted scope is narrowed to +(N1)–(N5) with the counterexamples as self-contained statements and (N6)–(N7), §5 as conditional implications at formula +level. A later rigorous statement of (N6) is Lemma 5.1 of `frontiers/c6_palm_route_20260929/PROOF.md` (Math-#145), +cited for the reader and not consumed. + +## 4. Proposed transitions + +Eight node transitions and, since v1.3, the evidence that carries them, represented in the graph itself: eight +fingerprinted review-record / consumed-source component nodes and sixteen required edges (`PROPOSED_TRANSITIONS.json`: +`transitions`, `proposed_graph_nodes`, `proposed_graph_edges`; `edges_unchanged: false`). The change of packaging answers +OpenAI 5360320845 item 1, OpenAI 5360327058 items 1–2 and Codex threads 4139807558/4139807562/4139807567: the production +loss-only audit (`git_transition_audit.read_snapshot`) reads `node.source` only, so acceptance evidence and consumed +sources that live only in `review_sources` metadata would never revalidate a promoted object when they change. The eight +classifications and every scope exclusion are unchanged from v1.0. + +| Node | Current | Proposed | Scope (STATUS row) | Review sources | Required premises after | +|---|---|---|---|---|---| +| `math.rn-count-interface` | `AUTHOR_SIDE_CANDIDATE` | `PROVED_REVIEWED` | (N1)–(N5) and the §3 counterexamples as self-contained probability statements; (N6)–(N7) and §5 as formula-level implications conditional on the parent's regression law / §9 convention and on the cap support source | this packet (`RN_COUNT_INTERFACE_REVIEW.md`, a component node); main#76 items 2–3 | `math.uniform-matrix-cap-lifetime` and `math.d1-component.marked-cylinder-cap` (both live `PROVED_REVIEWED`; the note's consumed premises); `math.align-component.rn-interface-review` | +| `math.lifetime-remainder` | `AUTHOR_SIDE_CANDIDATE` | `PROVED_REVIEWED` | Theorem R, existential `O(1)` remainder | main#67 5841270276, 5841782206 | D1 (live `PROVED_REVIEWED`); `math.align-component.external-issue-reviews` | +| `math.side24-coefficient` | `AUTHOR_SIDE_CANDIDATE` | `PROVED_REVIEWED` | coefficient arithmetic, `d = 2, 3` | main#65 5841269490; in-repo Anthropic record | D1; `…external-issue-reviews`; `…side24-review-claude` | +| `math.rn-fixed-remote-window` | `AUTHOR_SIDE_CANDIDATE` | `PROVED_REVIEWED` | fixed `ρ`, `η`, between-pin window | main#76 5841783172, 5841861362 | `math.rn-count-interface`; `…external-issue-reviews` | +| `math.rn-region.fixed-remote` | `COVERED_BY_CANDIDATE` | `PROVED_REVIEWED` | the D4 region | as the covering node | `math.rn-fixed-remote-window` (new required `covered_by` edge) | +| `math.rn-fixed-annulus-window` | `AUTHOR_SIDE_CANDIDATE` (blob fingerprint) | `PROVED_REVIEWED` (SHA256 fingerprint) | `d = 2` fixed scaled annulus, window | `reviews/pr22_…/REVIEW.md` | `math.rn-count-interface`; `…pr22-annulus-review`; `…two-scale-addendum` (the S6–S21 stitching input, which itself requires `…two-scale-review`) | +| `math.rn-region.fixed-annulus-window` | `COVERED_BY_CANDIDATE` | `PROVED_REVIEWED` | the covering node's scope | as the covering node | `math.rn-fixed-annulus-window` (new required `covered_by` edge) | +| `math.p15-full-price` | `AUTHOR_SIDE_CANDIDATE` (label fingerprint) | `PROVED_REVIEWED` (SHA256 fingerprint) | realized family, `d_i ≥ 2` | `reviews/p15_…/REVIEW.md`; main#74 5842112010 | `…external-issue-reviews`; `…p15-review`; `…p15-realized-covers-setwise` ((P1), (P2), Theorem P2 setwise only, which itself requires `…p15-review`) | + +Component nodes (`kind: reading_rule_component`, `PROVED_REVIEWED`, `controlling: false`, `fingerprint` = SHA256 of the +source; one node per byte identity; none duplicates a source the live graph already carries with a fingerprint): + +| Node | Source | Role | Provider | Consumed by | +|---|---|---|---|---| +| `math.align-component.rn-interface-review` | `reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md` (this packet) | review record | Anthropic (nonauthor) | `math.rn-count-interface` | +| `math.align-component.external-issue-reviews` | `reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md` (this packet: seven issue comments transcribed with id, account, timestamps and body; mutable external evidence, labelled) | external review record | xAI/Grok via Cursor (posted by `cursor[bot]`) and owner; recorded by Anthropic | D2, D3, D4, D6 | +| `math.align-component.side24-review-claude` | `reviews/side24_v1_coefficient_claude_20260929/REVIEW.md` | review record | Anthropic (other session) | D3 | +| `math.align-component.pr22-annulus-review` | `reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md` | review record | xAI | annulus | +| `math.align-component.two-scale-addendum` | `frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md` (`079f9399…`, blob `89cae3a9`) | consumed proof: the S6–S21 stitching input ((S4) on `A ≤ |u| ≤ B`) | OpenAI | annulus | +| `math.align-component.two-scale-review` | `reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md` (`04cf4c98…`, blob `89882516`) | review record of the addendum (S6–S21 and (S3)–(S5) ACCEPT) | xAI | `…two-scale-addendum` | +| `math.align-component.p15-review` | `reviews/p15_full_price_nonauthor_20260926/REVIEW.md` | review record | xAI | D6, `…p15-realized-covers-setwise` | +| `math.align-component.p15-realized-covers-setwise` | `frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md` (`c0dbb821…`, blob `17388191`) | consumed interface: (P1), (P2), Theorem P2 setwise at `K ≥ K_H(d)` only, as the D6 review checked them; the note's `c_v ≤ p_v` price theorem is not included | OpenAI | D6 | + +These are exactly the support dependencies the canonical claim manifest records for the annulus (`two-scale-s6-s21`) +and for the full-price theorem (`p15-realized-covers:setwise-interfaces`). The interface's two consumed premises are +the live D1 node (regression law `Q`, §9 Borel-mark convention, read with its four reading-rule components) and the live +cap component (`0bf922b9…`, the SHA256 the note quotes for its §5 support statement); the (N6) cross-reference to the +C6 Palm route's Lemma 5.1 in the review is for the reader and is not consumed. + +Every proposed node keeps `controlling: false`; each candidate node's `fingerprint` becomes the SHA256 of its source in +§2, and `apply()` carries `scope`, `explicit_limits`, a replacement `notes`, `review_disposition`, `review_sources` and a +structured `review_basis` onto the node, so no promoted node keeps a "review open" or "covered by candidate only" note +(Codex 4139807551; OpenAI 5360327058 item 3). Region nodes keep `coverage_source` and gain a required `covered_by` edge +to their covering node, so that a change to the covering proof reaches the region in `reverse_impact_between` (Codex +4139807558; OpenAI 5360327058 item 1). No `hist.*`, `eng.*` or `regional.*` node moves; no live node other than the +eight changes; no live edge is removed; every added edge leaves one of this record's objects. The order in +`execution_order` creates the component nodes and edges first, then the premise, then each region after its covering +node; the D4 theorem node and its region are executed only after Math-#151 is on main (satisfied at `ec6db8c`): the D4 +bytes are now carried by two live nodes on the same review, and the flip aligns the older one with the newer one; the +executing lane may then collapse `math.d5-component.remote-window-proof` onto the live node or keep both (xAI +5901912476, 5360240245). STATUS, PROOF_INDEX, SELECTOR_REGION and the catalog need no edit for this record: they +already say what the graph is being aligned to. + +`alignment_check.py` applies the proposal to a copy of the live graph and replays it through the hard gate's own +validators (`validate_graph_fail_closed`, `closure_report`, `reverse_impact_between`, imported from +`frontiers/downstream_gate_20260925/hard_gate.py`): the proposed graph is well formed, no node is controlling, +`gate_ok` holds, and the loss-only reverse-impact proposal names exactly the changed nodes and their dependents. +`PROPAGATION` then runs nine two-commit mutations through `reverse_impact_between` with source snapshots in the shape of +`git_transition_audit.read_snapshot` (proof edits reach their regions and consumers; a deleted review record and an +edited external-review record reach the accepted objects and their dependents; consumed-source edits reach their +consumers; an unrelated edit and a no-op reach none of the eight), the guarantee OpenAI 5360320845 asked to be tested +rather than inferred from old-versus-new GRAPH metadata. + +## 5. What is not proposed + +- The mesoscopic, pin-collision and intermediate regions: Math-#151. The witness-collision region and its residual: + Math-#160. `math.rn-mesoscopic-reduction` (legacy PR7 route): unchanged, still `AUTHOR_SIDE_REDUCTION`. +- Any second-provider reads. Where a row rests on one provider the row says so; the lane executing the flip decides + whether that is enough, as it was not for D1. +- Any controlling flag, promotion, `lemma_closed`, prize, STATUS, PROOF_INDEX, catalog or selector edit. + +## 6. Checks + +`alignment_check.py` (stdlib only, run from the repository root): +- **IDENTITIES.** All fifteen inventoried files (the six sources, the D1 parent, the four in-repo reviews, the two + consumed sources, and this packet's two review records) exist as regular files, no symlink on their paths, stated + SHA256 and blob. +- **VERDICTS.** The quoted verdict rows and binding lines of the in-repo reviews (pr22, p15, side24, two-scale), the + object headers of the sources, the D4 sentence that consumes the interface, the interface note's (N1)/(N4)/(N5) + displays, the five PROOF_INDEX rows, the interface review's overall verdict and evidence labels, and the seven comment + ids with their verdict lines and the mutability label in `EXTERNAL_REVIEWS.md` are present as substrings. +- **BASELINE.** Each transition's live node exists with exactly the recorded current classification, fingerprint, + kind and source; the D1 node is `PROVED_REVIEWED` with its four reading-rule components `PROVED_REVIEWED`. +- **TRANSITIONS.** `declarative` true, `executed` false, `edges_unchanged` false; every proposed classification is + `PROVED_REVIEWED` with `controlling: false`, a non-empty scope, explicit limits, replacement notes and at least one + review source; every candidate node's fingerprint equals the SHA256 of its inventoried source; every component node + is a `reading_rule_component`, `PROVED_REVIEWED`, non-controlling, fingerprinted to its inventoried source, with a + role, a provider, a review basis and a consumer, one node per byte identity and none for bytes the live graph already + carries; every added edge is well formed, new, and leaves one of this record's objects; applied to a copy of the live + graph, no live node other than the eight changes, no live edge is removed, every flipped node's required premises (the + live D1 node and cap component, the interface, the component nodes) are `PROVED_REVIEWED`, every region requires its + covering node, and every applied node carries its `explicit_limits`, its replacement `notes` and a `review_basis`. +- **GATE.** The proposed graph passes the hard gate's `validate_graph_fail_closed`; `closure_report` gives `gate_ok` + with no illegal controlling node; `reverse_impact_between(live, proposed)` runs and its impacted set (the eight nodes, + the eight component nodes and their dependents) is recorded. +- **PROPAGATION.** Nine two-commit cases on the proposed graph with source snapshots in the shape of + `git_transition_audit.read_snapshot`: a D4 proof edit reaches the fixed-remote region and the mesoscopic consumer; an + annulus proof edit reaches its region; deleting the interface review record reaches the interface, D4, the annulus and + both regions; editing the external-review record reaches D2, D3, D4, D6 and the fixed-remote region; editing the + two-scale addendum reaches the annulus and its region; editing the realized-covers source reaches D6; a D4 fingerprint + edit reaches the region; an unrelated edit reaches none of the eight; a no-op impacts nothing. +- **INTERFACE.** The finite content of §3, in two labelled parts: exact rational checks (Hölder for `p = 2, 3` on + finite spaces, the (N2) exponent identity, the (N3) identity, the sharp-`p` example at `r = 2^(−pm)`, the integer + monotonicity in (N4)) and floating-point numerical corroborations (the (N4) grid maximum, the (N5) Simpson quadrature + at three parameter points, the (N4) example's uniform tail on a grid). The analytic arguments are in the review; the + numerical part corroborates, it does not prove. +- **NEGATIVES.** Real filesystem faults on a temporary copy of the inventory (delete, change one byte, symlink, symlink + parent of the D4 proof) are rejected. +- **D4_DUPLICATE.** The live graph carries `math.d5-component.remote-window-proof` as `PROVED_REVIEWED`, + non-controlling, with the same SHA256 fingerprint and source as the D4 transition and as the inventory, a `review_basis` + citing main#76 with verdict ACCEPT, `component_of` `math.d5-pin-neighborhood-first-moment`; and the older live node + `math.rn-fixed-remote-window` still carries that fingerprint at `AUTHOR_SIDE_CANDIDATE`, the lag this record aligns. + +Twelve mutants must fail: `allow-symlink`, `no-hash`, `stale-fingerprint`, `drop-review-source`, `controlling-true`, +`executed-flag`, `skip-interface-premise`, `holder-reversed`, `baseline-drift`, `duplicate-drift`, `region-unlinked` +(the `covered_by` edges removed before the propagation replay: proof edits no longer reach the regions) and +`review-metadata-only` (the review-record nodes and their edges removed before the replay, leaving the citations as +metadata only: a deleted or edited review record no longer reaches its accepted object). + +## 7. Relation to other lanes + +- **Math-#151 (Codex, D5 fold; merged at `ec6db8c`, 30 September 00:56Z, final head `609e559`):** landed as proposed, + so the live graph carries `math.d5-component.remote-window-proof` (`PROVED_REVIEWED`, `component_of` + `math.d5-pin-neighborhood-first-moment`, `review_basis` main#76) for the D4 bytes beside `math.rn-fixed-remote-window` + (`AUTHOR_SIDE_CANDIDATE`); the coordination note (comment 5901742635) was not taken up before the merge. This record's + D4 flip aligns the two; collapsing the component node to a `required` edge onto the live node is a one-edge follow-up + for the executing lane, not proposed here. +- **Math-#160 (this session, C6 reconciliation):** already references the live D4 node with supporting edges; nothing + there changes. +- **OpenAI reviews 5360320845 and 5360327058; Codex review 5360253242 (threads 4139807545–67):** answered by v1.3 (§0, + §4, §6); the region-reporting thread is superseded on main since `ec6db8c` and not replayed. The single-provider caveat + and the HOLD on execution stand until the executing lane decides. +- **Math-#163 (navigation refresh):** availability index only; disjoint. +- **main#207 (closed 30 September 00:57Z, after Math-#151 merged):** the delivery note for this record is comment + 5901889845. The executing lane for this record remains non-Claude; any new coordination thread is that lane's to open. diff --git a/reviews/register_alignment_20260930/RESULTS.json b/reviews/register_alignment_20260930/RESULTS.json new file mode 100644 index 000000000..6702db536 --- /dev/null +++ b/reviews/register_alignment_20260930/RESULTS.json @@ -0,0 +1,99 @@ +{ + "checks": { + "BASELINE": true, + "D4_DUPLICATE": true, + "GATE": true, + "IDENTITIES": true, + "INTERFACE": true, + "NEGATIVES": true, + "PROPAGATION": true, + "TRANSITIONS": true, + "VERDICTS": true + }, + "component_nodes": 8, + "edges_added": 16, + "gate": { + "changed_nodes": [ + "math.align-component.external-issue-reviews", + "math.align-component.p15-realized-covers-setwise", + "math.align-component.p15-review", + "math.align-component.pr22-annulus-review", + "math.align-component.rn-interface-review", + "math.align-component.side24-review-claude", + "math.align-component.two-scale-addendum", + "math.align-component.two-scale-review", + "math.lifetime-remainder", + "math.p15-full-price", + "math.rn-count-interface", + "math.rn-fixed-annulus-window", + "math.rn-fixed-remote-window", + "math.rn-region.fixed-annulus-window", + "math.rn-region.fixed-remote", + "math.side24-coefficient" + ], + "impacted": [ + "math.align-component.external-issue-reviews", + "math.align-component.p15-realized-covers-setwise", + "math.align-component.p15-review", + "math.align-component.pr22-annulus-review", + "math.align-component.rn-interface-review", + "math.align-component.side24-review-claude", + "math.align-component.two-scale-addendum", + "math.align-component.two-scale-review", + "math.lifetime-remainder", + "math.p15-full-price", + "math.rn-count-interface", + "math.rn-fixed-annulus-window", + "math.rn-fixed-remote-window", + "math.rn-mesoscopic-reduction", + "math.rn-region.fixed-annulus-window", + "math.rn-region.fixed-remote", + "math.rn-selector-region-crosswalk", + "math.side24-coefficient" + ], + "reverse_impact_keys": [ + "changed_nodes", + "context_changed", + "graph", + "impacted", + "meaning", + "promotion_permission", + "source_snapshots_supplied", + "traversal_edges" + ] + }, + "interface_evidence": { + "exact_rational": [ + "(N1) Holder p=2,3 on finite rational spaces", + "(N2) exponent identity", + "(N3) conditional-mean identity", + "sharp-p example at r=2^-pm", + "(N4) integer monotonicity of ceil(t)" + ], + "numerical_corroboration_floating_point": [ + "(N4) grid maximum of (t+1)^p e^-3t", + "(N5) Simpson quadrature at three parameter points", + "(N4) example uniform tail on a grid" + ], + "results": { + "exact": true, + "numerical_corroboration": true + } + }, + "inventory_files": 15, + "object": "REGISTER-ALIGNMENT-20260930-v1", + "passed": true, + "propagation": { + "annulus-proof-edit-reaches-region": true, + "d4-fingerprint-edit-reaches-region": true, + "d4-proof-edit-reaches-region-and-consumer": true, + "external-review-record-edit-reaches-d2-d3-d4-d6": true, + "interface-review-deleted-reaches-interface-consumers-regions": true, + "no-op-impacts-nothing": true, + "realized-covers-edit-reaches-d6": true, + "two-scale-addendum-edit-reaches-annulus-and-region": true, + "unrelated-edit-leaves-the-eight-untouched": true + }, + "scope": "identity, verdict-row, live-baseline, transition-shape, hard-gate replay, two-commit propagation, interface arithmetic (exact and numerical parts labelled), filesystem-negative and live D4-duplicate checks; no mathematics is re-proved; nothing is written", + "transitions": 8 +} diff --git a/reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md b/reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md new file mode 100644 index 000000000..7e7049e2b --- /dev/null +++ b/reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md @@ -0,0 +1,56 @@ +# Nonauthor review — RN count interface note (D4 premise) + +**Object reviewed:** `frontiers/three_fronts_20260924/RN_COUNT_INTERFACE.md` (RN-COUNT-INTERFACE-20260924-v1), author +OpenAI / ChatGPT; on Math- `main` `aa288385af9392c509233c25a0f4012c9ba023e5`; 8938 bytes, SHA256 +`aa993f5217bd70e6d1060402d121ab659f6582a098e29042c67585a345a8e3ab`, git blob `371fd6d17920f2eb3b1c5ec30297acf6daf1d385`; unchanged since its landing commit `8a13ee9` +(24 September 2026). Live graph node `math.rn-count-interface` carries this SHA256 as fingerprint. +**Revision:** v1.3 (30 September 2026) corrects the evidence labels after OpenAI review 5360320845 item 2: the checks +that use floating point are now called numerical corroborations, the rational ones exact; and names the note's consumed +premises (item 3 there; OpenAI 5360327058 item 2). Verdicts unchanged. +**Reviewer:** Anthropic Claude, Claude Code session `session_017Mi3hxjaxV45x6zo6o1ee3`. Different provider from the +author. Same GitHub account as every lane; no organizational independence is claimed. +**Exposure:** I authored none of the three-fronts notes. I authored the remote-collision packet and the C6L packet, +both downstream of the fixed-remote theorem that consumes this note; neither is an input here. +**Scope:** the logical interface only, as the note itself states: the implications (N1)–(N3), the counterexamples of +§3 with (N4)–(N5), the marked Kac–Rice expression (N6)–(N7) as a formula, and the support statement of §5. No rate, +no RN numerical certificate and no evaluation of the Gaussian triple integral are claimed by the note or accepted +here. Scientific effect: NONE. +**Promoted scope (v1.3):** (N1)–(N5) and the §3 counterexamples as self-contained probability statements; (N6)–(N7) +and §5 as formula-level implications conditional on the note's two consumed premises, the parent's regression law `Q` +with its §9 Borel-mark convention (live node `math.uniform-matrix-cap-lifetime`, read with its four reading-rule +components) and the cap support source of §5 (live node `math.d1-component.marked-cylinder-cap`, SHA256 `0bf922b9…`, the +digest the note quotes); both are required edges in `PROPOSED_TRANSITIONS.json`. Nothing quantitative. + +## Verdicts + +| Item | Statement | Verdict | +|---|---|---| +| (N1) | `E[N 1_E] ≤ (E N^p)^(1/p) P(E)^(1−1/p)` for `p > 1` | **ACCEPT**: Hölder with exponents `p` and `p/(p−1)` applied to `N · 1_E`. Exact rational check for `p = 2` (Cauchy–Schwarz form `(E[N1_E])² ≤ E[N²] P(E)`) and `p = 3` (`(E[N1_E])³ ≤ E[N³] P(E)²`) on finite distributions in `alignment_check.py` (`INTERFACE`). | +| (N2) | `E N^p ≤ A r^(−β)` gives `E[N 1_E] ≤ A^(1/p) C^(1−1/p) r^([3(p−1)−β]/p)` | **ACCEPT**: substitution into (N1); the exponent `3 − 3/p − β/p` is the moment convention, as the note says. | +| (N3) | `E[N 1_E] = q E[N | E]`, `q = P(E) > 0` | **ACCEPT**: definition of conditional expectation; the two remarks (sufficiency of a bounded conditional mean; equivalence only under a lower comparison `q ≥ c r³`) follow. | +| §3 (N4) | `U` uniform, `E_r = {U ≤ r³}`, `N_r = ⌈log(1/r)⌉ 1_{E_r}`: `E N_r / r³ → ∞` while `sup_r E N_r^p < ∞` for every fixed `p` | **ACCEPT**: `P(E_r) = r³`; `E N_r^p = ⌈t⌉^p e^(−3t) ≤ (t+1)^p e^(−3t)` with `t = log(1/r) ≥ 1`, whose supremum over `t ≥ 1` is finite (the logarithmic derivative `−3 + p/(t+1)` is eventually negative). The argument is the log-derivative; `INTERFACE` corroborates it numerically, in floating point, on `r = e^(−t)`, `t = 1, …, 12`, and on a grid against the located maximum (labelled `numerical_corroboration`, not exact). | +| §3 sharp `p` | `N_r = ⌈r^(−3/p)⌉ 1_{E_r}`: `E N_r^p ≤ 2^p` for `r ≤ 1`, `E N_r ≍ r^(3−3/p)` | **ACCEPT**: `r^(−3/p) ≥ 1` gives `⌈r^(−3/p)⌉ ≤ 2 r^(−3/p)`. Checked exactly at `r = 2^(−pm)`, where `r^(−3/p) = 2^(3m)` is an integer, `E N_r^p = 1` and `E N_r = r^(3−3/p)` exactly. | +| (N5) | `P(N > t) ≤ A e^(−t/B)`, `A ≥ 1`, gives `E[N 1_E] ≤ ∫ min(q, A e^(−t/B)) dt = B q [1 + log(A/q)]` | **ACCEPT**: layer cake `E[N 1_E] = ∫_0^∞ P(N > t, E) dt ≤ ∫ min(q, P(N > t)) dt`; the crossover is `t_0 = B log(A/q)` and the two pieces are `q t_0` and `A B e^(−t_0/B) = B q`. The (N4) example has the uniform tail `P(N_r > t) ≤ e³ e^(−3t)` (`A = e³`, `B = 1/3`), so the logarithmic loss in (N5) is not removable from a tail hypothesis alone, as the note says. The identity is proved by the antiderivative; `INTERFACE` corroborates it by floating-point Simpson quadrature at three parameter points and checks the tail comparison on a floating-point grid (numerical corroboration, not exact). | +| §4 (N6) | marked Kac–Rice for `E_Q^W N_B` with the endpoint weight as a field mark and the event indicator inside the conditional expectation | **ACCEPT as a formula at the note's stated level of rigour** (bounded continuous cylinder marks, extension of finite measures, truncation of `W_r`, monotone convergence; compact `B` off the pins, exhaustion), conditional on the note's consumed premise: the parent's regression law `Q` and its §9 Borel-mark convention (live node `math.uniform-matrix-cap-lifetime`, read with its four reading-rule components; a required edge in the proposal). Its fixed-remote instance is the reviewed formula (12)–(14) of the D4 proof, accepted in main#76 comment 5841783172 items 2–3. A later rigorous statement of the same identity with the kernel convention fixed is Lemma 5.1 of `frontiers/c6_palm_route_20260929/PROOF.md` (Math-#145); it is cited for the reader and is not consumed here. Nothing quantitative is asserted by (N6) and nothing quantitative is accepted here. | +| §4 (N7) | an `A r⁵` enclosure of the numerator with `Z_r ≥ z_* r²` gives `E_Q^W N_B ≤ (A/z_*) r³` | **ACCEPT**: division; the note correctly separates this from the cap probability argument (`E_Q[W_r 1_{G^c}]`). | +| §5 | support on the rare event only inside the deterministic cap cylinder; remote regions need their own support statement or the count `N 1_{G^c}` | **ACCEPT as a scope statement**; it consumes the cap source `0bf922b9…` for the containment `{M, S}` on `G_r` (the live node `math.d1-component.marked-cylinder-cap` carries exactly that SHA256; a required edge in the proposal) and adds nothing to it. | +| §6 | completion test: (N7) or a uniform conditional mean with the support relation; finite moments give (N2), tails give (N5) | **ACCEPT** as the logical summary of the above. | + +**Overall: ACCEPT at the logical-interface scope.** The note proves exactly what it claims and no more: correct +inequalities and counterexamples, and the form of the full-pin Kac–Rice expression that the fixed-remote theorem later +evaluated. It is not an expected-count rate and is not treated as one. Evidence labels: the (N1)–(N3) and sharp-`p` +checks in `INTERFACE` are exact rational arithmetic; the (N4) grid, the (N5) quadrature and the tail grid are floating-point +numerical corroborations of arguments proved above, not exact checks. + +## Relation to its consumers +- `math.rn-fixed-remote-window` (D4) reads the interface as the formulation it completes: PROOF §1 "identified a + three-determinant integral whose unnormalized numerator must be O(r^5), but did not bound it. This note supplies + that bound"; §7 "Equation (14) now supplies it for every fixed remote region and the entire BETWEEN-PIN HEIGHT WINDOW". + The D4 review reconstructed the three determinant factors, the `O(k r⁵)` numerator and the original normalizer + (items 2–3), i.e. the consumed content of (N6)–(N7). +- `math.rn-fixed-annulus-window` (D5 fixed annulus) uses the same normalized three-determinant intensity with the + original normalizer (its (A8) and §5 ledger), reviewed in `reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md`. + +## Not established here +No rate, no RN or 24-jet certificate, no `ENV-RESCOV` or historical carrier, no register transition. This file is a +review record; the proposal that consumes it is `RECONCILIATION.md` in this directory. diff --git a/reviews/register_alignment_20260930/SOURCE_FILES.json b/reviews/register_alignment_20260930/SOURCE_FILES.json new file mode 100644 index 000000000..e49e54aee --- /dev/null +++ b/reviews/register_alignment_20260930/SOURCE_FILES.json @@ -0,0 +1,47 @@ +{ + "schema": 1, + "object": "REGISTER-ALIGNMENT-20260930-v1", + "scientific_effect": "NONE", + "disposition": "PROPOSAL_FOR_A_NON_CLAUDE_LANE", + "declarative": true, + "executed": false, + "base": "aa288385af9392c509233c25a0f4012c9ba023e5", + "files": [ + { + "path": "PROPOSED_TRANSITIONS.json", + "bytes": 40189, + "sha256": "dad87926726d8a86d5ff33d1d03eecafa9b05bf9e4c0eaeb08dd67104efc695d", + "git_blob": "1c1bea9ba98ca212159fa907e2bdeda1ff863d36" + }, + { + "path": "RECONCILIATION.md", + "bytes": 32725, + "sha256": "0baf1c4e3c48ca3e2bb4eaeb419ee8ba368f082447f38f638fd10ce023c5249f", + "git_blob": "ece9655fd80ea51c18d7b1b2410d4c073854db89" + }, + { + "path": "RN_COUNT_INTERFACE_REVIEW.md", + "bytes": 8115, + "sha256": "52d9038a3f27335d3c219babec785984e00b77f28d7cd7b390477c0bc6a749d1", + "git_blob": "7e7049e2b5e96e51394d44683d61c9d0e03b9323" + }, + { + "path": "RESULTS.json", + "bytes": 3452, + "sha256": "cbbff25994c22c55fd49c59bc2748af1c6ef128793a34880613cf7cb1d9162df", + "git_blob": "6702db536f00ec5689ab398c003f46a91b645d7b" + }, + { + "path": "alignment_check.py", + "bytes": 31556, + "sha256": "eb1888ea57416f87fbfa4692b6c07b20261c97bd08ce926aee7ec6fca5486502", + "git_blob": "cd110b0cfb2cfaf6f11e7405d99e0070c816a224" + }, + { + "path": "EXTERNAL_REVIEWS.md", + "bytes": 29877, + "sha256": "fa6677f16f688352f3fc9b1703d39324fe57a3b2bf61960591f524f858e99c9d", + "git_blob": "2be80e35bce1ffc90d1f7a0675ad5e8830ddbd28" + } + ] +} diff --git a/reviews/register_alignment_20260930/alignment_check.py b/reviews/register_alignment_20260930/alignment_check.py new file mode 100644 index 000000000..cd110b0cf --- /dev/null +++ b/reviews/register_alignment_20260930/alignment_check.py @@ -0,0 +1,585 @@ +"""Checks for REGISTER-ALIGNMENT-20260930-v1 (RECONCILIATION.md, PROPOSED_TRANSITIONS.json, RN_COUNT_INTERFACE_REVIEW.md). + +Standard library only. Run from the repository root: python -B -S reviews/register_alignment_20260930/alignment_check.py +Checks: IDENTITIES, VERDICTS, BASELINE, TRANSITIONS, GATE, PROPAGATION, INTERFACE, NEGATIVES, D4_DUPLICATE. No mathematics +is re-proved; the proposed graph is replayed through the downstream hard gate's own validators, and two-commit source +mutations through its reverse-impact rule. Nothing is written to the repository. +""" +import argparse +import copy +import hashlib +import importlib.util +import json +import math +import os +import pathlib +import shutil +import sys +import tempfile +from fractions import Fraction as F + +MUTANTS = ("allow-symlink", "no-hash", "stale-fingerprint", "drop-review-source", "controlling-true", "executed-flag", + "skip-interface-premise", "holder-reversed", "baseline-drift", "duplicate-drift", "region-unlinked", + "review-metadata-only") +MUT = None +HERE = "reviews/register_alignment_20260930" +GRAPH = "frontiers/downstream_gate_20260925/GRAPH.json" +HARD_GATE = "frontiers/downstream_gate_20260925/hard_gate.py" +D1 = "math.uniform-matrix-cap-lifetime" +D4_DUP = "math.d5-component.remote-window-proof" +D4_NODE = "math.rn-fixed-remote-window" +IFACE = "math.rn-count-interface" +D4 = "frontiers/remote_window_20260924/PROOF.md" +INVENTORY = { + "frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md": [ + "380b7d0abdb0fe2de5a6564565af9560d3f1b1ce22fd5538927db0c52f4f3a4a", + "247b3ecf80bfbe896948d5d489b2d5842a81c481" + ], + "frontiers/three_fronts_20260924/RN_COUNT_INTERFACE.md": [ + "aa993f5217bd70e6d1060402d121ab659f6582a098e29042c67585a345a8e3ab", + "371fd6d17920f2eb3b1c5ec30297acf6daf1d385" + ], + "coefficients/side24_v1/PROOF.md": [ + "c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769", + "44b66f04f89fcd87383b3603fa69f1feb64cdddd" + ], + "frontiers/remote_window_20260924/PROOF.md": [ + "a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7", + "b383bfcc88ec4ad497dff01fb6640e429ba24a84" + ], + "frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md": [ + "1fd9fe7141e464fd1c09ebf0318d8a701729c9c61ea24f73f7e20a9cf10c552b", + "081abc13c5e66342c13df2af2bd6b114f320486f" + ], + "frontiers/full_price_20260924/PROOF.md": [ + "87521901ca8e5405b4d1e47f1deb1cd0326affbd6f5967b53c4178590da993f9", + "582180e41dca0ad815ad0f18574df42040912149" + ], + "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md": [ + "29a0c6d00ce739baf1d29a3163977d8e707e2079e216fba4fee3669cebec127d", + "1f153966dae48d10574db0d272f75d08ca3a8b23" + ], + "reviews/p15_full_price_nonauthor_20260926/REVIEW.md": [ + "691ea0db5c0f073326c9f7208c9804c6f5d0daf92ba7467529c9d57e08b15eb7", + "07db19f826763b8faa7414ba2e403d9c45bc0b6e" + ], + "reviews/side24_v1_coefficient_claude_20260929/REVIEW.md": [ + "258c414c46be93142ee552cfa4c32c03dd89b6bf7b0b470334f152e1e0a57eef", + "665d1683f33a7180957923c3cb2abce8ade235d1" + ], + "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md": [ + "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "dfed3b8d318a3ab1950957f393307733a4bef3f2" + ], + "frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md": [ + "079f9399aef401d58749b3684f3acbb7f49ffdcbcac9f501b79e06c28a7f4e7d", + "89cae3a9734f2ec7172cd0b6b0b3af3ddd355d73" + ], + "reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md": [ + "04cf4c986f29ac7ac33b3cc87feac23f3cf494e0c1b3bf4476e4e6666de46574", + "8988251631cab8e65eb2b01a08f7fc593b018570" + ], + "frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md": [ + "c0dbb821fb57b685a20cc321e4074456f39a9697f3104afd1f728e4732179bb9", + "173881916ccd0e738bdb41279e835e78e520fcbc" + ], + "reviews/register_alignment_20260930/RN_COUNT_INTERFACE_REVIEW.md": [ + "52d9038a3f27335d3c219babec785984e00b77f28d7cd7b390477c0bc6a749d1", + "7e7049e2b5e96e51394d44683d61c9d0e03b9323" + ], + "reviews/register_alignment_20260930/EXTERNAL_REVIEWS.md": [ + "fa6677f16f688352f3fc9b1703d39324fe57a3b2bf61960591f524f858e99c9d", + "2be80e35bce1ffc90d1f7a0675ad5e8830ddbd28" + ] +} +VERDICTS = { + "frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md": ["**Object:** LIFETIME-BOUNDED-REMAINDER-20260924-v1."], + "frontiers/three_fronts_20260924/RN_COUNT_INTERFACE.md": [ + "**Object:** RN-COUNT-INTERFACE-20260924-v1.", + "E[N_r 1_Er] <= (E N_r^p)^(1/p) P(E_r)^(1-1/p).", + "N_r=ceil(log(1/r)) 1_Er.", + "= B q[1+log(A/q)]."], + "coefficients/side24_v1/PROOF.md": ["Object: SIDE24-COEFFICIENT-D23-20260924-v1."], + "frontiers/remote_window_20260924/PROOF.md": [ + "**Object:** RN-FIXED-REMOTE-WINDOW-20260924-v1.", + "Equation (14) now supplies it for every fixed remote region and the entire BETWEEN-PIN HEIGHT WINDOW."], + "frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md": ["**Object:** D5-FIXED-ANNULUS-STITCH-20260925-v1."], + "frontiers/full_price_20260924/PROOF.md": ["**Object:** P15-FULL-TRANSFORMED-PRICE-20260924-v1."], + "reviews/pr22_fixed_annulus_nonauthor_20260925/REVIEW.md": [ + "| Blob | `081abc13c5e66342c13df2af2bd6b114f320486f` |", + "| SHA256 | `1fd9fe7141e464fd1c09ebf0318d8a701729c9c61ea24f73f7e20a9cf10c552b` |", + "| Cutoff `r^{1/24}` | **ACCEPT** |", + "| Inner two-scale stitching | **ACCEPT** |", + "`TWO_SCALE_ADDENDUM.md` blob `89cae3a9734f2ec7172cd0b6b0b3af3ddd355d73`, 15902 bytes"], + "reviews/p15_full_price_nonauthor_20260926/REVIEW.md": [ + "| Blob | `582180e41dca0ad815ad0f18574df42040912149` |", + "| SHA256 | `87521901ca8e5405b4d1e47f1deb1cd0326affbd6f5967b53c4178590da993f9` |", + "| 1. Coordinatewise hazard transform, separate concavity, chord, `p=0,1` | **ACCEPT** |", + "SHA256 `c0dbb821fb57b685a20cc321e4074456f39a9697f3104afd1f728e4732179bb9`. That is the digest named in the proof.", + "| 4. Full-block cover, same palette, realized family | **ACCEPT** |"], + "reviews/side24_v1_coefficient_claude_20260929/REVIEW.md": [ + "c06daccc4ba4b9168522b9888b76a7d599934fc3b91bd753ee5d492262917769", + "Overall: **ACCEPT at the arithmetic-enclosure scope**"], + "PROOF_INDEX.md": [ + "- D2 lifetime remainder: proof [frontiers/three_fronts_20260924/LIFETIME_REMAINDER.md]", + "- D3 SIDE24 coefficient: proof [coefficients/side24_v1/PROOF.md]", + "- D4 fixed-remote RN theorem: proof [frontiers/remote_window_20260924/PROOF.md]", + "- D5 fixed-annulus height-window fallback: proof [frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md]", + "- D6 P15 full price theorem: proof [frontiers/full_price_20260924/PROOF.md]"], + "frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md": ["**Object:** D5-TWO-SCALE-20260925-v1."], + "reviews/replacement_20260925_pr19_pr21/TWO_SCALE_REVIEW.md": [ + "blob `89cae3a9734f2ec7172cd0b6b0b3af3ddd355d73`, 15902 bytes, SHA256 `079f9399aef401d58749b3684f3acbb7f49ffdcbcac9f501b79e06c28a7f4e7d`", + "| S6 | **ACCEPT** |"], + "frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md": ["**Object:** P15-REALIZED-COVERS-20260924-v1."], + HERE + "/RN_COUNT_INTERFACE_REVIEW.md": [ + "**Overall: ACCEPT at the logical-interface scope.**", + "numerical corroborations of arguments proved above, not exact checks"], + HERE + "/EXTERNAL_REVIEWS.md": [ + "issuecomment-5841270276", "issuecomment-5841782206", "issuecomment-5841269490", "issuecomment-5841779222", + "issuecomment-5841783172", "issuecomment-5841861362", "issuecomment-5842112010", + "R5 and R6 are **ACCEPT**. Theorem R is accepted at its stated O(1) remainder scope.", + "All six coefficient interfaces check out. The disposition is **COEFFICIENT-CALC-REVIEWED / PARENT-IMPORTED-OPEN**.", + "This accepts only the fixed-ρ and fixed-η interfaces below. It does not accept a full RN or 24-jet theorem.", + "D6 ANALYTIC REVIEW COMPLETE", + "An issue comment is a mutable external object"], +} + + +def git_blob(data): + return hashlib.sha1(b"blob %d\0" % len(data) + data).hexdigest() + + +def no_symlink_on_path(root, path): + parts = pathlib.PurePosixPath(path).parts + return not any((root / pathlib.PurePosixPath(*parts[:i])).is_symlink() for i in range(1, len(parts) + 1)) + + +def identities_ok(root): + for path, (sha, blob) in INVENTORY.items(): + p = root / path + if not os.path.lexists(p): + return False + if MUT != "allow-symlink" and not no_symlink_on_path(root, path): + return False + if not p.is_file(): + return False + data = p.read_bytes() + if MUT != "no-hash" and (hashlib.sha256(data).hexdigest() != sha or git_blob(data) != blob): + return False + return True + + +def check_verdicts(root): + for path, needles in VERDICTS.items(): + text = (root / path).read_text(encoding="utf-8") + if not all(n in text for n in needles): + return False + return True + + +def load_spec(root): + spec = json.loads((root / HERE / "PROPOSED_TRANSITIONS.json").read_text(encoding="utf-8")) + if MUT == "executed-flag": + spec["executed"] = True + if MUT == "skip-interface-premise": + spec["transitions"] = [t for t in spec["transitions"] if t["node"] != IFACE] + if MUT == "drop-review-source": + for t in spec["transitions"]: + if t["node"] == D4_NODE: + t["proposed"]["review_sources"] = [] + if MUT == "controlling-true": + for t in spec["transitions"]: + if t["node"] == D4_NODE: + t["proposed"]["controlling"] = True + if MUT == "stale-fingerprint": + for t in spec["transitions"]: + if t["node"] == D4_NODE: + t["proposed"]["fingerprint"] = "0" * 64 + if MUT == "baseline-drift": + for t in spec["transitions"]: + if t["node"] == D4_NODE: + t["current"]["classification"] = "PROVED_REVIEWED" + return spec + + +def check_baseline(root, spec): + live = json.loads((root / GRAPH).read_text(encoding="utf-8"))["nodes"] + ok = True + for t in spec["transitions"]: + n = live.get(t["node"]) + if not isinstance(n, dict): + return False + ok &= n.get("classification") == t["current"]["classification"] + ok &= n.get("fingerprint") == t["current"]["fingerprint"] + ok &= n.get("kind") == t["kind"] and n.get("controlling") is False + if t["kind"] == "candidate": + ok &= n.get("source") == t["proposed"]["source"] + d1 = live.get(D1, {}) + ok &= d1.get("classification") == "PROVED_REVIEWED" and d1.get("fingerprint") == INVENTORY[ + "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md"][0] + rr = d1.get("reading_rule", []) + ok &= len(rr) == 4 and all(live.get(x, {}).get("classification") == "PROVED_REVIEWED" for x in rr) + return bool(ok) + + +def apply(spec, graph): + """The proposal applied to a copy of the live graph: the eight flips with their scope exclusions and replacement + notes, plus the review-record / consumed-source component nodes and the required edges that carry the evidence.""" + new = copy.deepcopy(graph) + for t in spec["transitions"]: + n = new["nodes"][t["node"]] + p = t["proposed"] + n["classification"] = p["classification"] + n["controlling"] = p["controlling"] + n["fingerprint"] = p["fingerprint"] + if p.get("source"): + n["source"] = p["source"] + n["scope"] = p["scope"] + n["explicit_limits"] = p["explicit_limits"] + n["notes"] = p["notes"] + n["review_disposition"] = p["review_disposition"] + n["review_sources"] = [r["ref"] for r in p["review_sources"]] + n["review_basis"] = [{"review": r["ref"], "provider": r.get("provider", "unstated"), "verdict": r.get("verdict", "")} + for r in p["review_sources"]] + if p.get("coverage_source"): + n["coverage_source"] = p["coverage_source"] + for c in spec["proposed_graph_nodes"]: + new["nodes"][c["id"]] = {k: v for k, v in c.items() if k != "id"} + new["edges"] = list(new["edges"]) + [dict(e) for e in spec["proposed_graph_edges"]] + return new + +def check_transitions(root, spec): + graph = json.loads((root / GRAPH).read_text(encoding="utf-8")) + ok = spec.get("declarative") is True and spec.get("executed") is False and spec.get("edges_unchanged") is False + ids = [t["node"] for t in spec["transitions"]] + ok &= len(ids) == len(set(ids)) and len(ids) >= 1 + for t in spec["transitions"]: + p = t["proposed"] + ok &= p["classification"] == "PROVED_REVIEWED" and p["controlling"] is False + ok &= bool(p.get("scope")) and bool(p.get("explicit_limits")) and bool(p.get("notes")) + ok &= len(p.get("review_sources", [])) >= 1 + if t["kind"] == "candidate": + ok &= p.get("source") in INVENTORY and p["fingerprint"] == INVENTORY[p["source"]][0] + else: + ok &= t["kind"] == "region" and p.get("coverage_source") in ids + ok &= not t["node"].startswith(("hist.", "eng.", "regional.")) + # component nodes: one per byte identity, fingerprinted to the inventory, PROVED_REVIEWED evidence records, + # none for bytes the live graph already carries with a fingerprint (Codex 4139312869 on Math-#160) + comps = spec["proposed_graph_nodes"] + cids = [c["id"] for c in comps] + live_fp_sources = {n.get("source") for n in graph["nodes"].values() + if isinstance(n, dict) and n.get("fingerprint") and n.get("source")} + ok &= len(cids) == len(set(cids)) and not (set(cids) & set(graph["nodes"])) and len(comps) == spec["nodes_added"] + ok &= len({c["source"] for c in comps}) == len(comps) + for c in comps: + ok &= c["kind"] == "reading_rule_component" and c["classification"] == "PROVED_REVIEWED" and c["controlling"] is False + ok &= c["source"] in INVENTORY and c["fingerprint"] == INVENTORY[c["source"]][0] + ok &= c["source"] not in live_fp_sources + ok &= bool(c.get("component_role")) and bool(c.get("author_provider")) and len(c.get("review_basis", [])) >= 1 + consumers = c.get("components_of") or [c.get("component_of")] + ok &= all(x in ids + cids for x in consumers) and len(consumers) >= 1 + edges_new = spec["proposed_graph_edges"] + known = set(graph["nodes"]) | set(cids) + live_keys = {(e["from"], e["to"], e["relation"]) for e in graph["edges"]} + seen = set() + for e in edges_new: + ok &= {"from", "to", "required", "relation"} <= set(e) and type(e["required"]) is bool + ok &= e["from"] in known and e["to"] in known and bool(e["relation"].strip()) + key = (e["from"], e["to"], e["relation"]) + ok &= key not in seen and key not in live_keys + seen.add(key) + ok &= e["from"] in ids or e["from"] in cids # every added edge leaves one of this record's objects + ok &= len(edges_new) == spec["edges_added"] + if not ok: + return False, None + new = apply(spec, graph) + nodes = new["nodes"] + edges = new["edges"] + ok &= edges[:len(graph["edges"])] == graph["edges"] and len(edges) == len(graph["edges"]) + len(edges_new) + ok &= all(graph["nodes"][k] == nodes[k] for k in graph["nodes"] if k not in ids) # only the eight live nodes change + for t in spec["transitions"]: + nid = t["node"] + req = [e["to"] for e in edges if e["from"] == nid and e["required"] is True] + ok &= all(nodes[d]["classification"] == "PROVED_REVIEWED" for d in req) + ok &= sorted(req) == sorted(t["required_premises_after"]) + if t["kind"] == "region": + ok &= t["proposed"]["coverage_source"] in req # a region depends on its covering node + ok &= nodes[t["proposed"]["coverage_source"]]["classification"] == "PROVED_REVIEWED" + n = nodes[nid] + ok &= n.get("explicit_limits") == t["proposed"]["explicit_limits"] and n.get("notes") == t["proposed"]["notes"] + ok &= "review open" not in n["notes"] and "candidate only" not in n["notes"] + ok &= isinstance(n.get("review_basis"), list) and len(n["review_basis"]) >= 1 + for c in comps: # component nodes' own required premises + req = [e["to"] for e in edges if e["from"] == c["id"] and e["required"] is True] + ok &= all(nodes[d]["classification"] == "PROVED_REVIEWED" for d in req) + return bool(ok), new + +def load_hard_gate(root): + hg_spec = importlib.util.spec_from_file_location("hard_gate", root / HARD_GATE) + hg = importlib.util.module_from_spec(hg_spec) + hg_spec.loader.exec_module(hg) + return hg + + +def check_gate(root, spec, new): + if new is None: + return False, {} + hg = load_hard_gate(root) + old = json.loads((root / GRAPH).read_text(encoding="utf-8")) + try: + hg.validate_graph_fail_closed(new) + rep_new = hg.closure_report(new) + rep_old = hg.closure_report(old) + ri = hg.reverse_impact_between(old, new) + except Exception: + return False, {} + ok = rep_new.get("gate_ok") is True and not rep_new.get("illegal_controlling") + ok &= rep_old.get("gate_ok") is True + ok &= not any(n.get("controlling") for n in new["nodes"].values()) + changed = sorted([t["node"] for t in spec["transitions"]] + [c["id"] for c in spec["proposed_graph_nodes"]]) + imp = ri.get("impacted") if isinstance(ri, dict) else None + names = [] + if isinstance(imp, list): + for x in imp: + names.append(x if isinstance(x, str) else str(x.get("node") or x.get("id") or x)) + # loss-only rule: every changed node is itself in the impacted set + ok &= isinstance(ri, dict) and set(changed) <= set(names) + return bool(ok), {"changed_nodes": changed, "impacted": sorted(set(names)), "reverse_impact_keys": sorted(ri.keys()) if isinstance(ri, dict) else []} + + +def check_interface(): + """Finite content of RN_COUNT_INTERFACE_REVIEW.md: exact rational checks, and floating-point corroborations + labelled as such (OpenAI 5360320845 item 2).""" + ok = True + num = True + le = (lambda a, b: a >= b) if MUT == "holder-reversed" else (lambda a, b: a <= b) + # (N1) on finite rational spaces, p = 2 and p = 3 (Cauchy-Schwarz / Holder in power form) + spaces = [([F(1, 4)] * 4, [0, 1, 3, 7], [1, 0, 1, 0]), ([F(1, 2), F(1, 3), F(1, 6)], [2, 5, 11], [1, 1, 0]), + ([F(1, 8), F(3, 8), F(1, 2)], [0, 0, 9], [0, 0, 1]), ([F(9, 10), F(1, 10)], [0, 13], [0, 1])] + for probs, N, E in spaces: + assert sum(probs) == 1 + ene = sum(p * n * e for p, n, e in zip(probs, N, E)) + pe = sum(p * e for p, e in zip(probs, E)) + m2 = sum(p * n * n for p, n in zip(probs, N)) + m3 = sum(p * n ** 3 for p, n in zip(probs, N)) + ok &= le(ene ** 2, m2 * pe) and le(ene ** 3, m3 * pe ** 2) + if pe > 0: # (N3) + ok &= ene == pe * (ene / pe) + # (N2) exponent: (3(p-1) - beta)/p == 3 - 3/p - beta/p + for p in (2, 3, 5): + for beta in (F(0), F(1, 2), F(3)): + ok &= F(3 * (p - 1), 1) / p - beta / p == 3 - F(3, p) - beta / p + # (N4), NUMERICAL (floating point): r = e^-t, t = 1..12: E N / r^3 = ceil(t) increases; ceil(t)^p e^-3t <= (t+1)^p e^-3t, + # and the grid maximum of (t+1)^p e^-3t stays below the located critical value. The proof is the log-derivative argument. + for p in (1, 2, 4, 7): + vals = [math.ceil(t) ** p * math.exp(-3 * t) for t in range(1, 13)] + bound = [(t + 1) ** p * math.exp(-3 * t) for t in range(1, 13)] + num &= all(v <= b + 1e-15 for v, b in zip(vals, bound)) + tmax = max(1.0, p / 3 - 1) # critical point of (t+1)^p e^{-3t} + sup = (tmax + 1) ** p * math.exp(-3 * tmax) + grid = [(t / 100 + 1) ** p * math.exp(-3 * (t / 100)) for t in range(100, 400000, 7)] + num &= max(grid) <= sup + 1e-9 and math.isfinite(sup) + ok &= all(math.ceil(t) > math.ceil(t - 1) for t in range(2, 13)) # E N_r / r^3 -> infinity along the grid (exact integers) + # sharp p: r = 2^{-p m}: E N^p = 1, E N = r^{3-3/p} exactly + for p in (2, 3, 4): + for m in (1, 2, 3): + r = F(1, 2 ** (p * m)) + n_r = 2 ** (3 * m) # = ceil(r^{-3/p}) exactly + ok &= n_r ** p * r ** 3 == 1 and le(F(1), F(2 ** p)) and n_r * r ** 3 == F(1, 2 ** (3 * m * (p - 1))) + ok &= n_r * r ** 3 == r ** 3 / r ** F(3, 1) * F(1, 2 ** (3 * m * (p - 1))) # r^{3-3/p} = 2^{-3m(p-1)} + # (N5), NUMERICAL (floating point): int_0^inf min(q, A e^{-t/B}) dt = B q (1 + log(A/q)), q <= A; Simpson quadrature at + # three parameter points corroborates the antiderivative identity proved in the review + for (A, B, q) in ((1.0, 1.0, 0.1), (20.0, 0.5, 0.001), (3.0, 2.0, 2.0)): + t0 = B * math.log(A / q) + n = 200000 + T = t0 + 60 * B + h = T / n + s = 0.0 + for i in range(n + 1): + t = i * h + w = 1 if i in (0, n) else (4 if i % 2 else 2) + s += w * min(q, A * math.exp(-t / B)) + quad = s * h / 3 + num &= abs(quad - B * q * (1 + math.log(A / q))) <= 1e-6 * B * q * (1 + math.log(A / q)) + # uniform tail of the (N4) example, NUMERICAL (floating point): P(N_r > t) = r^3 1{t < ceil(log 1/r)} <= e^3 e^{-3t} + for s_ in range(1, 15): + r3 = math.exp(-3 * s_) + for t10 in range(0, 10 * s_ + 30): + t = t10 / 10 + p_tail = r3 if t < math.ceil(s_) else 0.0 + num &= le(p_tail, math.exp(3) * math.exp(-3 * t) + 1e-300) + return {"exact": bool(ok), "numerical_corroboration": bool(num)} + + +def check_negatives(src): + rejected = [] + for fault in ("delete", "change", "symlink", "symlink-parent"): + with tempfile.TemporaryDirectory() as tmp: + root = pathlib.Path(tmp) + for path in INVENTORY: + dst = root / path + dst.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(src / path, dst) + target = root / D4 + if fault == "delete": + target.unlink() + elif fault == "change": + target.write_bytes(target.read_bytes() + b"\n") + elif fault == "symlink": + moved = root / "elsewhere" / "PROOF.md" + moved.parent.mkdir() + shutil.move(str(target), str(moved)) + os.symlink(moved, target) + else: + moved = root / "elsewhere_dir" + shutil.move(str(target.parent), str(moved)) + os.symlink(moved, target.parent) + rejected.append(not identities_ok(root)) + return all(rejected) + + +def check_d4_duplicate(root, spec): + """Since ec6db8c (Math-#151) the live graph carries the D4 bytes twice; bind the duplicate to the D4 transition.""" + live = json.loads((root / GRAPH).read_text(encoding="utf-8"))["nodes"] + dup = live.get(D4_DUP) + old = live.get(D4_NODE) + t = next(t for t in spec["transitions"] if t["node"] == D4_NODE) + want = spec["live_duplicate"] + fp = t["proposed"]["fingerprint"] + if MUT == "duplicate-drift": + fp = "1" * 64 + if not isinstance(dup, dict) or not isinstance(old, dict): + return False + ok = dup.get("classification") == "PROVED_REVIEWED" and dup.get("controlling") is False + ok &= dup.get("fingerprint") == fp == want["fingerprint"] == INVENTORY[t["proposed"]["source"]][0] + ok &= dup.get("source") == t["proposed"]["source"] == want["source"] + ok &= dup.get("component_of") == want["component_of"] + ok &= any("main#76" in str(b.get("review")) and b.get("verdict") == "ACCEPT" for b in dup.get("review_basis", [])) + ok &= old.get("fingerprint") == dup.get("fingerprint") and old.get("classification") == t["current"]["classification"] + return bool(ok) + + +def snapshot(root, graph): + """Source snapshot in the shape of git_transition_audit.read_snapshot, taken from the working tree.""" + out = {} + for nid, node in graph["nodes"].items(): + ref = node.get("source") + if ref is None: + out[nid] = {"kind": "record_only"} + continue + if ref.startswith(("https://", "http://", "external:")): + out[nid] = {"kind": "external_unresolved", "reference": ref} + continue + p = root / ref.rstrip("/") + if p.is_file(): + data = p.read_bytes() + out[nid] = {"kind": "blob", "reference": ref, "bytes": len(data), "sha256": hashlib.sha256(data).hexdigest()} + elif p.is_dir(): + h = hashlib.sha256() + for f in sorted(x for x in p.rglob("*") if x.is_file() and "__pycache__" not in x.parts): + h.update(str(f.relative_to(p)).encode("utf-8") + b"\0" + hashlib.sha256(f.read_bytes()).digest()) + out[nid] = {"kind": "tree", "reference": ref, "sha256": h.hexdigest()} + else: + out[nid] = {"kind": "missing", "reference": ref} + return out + + +def check_propagation(root, spec, new): + """Two-commit mutations on the proposed graph through the production loss-only rule (reverse_impact_between with + source snapshots): evidence and consumed-source changes must reach the objects they support (OpenAI 5360320845, + 5360327058; Codex 4139807558, 4139807567). Nothing scientific is decided here.""" + if new is None: + return False, {} + hg = load_hard_gate(root) + g = copy.deepcopy(new) + if MUT == "region-unlinked": + g["edges"] = [e for e in g["edges"] if e.get("relation") != "covered_by"] + if MUT == "review-metadata-only": + drop = {c["id"] for c in spec["proposed_graph_nodes"] if str(c.get("component_role", "")).startswith("review_record")} + g["nodes"] = {k: v for k, v in g["nodes"].items() if k not in drop} + g["edges"] = [e for e in g["edges"] if e["from"] not in drop and e["to"] not in drop] + base = snapshot(root, g) + by_source = {} + for nid, n in g["nodes"].items(): + if n.get("source"): + by_source.setdefault(n["source"], []).append(nid) + + def run(edit): + g2, s2 = copy.deepcopy(g), copy.deepcopy(base) + edit(g2, s2) + try: + return set(hg.reverse_impact_between(g, g2, old_sources=base, new_sources=s2)["impacted"]) + except Exception: + return None + + def source_edit(path, kind="blob"): + def f(g2, s2): + for nid in by_source.get(path, []): + s2[nid] = ({"kind": "blob", "reference": path, "bytes": 1, "sha256": "1" * 64} if kind == "blob" + else {"kind": "missing", "reference": path}) + return f + + def fp_edit(g2, s2): + g2["nodes"][D4_NODE]["fingerprint"] = "2" * 64 + + eight = {t["node"] for t in spec["transitions"]} + cases = { + "d4-proof-edit-reaches-region-and-consumer": (source_edit(D4), {D4_NODE, "math.rn-region.fixed-remote", "math.rn-mesoscopic-reduction"}), + "annulus-proof-edit-reaches-region": (source_edit("frontiers/rn_thin_tube_20260925/FIXED_ANNULUS_CANDIDATE.md"), + {"math.rn-fixed-annulus-window", "math.rn-region.fixed-annulus-window"}), + "interface-review-deleted-reaches-interface-consumers-regions": (source_edit(HERE + "/RN_COUNT_INTERFACE_REVIEW.md", "missing"), + {IFACE, D4_NODE, "math.rn-fixed-annulus-window", "math.rn-region.fixed-remote", "math.rn-region.fixed-annulus-window"}), + "external-review-record-edit-reaches-d2-d3-d4-d6": (source_edit(HERE + "/EXTERNAL_REVIEWS.md"), + {"math.lifetime-remainder", "math.side24-coefficient", D4_NODE, "math.p15-full-price", "math.rn-region.fixed-remote"}), + "two-scale-addendum-edit-reaches-annulus-and-region": (source_edit("frontiers/rn_thin_tube_20260925/TWO_SCALE_ADDENDUM.md"), + {"math.rn-fixed-annulus-window", "math.rn-region.fixed-annulus-window"}), + "realized-covers-edit-reaches-d6": (source_edit("frontiers/three_fronts_20260924/P15_REALIZED_COVERS.md"), {"math.p15-full-price"}), + "d4-fingerprint-edit-reaches-region": (fp_edit, {D4_NODE, "math.rn-region.fixed-remote"}), + } + results = {} + for name, (edit, must) in cases.items(): + imp = run(edit) + results[name] = imp is not None and must <= imp + imp = run(source_edit("reviews/d5_collar_count_20260928/REVIEW.md")) + results["unrelated-edit-leaves-the-eight-untouched"] = imp is not None and not (imp & eight) + imp = run(lambda g2, s2: None) + results["no-op-impacts-nothing"] = imp == set() + return bool(all(results.values()) and len(results) == 9), results + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument("--mutant", choices=MUTANTS) + MUT = ap.parse_args().mutant + root = pathlib.Path(".").resolve() + spec = load_spec(root) + ident = identities_ok(root) + trans_ok, new = check_transitions(root, spec) + gate_ok, gate = check_gate(root, spec, new) + prop_ok, prop = check_propagation(root, spec, new) + iface = check_interface() + checks = {"IDENTITIES": ident, "VERDICTS": ident and check_verdicts(root), "BASELINE": check_baseline(root, spec), + "TRANSITIONS": trans_ok, "GATE": gate_ok, "PROPAGATION": prop_ok, + "INTERFACE": iface["exact"] and iface["numerical_corroboration"], "NEGATIVES": check_negatives(root), + "D4_DUPLICATE": check_d4_duplicate(root, spec)} + passed = all(checks.values()) and len(checks) == 9 + print(json.dumps({"object": "REGISTER-ALIGNMENT-20260930-v1", "checks": checks, "passed": passed, + "inventory_files": len(INVENTORY), "transitions": len(spec["transitions"]), + "component_nodes": len(spec["proposed_graph_nodes"]), "edges_added": len(spec["proposed_graph_edges"]), + "gate": gate, "propagation": prop, + "interface_evidence": {"exact_rational": ["(N1) Holder p=2,3 on finite rational spaces", "(N2) exponent identity", + "(N3) conditional-mean identity", "sharp-p example at r=2^-pm", + "(N4) integer monotonicity of ceil(t)"], + "numerical_corroboration_floating_point": ["(N4) grid maximum of (t+1)^p e^-3t", + "(N5) Simpson quadrature at three parameter points", + "(N4) example uniform tail on a grid"], + "results": iface}, + "scope": "identity, verdict-row, live-baseline, transition-shape, hard-gate replay, two-commit propagation, " + "interface arithmetic (exact and numerical parts labelled), filesystem-negative and live D4-duplicate " + "checks; no mathematics is re-proved; nothing is written"}, indent=2, sort_keys=True)) + return 0 if passed else 1 + + +if __name__ == "__main__": + sys.exit(main())