diff --git a/claims/README.md b/claims/README.md index 60bf695e6..c20cedca8 100644 --- a/claims/README.md +++ b/claims/README.md @@ -1,7 +1,7 @@ # Claim / premise dependency graph -`graph.json` is the program's claim structure as data: 24 claims, 13 named -premises, 8 firewalls. `tools/claims_check.py` turns the firewalls into +`graph.json` is the program's claim structure as data: 27 claims, 13 named +premises, 13 firewalls. `tools/claims_check.py` turns the firewalls into assertions; `tests/test_claims.py` proves the checker actually rejects each violation it is supposed to reject. @@ -62,7 +62,7 @@ the registers' own technical statuses `NEEDS_RECONCILIATION` and | `arithmetic` | `exact_rational`, `interval_*`, `not_applicable`, `float`, `mpmath_float`, … — or, when it comes from a carrier manifest, that manifest's own sentence | | `certifying` | what the artifact's own record says about itself. It is used **only to refuse**; it never grants anything | -## The eight firewalls +## The thirteen firewalls | ID | Rule | Source | |---|---|---| @@ -74,6 +74,11 @@ the registers' own technical statuses `NEEDS_RECONCILIATION` and | `FW-LM011-PRECONDITION` | the RV-LM011 synthesis route may not be marked satisfiable while any named prerequisite is unsatisfied, and a technical pass at **zero** organizational independence credit does not discharge an independence-requiring gate | `review_queue.json` RV-LM011-MAIN; `easy_closure_queue.json` P02-LM-011; `docs/OPEN_PROBLEMS.md` §D | | `FW-NO-RECEIPT-PROMOTION` | a receipt, a green test run, a reproduction or a carrier binding may never raise a grade or move a status, on a claim or on a premise | `engine/README.md`; OP-PROT-012 §4(c); OP-GDN-002 §6 | | `FW-FLOAT-NOT-CERTIFIED` | high precision is not certification: no evidence may be `certifying` while its arithmetic is float, and no certified/enclosed claim may rest solely on float evidence | `engine/README.md`; `engine/rn_engine/BINDING.json`; `README.md` status discipline | +| `FW-RETRACTED-NOT-UNCONDITIONAL` | a transcribed retraction cannot carry an unconditional grade | the graph's retraction record and register source | +| `FW-PROPOSED-LAYER-NOT-A-STATUS` | a proposed transition cannot become a current status by copying its words | the graph's proposed-layer source | +| `FW-RUNG-OPEN-PREMISE` | each existing certifying grade (`FROZEN_CERTIFICATE`, `CERTIFIED_RUNG`, `AUTHOR_SIDE_CERTIFIED`) requires a discharged word in **both** columns of every transitive premise; absent, unknown and malformed statuses refuse. The repaired D1 operational grade must also be a known string | D1 frozen body, existing certifying-grade vocabulary, and the [reviewed convergence contract](../docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md) | +| `FW-RN-FLOOR-DEPENDENCY` | RN3-FAR and RN5-NEAR-POINT-CERTS name H3-RUNG-FLOOR, not the distinct H3 band input | frozen runner `_PINS` and `Z_LO` parser | +| `FW-RN-FLOOR-SOURCE` | refuse missing, changed, misattributed or symlinked rung-source bytes and report reverse consumers | frozen runner pin; [bounded source contract](../docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md) | Plus referential integrity, acyclicity, "a CONDITIONAL claim must name at least one premise", "`technical_status` and `grade` may not drift apart", and "an @@ -140,7 +145,7 @@ python3 -m pytest tests/test_claims.py -q # firewalls + negative controls ``` `tests/test_claims.py` runs the checker on the committed graph and then breaks a -**copy** of it in twenty-two ways — promoting a conditional theorem, composing +**copy** of it in multiple ways — promoting a conditional theorem, composing 2D with 3D, leaking the prize track, dropping the decimal kill, unwiring a RV-LM011 prerequisite, spending a zero-independence pass on an independence gate, letting a receipt discharge a premise, calling a float certifying — and @@ -150,6 +155,20 @@ from something incidental. Every mutation is passed to the checker with an explicit `--graph`: a default-argument bug once made these tests silently re-check the good graph and pass regardless. +## Audit convergence proposal + +D1-v2.2(1) preserves the frozen `CERTIFIED_RUNG` source word but is operationally +`CONDITIONAL` / `HOLD_WITH_DOMAIN`, matching the corrected hardening profile. +The RN premise and H5 hypotheses remain unresolved. The source statement and +its numerical terms are historical transcription, not newly certified bounds; +the annulus-number defect and RN3 AMEND review remain explicit in its note. + +H3-RUNG-FLOOR is a distinct author-side single-rung object with zero independence +credit. The rung-source check reads repository bytes only, fails without changing +any status, and reports reverse consumers. It is **not** the hardening transition +adapter, a live Drive watcher, or a mathematical re-review. See the +[repair scope and update procedure](../docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md). + ## Updating it When a source status changes, edit the matching `status_frozen_v2_2`, diff --git a/claims/graph.json b/claims/graph.json index 4d7fab0e5..9d1efe9eb 100644 --- a/claims/graph.json +++ b/claims/graph.json @@ -180,15 +180,17 @@ "D1-v2.2(1)": { "track": "UPPER2D", "statement": "Certified rung bound at r = 0.05: 1 − q(0.05, 6/5) ≤ Ĩ_hi + C_RN(0.05)·√Q_{0.05}(B1.dir) + P_{0.05}(B2) + P_{0.05}(B4), with E_w(0.05) ≤ Ĩ_hi = 8.1272827e-2 = 650.1827·(0.05)³ (chart part = I_hi(v3) − 19.55·(0.05)³ = 628.2548·(0.05)³, where I_hi(v3) = 8.0975589252e-2 = 647.8048·(0.05)³ is the H5 chart total, pin 8d7028e4…; remote part = B_remote·(0.05)³ = 21.9279·(0.05)³) and C_RN(0.05) ≤ 3.46.", - "grade": "CERTIFIED_RUNG", + "grade": "CONDITIONAL", "rung": 0.05, "depends_on": [ "H5-RIM", "H5-AXIS", "D3-LEMMA-RN-UNIF" ], - "note": "D3-LEMMA-RN-UNIF is used at the rung only and is precisely stated, NOT closed. Until 2026-09-19 the statement gave the H5 chart total I_hi(v3) = 647.8048·r³ as the theorem's content; the theorem's own display (D1_ASSEMBLY_v2_2.md §1, mirrored byte-exact) is the bound above.", - "source": "D1_ASSEMBLY_v2_2.md (frozen body sha 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6)" + "note": "D3-LEMMA-RN-UNIF is used at the rung only and is precisely stated, NOT closed. Fail-closed audit 2026-09-25 therefore preserves the source label CERTIFIED_RUNG in source_grade_verbatim but records the current operational grade as CONDITIONAL until that named premise closes. Until 2026-09-19 the statement gave the H5 chart total I_hi(v3) = 647.8048·r³ as the theorem's content; the theorem's own display (D1_ASSEMBLY_v2_2.md §1, mirrored byte-exact) is the bound above. The remote part B_remote = 21.9279 r^3 carries DEFECTIVE_SCOPE hold Q-RN5-MOMENT-003: it rests on I_ann = 17.6804 r^3, which is not a certified upper bound because envelope_v is refuted by the RN5 counterexample. The far component is independently dominated by RN3-FAR (I_far < 2.83312 r^3); that route's review record reviews/records/REV-RN3-FARZONE-20260918.json is technical_verdict AMEND (zero credit), so the domination is conditional on those findings, not pending a missing reviewer. This note changes no grade or flag (walk-down ledger Drive 1X7ha4isKl9q73PlSQm8c-n-w4jy5J3lE, NONAUTHORITATIVE).", + "source": "D1_ASSEMBLY_v2_2.md (frozen body sha 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6)", + "source_grade_verbatim": "CERTIFIED_RUNG", + "audit_disposition": "HOLD_WITH_DOMAIN" }, "D1-v2.2(2)": { "track": "UPPER2D", @@ -219,7 +221,7 @@ "statement": "At r = 1/20, fixed axis: 0.88021 < rho/rho_ref < 1.12058 over all 13,604 quarter-grid boxes meeting 5 <= |y| <= 17 and every mark v in [6/5 - r^3/6, 6/5]; hence 2.22542 r^3 < I_far < 2.83312 r^3.", "grade": "AUTHOR_SIDE_CERTIFIED", "depends_on": [ - "H3-BAND-FLOOR" + "H3-RUNG-FLOOR" ], "independence_credit": 0, "note": "Fixed r, fixed axis. Near annulus and all-small-r remain open. Uses the correct typed second determinant moment and is outside the RN5 defect scope.", @@ -254,7 +256,7 @@ "statement": "65 point-law certificates on the 13-radius, 5-angle D4 net plus 10 spatial-box certificates for the corrected near-region moment bound, at 384 bits.", "grade": "AUTHOR_SIDE_PARTIAL", "depends_on": [ - "H3-BAND-FLOOR" + "H3-RUNG-FLOOR" ], "independence_credit": 0, "note": "Ten boxes do NOT cover the annulus. Diagnostic polar sums (2.34195 r^3 corrected, 17.67237 r^3 wrong-power) are not bounds on the spatial integral.", @@ -745,6 +747,48 @@ "next_action_verbatim": "Execute R1–R10 in bundle; reconstruct Holder, L2 Taylor remainders and marginal whitening; then extend complete near cover", "note": "Transcribed 2026-09-19 from the 2026-09-18 xlsx export's review_queue row (the route was created 2026-09-17, after the markdown export). READY is the register's word for a route ready for review; it grades nothing, and independence_credit is 0. The easy_closure_queue tab carries no row for this route, which the field easy_closure_queue_row records explicitly. The RN5 candidate 'No annulus cover, no all-small-r extension, no external acceptance' (Scope / dependencies); D3-LEMMA-RN-UNIF stays not closed and the five validity premises stay OPEN. Nothing here composes with the 3D track.", "source": "registers/json/review_queue.json row RV-RN5-MOMENT-REPAIR (2026-09-18 xlsx export); no easy_closure_queue row exists for this route; packet https://drive.google.com/file/d/1LtnvNd0vAW-y3pzbyHLjgtF7Uw5sTph5/view" + }, + "H3-RUNG-FLOOR": { + "track": "UPPER2D", + "statement": "At r = 0.05 only (six-pin law Q_{0.05}, mark 6/5): Z_{0.05} in [7.7592917375327855e-3, 1.1468646473404396e-2]. It is a single-rung enclosure, not a band or uniform-in-r statement.", + "grade": "AUTHOR_SIDE_CERTIFIED", + "source_grade_verbatim": "CERTIFIED_RUNG", + "audit_disposition": "LABEL_PRESERVED_NOT_CONTROLLING", + "rung": 0.05, + "depends_on": [], + "independence_credit": 0, + "note": "Hardening-profile history, transcribed from a01c72f1937875b94bfd78e183a6dbbdb2b04da4: Added 2026-09-25 so that RN3-FAR and RN5-NEAR-POINT-CERTS name the floor they actually consume (the rung value 0.0077592917..., which d3_rn_unif.py L74-81 parses and fail-closes on), not H3-BAND-FLOOR (c_Z r^2 uniform on (0, 0.05], a different statement). The rung lower end exceeds c_Z*(0.05)^2 = 4.0387e-3, but the enclosure is computed directly and does not use the band floor. Transcription only; no grade of any other node moves. Gate reconciliation 2026-09-27: the object's own label CERTIFIED_RUNG is kept in source_grade_verbatim; the operational grade is AUTHOR_SIDE_CERTIFIED (same strength, zero independence credit) because claims_gate_adapter treats CERTIFIED_RUNG as a controlling status and refuses a new controlling node introduced by merge (UNSUPPORTED_CONTROLLING_PROMOTION). A merge is not a positive admission; a nonauthor review filed against this node is the route to the verbatim label. This migration proposal preserves that mapping but does not install claims_gate_adapter or its transition machinery; its source contract is a read-only refusal only.", + "evidence": [ + { + "kind": "frozen_certificate_body", + "ref": "engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/H3_closure/H3_RUNG_FLOOR.md, 7003 bytes, sha256 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa (STAGE E REPAIR R2, 2026-09-13)", + "arithmetic": "interval (mpmath iv, 100 dps)", + "certifying": true, + "note": "Arithmetic transcribed from the object's own declaration ('everything below is interval arithmetic (mpmath iv, 100 dps)'; 'no Monte Carlo in the certificate'). certifying: true records what the object asserts. It is not an independence credit or an external verdict." + }, + { + "kind": "carrier_binding", + "ref": "engine/rn_engine/BINDING.json carrier RNENG-08", + "carrier_id": "RNENG-08", + "arithmetic": "not applicable (Markdown artifact)", + "certifying": false, + "note": "Byte-exact carrier recovery is provenance, not proof." + } + ], + "source": "H3_RUNG_FLOOR.md (H3-closure line, companion to the frozen H3_CLOSURE.md)", + "source_bindings": [ + { + "repo": "d6g8k5htny-coder/main", + "path": "engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/H3_closure/H3_RUNG_FLOOR.md", + "role": "scientific_object", + "extraction_rule": "whole_file", + "expected_sha256": "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa", + "mirror_freshness": "external_sync_obligation", + "freshness_meaning": "GitHub monitors the frozen H3_RUNG_FLOOR.md bytes in this repository (7,003 B, recovered byte-exact as carrier RNENG-08 in engine/rn_engine/BINDING.json). Drive sync/readback is an external provenance obligation; GitHub does not watch Drive live.", + "note": "Binding added 2026-09-27 so that this controlling node names monitorable repository bytes; the prose `source` field was unresolved and the claims gate refused every transition. Transcription only; no grade moves.", + "expected_bytes": 7003 + } + ] } }, "firewalls": [ @@ -797,6 +841,21 @@ "id": "FW-PROPOSED-LAYER-NOT-A-STATUS", "rule": "A PROPOSED-tier promotion transcribed verbatim in this graph is a record of what a source proposed, never a status. An entry carrying proposed_layer_verbatim must name its proposed_layer_source, that source must record the tier and the authority the proposal carries, the value the transition PROPOSES must appear in no status or grade field of that entry, and every status field must still carry the pre-promotion value. No status or grade field anywhere may hold a transition: a status is a value, not an arrow. Only the operator applies the licensing predicate.", "source": "claims/graph.json premises.OBL-H5-ZBAND.proposed_layer_source, transcribing H5_ZBAND_CONSUMPTION_2026-09-15.md (Drive 18R0wwSFHa--ZMdLRV3ElMO0T5u5YD3lk, mirrored byte-exact): 'STATUS: PROPOSED · AUTHORITY: none'. Added 2026-09-22 after the pull request's owner flagged the skim-trap in d6g8k5htny-coder/main#2 (comment 5785276754): the verbatim 'OPEN → DISCHARGED (consumption grade)' string was contained by field naming and prose only, and tools/claims_check.py did not know the field existed. 'Green CI ≠ discharge.'" + }, + { + "id": "FW-RUNG-OPEN-PREMISE", + "rule": "A claim operationally graded FROZEN_CERTIFICATE, CERTIFIED_RUNG or AUTHOR_SIDE_CERTIFIED must have a discharged word (CLOSED, DISCHARGED, PROMOTED, SATISFIED, CERTIFIED) in both status_frozen_v2_2 and status_register_note for every transitive premise. Missing, unknown, malformed and empty status records are refused. The repaired D1-v2.2(1) operational grade must be a known string from the existing strength vocabulary; this is not global validation of unrelated historical labels. Historical source labels may be preserved in source_grade_verbatim; this checker never discharges a premise.", + "source": "Fail-Closed Claim Audit 2026-09-25; D1_ASSEMBLY_v2_2.md §1 names D3-LEMMA-RN-UNIF(r=0.05) as NOT closed" + }, + { + "id": "FW-RN-FLOOR-DEPENDENCY", + "rule": "RN3-FAR and RN5-NEAR-POINT-CERTS must name H3-RUNG-FLOOR, the frozen runner input, rather than the distinct H3-BAND-FLOOR. No premise is discharged.", + "source": "engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_rn_unif.py, _PINS and Z_LO parser; SI02 source comparison" + }, + { + "id": "FW-RN-FLOOR-SOURCE", + "rule": "The H3-RUNG-FLOOR input must retain its exact repository, canonical path, whole-file extraction, 7003-byte length and SHA-256 from the frozen runner. Missing, altered, misattributed or symlinked input is refused; reverse consumers are diagnostic only.", + "source": "engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_rn_unif.py _PINS; engine/rn_engine/BINDING.json carrier RNENG-08; docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md" } ] } diff --git a/docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md b/docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md new file mode 100644 index 000000000..9a7768d70 --- /dev/null +++ b/docs/CLAIM_CONVERGENCE_PROPOSAL_20261002.md @@ -0,0 +1,152 @@ +# SI01 / SI02 bounded migration convergence proposal + +This is an isolated post-audit-cut engineering proposal. It does not change the +historical audit inputs, publish a scientific verdict, or authorize integration. +The two issues are independent: correcting a graph label is not checker evidence, +and a checker refusal is not a proof or a deployed status-transition system. + +## Exact base, reference, and authorship + +- Migration base: `534f4fce08be919cb969ca87963c5210148497a1`, branch + `claude/drive-audit-github-migration-rrglpp`, repository + `d6g8k5htny-coder/main` +- Corrected reference: hardening `a01c72f1937875b94bfd78e183a6dbbdb2b04da4`, + `claims/graph.json`, `tools/claims_check.py`, and + `docs/FAIL_CLOSED_CLAIM_AUDIT_REPAIRS_20260925.md` +- Previous source edits identify Anthropic session + `01Cz7WZybv8znP64SpPj6sWY` in commits `b1335def2615888463e2d134294ef451895b8d0d` + and `b011cddfa87dee95d3357f5d912ebd38693ed36a`; Git account metadata is not + evidence of current active ownership +- This proposal: OpenAI/Codex, source-exposed implementation. Nonauthor exact-head + engineering review is required before integration. Same-provider technical + review earns zero organizational-independence credit + +## SI01: preserve the conditional result and refuse the historical over-grade + +The frozen D1-v2.2(1) body calls itself a certified rung and explicitly depends on +RN-UNIF, which is NOT_CLOSED/OPEN. The migration checker did not apply its +unconditional-grade rule to `CERTIFIED_RUNG`. It accepted open, unknown, missing, +and conflicting status columns under that grade. + +The selected hardening correction is ported without replacing the whole graph: +operational `CONDITIONAL`, original `source_grade_verbatim: CERTIFIED_RUNG`, and +`HOLD_WITH_DOMAIN`. The statement, source identity, and dependency list remain +unchanged. The reference note preserves Q-RN5-MOMENT-003's annulus-number defect +and RN3's AMEND review with zero credit; neither number is newly certified. + +`FW-RUNG-OPEN-PREMISE` retains the hardening discharge contract: every transitive +premise of a certifying claim must have one of CLOSED, DISCHARGED, PROMOTED, +SATISFIED, CERTIFIED in **both** status columns. Missing, unknown and malformed values refuse. An empty known premise +record is checked rather than skipped by truthiness; the reference profile +rejects it through broader validation, which this bounded port does not import. This rule never writes +those words or determines scientific discharge. Other migration firewalls are +preserved; this is not a complete backport of unrelated hardening behavior. + +### Readiness-review successor: close the equivalent-grade bypass + +The first published candidate `34e946cb5009fea769e416e5905ebe4cbb850189` +copied the hardening loop's exact `CERTIFIED_RUNG` selector. Automated review +[4168807065](https://github.com/d6g8k5htny-coder/main/pull/237#discussion_r4168807065) +found that changing D1's operational grade to `AUTHOR_SIDE_CERTIFIED` still +passed with RN-UNIF open. Author and nonauthor normal/optimized CLI reproductions +confirmed it. Earlier successful checks and review records remain evidence for +that older candidate, not a claim that this bypass was absent. + +The successor applies the same both-column, transitive premise test to the +already declared `CERTIFYING_GRADES`: FROZEN_CERTIFICATE, CERTIFIED_RUNG and +AUTHOR_SIDE_CERTIFIED. This deliberately strengthens the hardening rung-only +selector, rather than treating that older loop as complete firewall authority. +No grade strength, vocabulary entry, status or claim mapping is changed. A +certified leaf with no premise is not assigned an invented obligation; existing +RN3/H3 author-side scope remains valid under this repository refusal. The +source-verbatim label alone never triggers the guard. + +The repaired D1 mapping additionally rejects an unknown, absent or non-string +operational grade before grade-set lookups, with a controlled diagnostic. This +prevents replacing a recognized certifying word with an unrecognized spelling +or malformed value to evade the same boundary. The check uses the existing +strength vocabulary only for D1; unrelated historical labels, including +P14-A..E's AUTHOR_SIDE_COMPLETE, are preserved. Known noncertifying D1 labels +retain their existing behavior. This is not complete graph-schema validation. +A legitimate new D1 operational label requires an explicitly reviewed successor +mapping and corresponding vocabulary/guard tests; it must not be added merely +to silence this refusal. Passing this structural test licenses no status move. + +The authority concern in +[4168807052](https://github.com/d6g8k5htny-coder/main/pull/237#discussion_r4168807052) +is addressed by the precise boundary in the +[migration-only disposition](https://github.com/d6g8k5htny-coder/main/pull/237#issuecomment-5958959846): +Dylan's explicit repair request authorizes loss-only repository presentation, +refusal and source routing. The historical AGENTS/CLAUDE no-reclassification +rule remains controlling for authoritative scientific verdicts. The original +CERTIFIED_RUNG source word, proof body, premise records and conditional truth +remain unchanged; the existing hardening correction supplies the operational +mapping. This is not an operator promotion or a rewrite of source truth. + +## SI02: identify the actual consumed source + +RN3-FAR and RN5-NEAR-POINT-CERTS now name H3-RUNG-FLOOR. H3-BAND-FLOOR remains a +separate unchanged node; this proposal does not dispute or re-review its claim. +The new node keeps the hardening profile's single-rung scope at r = 0.05, +`AUTHOR_SIDE_CERTIFIED`, original `CERTIFIED_RUNG` label and zero credit. Its +reference note explicitly distinguishes hardening's transition machinery from +this migration proposal. + +The actual frozen runner is +`engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_rn_unif.py`, +SHA-256 `85d7725fab42eeb0e823226f44d17f142a5c57e5d89084b2b6edffe4a8f0c930`. +Its `_PINS` binds `../H3_closure/H3_RUNG_FLOOR.md`, it opens that exact file, +and its parser requires lower endpoint `7.7592917375327855e-3`. Thus the source +match is based on executed consumption logic and a byte pin, not a similar title. +No frozen runner or proof body is modified or executed by the new checker. + +### Bounded source contract and deliberate update procedure + +`FW-RN-FLOOR-SOURCE` validates the single binding against the runner's existing +fixed input contract, then verifies the actual repository file: + +- Repository: `d6g8k5htny-coder/main` +- Path: `engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/H3_closure/H3_RUNG_FLOOR.md` +- Extraction: whole file, exactly 7,003 bytes +- SHA-256: `6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa` +- No symlink components, missing/non-file input, alternative repository/path, + unknown extraction, malformed digest/length, or graph-only coherent re-pin + +`FW-RN-FLOOR-DEPENDENCY` refuses substituting the band node for either known RN +consumer. Refusals name the floor and reverse consumers, without writing a new +status. Unrelated documentation changes do not invalidate this contract. + +This is deliberately narrower and stricter than a generic mutable binding: +migration has no reviewed transition adapter that could justify changing the +consumed scientific input. The constants transcribe an already frozen runner +contract; they create no new mathematical authority. Altering both the file and +the graph cannot silently make a new input validate itself. + +For a legitimate successor: retain the original frozen files; identify the +numbered successor runner and source, all affected consumers, and exact byte +identities; provide the review/disposition that supports using that new input; +then propose a scoped update to this contract, graph, and regression fixtures +for nonauthor review. Do not merely update a digest to silence a failed check. +A reviewed deployment of the hardening transition adapter is a separate design, +not something this patch has installed. + +## Verification and unresolved boundaries + +Run `python3 tools/claims_check.py` and +`python3 -m pytest tests/test_claims.py tests/test_claims_audit_convergence.py -q`. +The new tests use explicit `--graph` CLI calls in normal and optimized Python, +including positive controls, direct/transitive open premises, both status +columns, lost/altered/symlink sources, coherent source-plus-graph re-pinning, +wrong dependencies, exact runner consumption, and unrelated-document controls. + +The full repository suite and workflow checks, exact preservation evidence, +and nonauthor review are separate required records at the candidate head. +This document does not imply those checks passed before they are recorded. + +No live Drive status is inferred from these historical exports. No premise, +lemma, theorem or prize is promoted; the conditional truth and historical +labels remain. No transition adapter, automatic persistent invalidation, +scientific acceptance, full hardening parity, or live Drive watcher is claimed. +Canonical/default refs and all audit input bytes remain untouched. Integration +requires owner/scope reconciliation, current checks, and audit-coordinator +release; preparing this proposal does not lift that boundary. diff --git a/tests/test_claims_audit_convergence.py b/tests/test_claims_audit_convergence.py new file mode 100644 index 000000000..6e6030ba8 --- /dev/null +++ b/tests/test_claims_audit_convergence.py @@ -0,0 +1,321 @@ +"""SI01/SI02 regression controls. Synthetic statuses never mutate source data.""" +import copy +import json +from pathlib import Path +import subprocess +import sys + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +CHECKER = ROOT / 'tools/claims_check.py' +D1 = 'D1-v2.2(1)' +FLOOR = 'H3-RUNG-FLOOR' +CONSUMERS = ('RN3-FAR', 'RN5-NEAR-POINT-CERTS') +CERTIFYING_GRADES = ('CERTIFIED_RUNG', 'AUTHOR_SIDE_CERTIFIED', 'FROZEN_CERTIFICATE') +FLOOR_PATH = ('engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/' + 'H3_closure/H3_RUNG_FLOOR.md') +FLOOR_SHA256 = '6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa' + + +def graph(): + return json.loads((ROOT / 'claims/graph.json').read_text(encoding='utf-8')) + + +def check(g, tmp_path, optimized, checker=CHECKER): + path = tmp_path / 'candidate.json' + path.write_text(json.dumps(g), encoding='utf-8') + args = [sys.executable] + (['-O'] if optimized else []) + return subprocess.run(args + [str(checker), '--graph', str(path)], + capture_output=True, text=True) + + +def rung_graph(grade='CERTIFIED_RUNG'): + g = graph() + g['claims'][D1]['grade'] = grade + g['claims'][D1]['depends_on'] = ['H5-RIM'] + # This premise has no receipt-only evidence: positive controls isolate the + # rung rule rather than failing an unrelated receipt-promotion firewall. + return g + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('frozen,note', [ + ('NOT_CLOSED', 'OPEN'), ('CLOSED', 'OPEN'), ('OPEN', 'CLOSED'), + ('NAMED_HYPOTHESIS', 'CLOSED'), ('CLOSED', 'RESTATED'), + ('UNKNOWN', 'CLOSED'), ('CLOSED', 'UNKNOWN'), + (None, 'CLOSED'), ('CLOSED', None), (False, 'CLOSED'), + ('CLOSED', []), ('CLOSED', {'status': 'CLOSED'}), + ([], 'CLOSED'), ({'status': 'CLOSED'}, 'CLOSED'), + ('', 'CLOSED'), ('CLOSED', ''), +]) +@pytest.mark.parametrize('grade', CERTIFYING_GRADES) +def test_certified_rung_refuses_each_undischarged_status(grade, tmp_path, optimized, frozen, note): + g = rung_graph(grade) + p = g['premises']['H5-RIM'] + for key, value in [('status_frozen_v2_2', frozen), ('status_register_note', note)]: + if value is None: + p.pop(key, None) + else: + p[key] = value + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout + assert D1 in r.stdout and 'H5-RIM' in r.stdout + assert 'Traceback' not in r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', CERTIFYING_GRADES) +def test_certified_rung_accepts_discharged_synthetic_premise(grade, tmp_path, optimized): + g = rung_graph(grade) + for col in ('status_frozen_v2_2', 'status_register_note'): + g['premises']['H5-RIM'][col] = 'CLOSED' + r = check(g, tmp_path, optimized) + assert r.returncode == 0, r.stdout + r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', CERTIFYING_GRADES) +def test_certified_rung_refuses_transitive_open_premise(grade, tmp_path, optimized): + g = rung_graph(grade) + g['claims']['SYNTHETIC-INTERMEDIATE'] = { + 'track': 'UPPER2D', 'grade': 'CONDITIONAL', 'depends_on': ['H5-RIM']} + g['claims'][D1]['depends_on'] = ['SYNTHETIC-INTERMEDIATE'] + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout and 'H5-RIM' in r.stdout + + +@pytest.mark.parametrize('optimized', [False, True]) +def test_restoring_d1_historical_grade_is_rejected(tmp_path, optimized): + g = graph() + g['claims'][D1]['grade'] = 'CERTIFIED_RUNG' + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout and 'D3-LEMMA-RN-UNIF' in r.stdout + + +def test_d1_operational_mapping_preserves_historical_grade_and_holds(): + node = graph()['claims'][D1] + assert node['grade'] == 'CONDITIONAL' + assert node['source_grade_verbatim'] == 'CERTIFIED_RUNG' + assert node['audit_disposition'] == 'HOLD_WITH_DOMAIN' + assert 'Q-RN5-MOMENT-003' in node['note'] + assert 'AMEND' in node['note'] + + +def test_rn_consumers_use_the_exact_distinct_single_rung_floor(): + g = graph() + assert FLOOR in g['claims'] + node = g['claims'][FLOOR] + assert node['grade'] == 'AUTHOR_SIDE_CERTIFIED' + assert node['source_grade_verbatim'] == 'CERTIFIED_RUNG' + assert node['independence_credit'] == 0 + assert node['source_bindings'][0]['path'] == FLOOR_PATH + assert node['source_bindings'][0]['expected_sha256'] == FLOOR_SHA256 + for consumer in CONSUMERS: + assert FLOOR in g['claims'][consumer]['depends_on'] + assert 'H3-BAND-FLOOR' not in g['claims'][consumer]['depends_on'] + assert 'H3-BAND-FLOOR' in g['claims'] + + +def floor_fixture(tmp_path): + """Run the actual CLI with disposable repository bytes, never frozen inputs.""" + import shutil + root = tmp_path / 'repository' + checker = root / 'tools/claims_check.py' + checker.parent.mkdir(parents=True) + shutil.copyfile(CHECKER, checker) + source = root / FLOOR_PATH + source.parent.mkdir(parents=True) + shutil.copyfile(ROOT / FLOOR_PATH, source) + g = graph() + g['claims'][FLOOR] = { + 'track': 'UPPER2D', 'grade': 'AUTHOR_SIDE_CERTIFIED', 'depends_on': [], + 'source_bindings': [{ + 'repo': 'd6g8k5htny-coder/main', 'path': FLOOR_PATH, + 'extraction_rule': 'whole_file', 'expected_bytes': 7003, + 'expected_sha256': FLOOR_SHA256, + }], + } + for consumer in CONSUMERS: + g['claims'][consumer]['depends_on'] = [FLOOR] + return g, checker, source + + +@pytest.mark.parametrize('optimized', [False, True]) +def test_matching_source_binding_passes_without_state_writes(tmp_path, optimized): + g, checker, source = floor_fixture(tmp_path) + before = source.read_bytes() + r = check(g, tmp_path, optimized, checker) + assert r.returncode == 0, r.stdout + r.stderr + assert source.read_bytes() == before + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('mutation', ['alter', 'length', 'absent', 'symlink', 'parent_symlink']) +def test_source_binding_refuses_stale_rn_consumers(tmp_path, optimized, mutation): + g, checker, source = floor_fixture(tmp_path) + if mutation == 'alter': + payload = source.read_bytes() + source.write_bytes(bytes([payload[0] ^ 1]) + payload[1:]) + elif mutation == 'length': + source.write_bytes(source.read_bytes() + b'\n') + elif mutation == 'absent': + source.unlink() + elif mutation == 'symlink': + target = tmp_path / 'outside.md' + source.rename(target) + source.symlink_to(target) + elif mutation == 'parent_symlink': + parent = source.parent + target = tmp_path / 'outside-directory' + parent.rename(target) + parent.symlink_to(target, target_is_directory=True) + r = check(g, tmp_path, optimized, checker) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RN-FLOOR-SOURCE:' in r.stdout + assert all(name in r.stdout for name in (FLOOR, *CONSUMERS)) + if mutation == 'alter': + assert 'source SHA-256 mismatch' in r.stdout + assert 'source byte length mismatch' not in r.stdout + elif mutation == 'length': + assert 'source byte length mismatch' in r.stdout + assert 'Traceback' not in r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('mutation', [ + 'wrong_edge', 'lost_node', 'lost_binding', 'unknown_repo', 'absolute_path', + 'parent_path', 'noncanonical_path', 'invalid_digest', 'invalid_bytes', + 'boolean_bytes', 'unsupported_extraction', 'coherent_repin', +]) +def test_floor_contract_cannot_silently_lose_its_input(tmp_path, optimized, mutation): + g, checker, source = floor_fixture(tmp_path) + binding = g['claims'][FLOOR]['source_bindings'][0] + if mutation == 'wrong_edge': + g['claims'][CONSUMERS[0]]['depends_on'] = ['H3-BAND-FLOOR'] + elif mutation == 'lost_node': + del g['claims'][FLOOR] + elif mutation == 'lost_binding': + del g['claims'][FLOOR]['source_bindings'] + elif mutation == 'unknown_repo': + binding['repo'] = 'someone/else' + elif mutation == 'absolute_path': + binding['path'] = str(source) + elif mutation == 'parent_path': + binding['path'] = '../outside.md' + elif mutation == 'noncanonical_path': + binding['path'] = FLOOR_PATH.replace('/H3_closure/', '/./H3_closure/') + elif mutation == 'invalid_digest': + binding['expected_sha256'] = 'not-a-digest' + elif mutation == 'invalid_bytes': + binding['expected_bytes'] = 0 + elif mutation == 'boolean_bytes': + binding['expected_bytes'] = True + elif mutation == 'unsupported_extraction': + binding['extraction_rule'] = 'frozen_body' + elif mutation == 'coherent_repin': + import hashlib + source.write_bytes(source.read_bytes() + b'\n') + binding['expected_sha256'] = hashlib.sha256(source.read_bytes()).hexdigest() + binding['expected_bytes'] = source.stat().st_size + r = check(g, tmp_path, optimized, checker) + assert r.returncode == 1, r.stdout + r.stderr + assert ('FW-RN-FLOOR-SOURCE:' in r.stdout or + 'FW-RN-FLOOR-DEPENDENCY:' in r.stdout) + assert 'Traceback' not in r.stderr + + +def test_floor_contract_matches_actual_frozen_runner_pin_and_parser(): + import ast + import hashlib + runner = ROOT / ('engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/' + 'D3_percolation/d3_rn_unif.py') + payload = runner.read_bytes() + assert hashlib.sha256(payload).hexdigest() == ( + '85d7725fab42eeb0e823226f44d17f142a5c57e5d89084b2b6edffe4a8f0c930') + tree = ast.parse(payload) + pins = next(ast.literal_eval(n.value) for n in tree.body + if isinstance(n, ast.Assign) and + any(isinstance(t, ast.Name) and t.id == '_PINS' for t in n.targets)) + consumed = '../H3_closure/H3_RUNG_FLOOR.md' + assert pins[consumed] == FLOOR_SHA256 + text = payload.decode('utf-8') + assert "_floor_txt = open('../H3_closure/H3_RUNG_FLOOR.md').read()" in text + assert "Z_LO = mpf(_m.group(1))" in text + assert "ck(Z_LO == mpf('7.7592917375327855e-3')" in text + source = (ROOT / FLOOR_PATH).read_bytes() + assert len(source) == 7003 + assert hashlib.sha256(source).hexdigest() == FLOOR_SHA256 + + +@pytest.mark.parametrize('optimized', [False, True]) +def test_unrelated_document_change_does_not_invalidate_floor(tmp_path, optimized): + g, checker, source = floor_fixture(tmp_path) + doc = checker.parent.parent / 'README.md' + doc.write_text('Unrelated navigation update.\n', encoding='utf-8') + r = check(g, tmp_path, optimized, checker) + assert r.returncode == 0, r.stdout + r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', CERTIFYING_GRADES) +def test_certified_rung_refuses_empty_premise_record(grade, tmp_path, optimized): + g = rung_graph(grade) + g['premises']['H5-RIM'] = {} + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout and 'H5-RIM' in r.stdout + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', CERTIFYING_GRADES) +def test_d1_certifying_alias_refuses_actual_open_rn(tmp_path, optimized, grade): + g = graph() + g['claims'][D1]['grade'] = grade + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout + assert D1 in r.stdout and 'D3-LEMMA-RN-UNIF' in r.stdout + assert f'is graded {grade}' in r.stdout + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', ['MISSING', None, 'FUTURE_CERTIFIED', True, [], {}]) +def test_d1_unknown_or_malformed_grade_is_not_a_bypass(tmp_path, optimized, grade): + g = graph() + if grade == 'MISSING': + g['claims'][D1].pop('grade') + else: + g['claims'][D1]['grade'] = grade + r = check(g, tmp_path, optimized) + assert r.returncode == 1, r.stdout + r.stderr + assert 'FW-RUNG-OPEN-PREMISE:' in r.stdout and D1 in r.stdout + assert 'unknown or malformed operational grade' in r.stdout + assert 'Traceback' not in r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +def test_source_labels_and_existing_author_side_scope_remain_compatible(tmp_path, optimized): + g = graph() + assert g['claims'][D1]['grade'] == 'CONDITIONAL' + assert g['claims'][D1]['source_grade_verbatim'] == 'CERTIFIED_RUNG' + assert g['claims']['RN3-FAR']['grade'] == 'AUTHOR_SIDE_CERTIFIED' + assert g['claims'][FLOOR]['grade'] == 'AUTHOR_SIDE_CERTIFIED' + assert g['claims']['P14-A..E']['grade'] == 'AUTHOR_SIDE_COMPLETE' + r = check(g, tmp_path, optimized) + assert r.returncode == 0, r.stdout + r.stderr + + +@pytest.mark.parametrize('optimized', [False, True]) +@pytest.mark.parametrize('grade', ['CONDITIONAL', 'AUTHOR_SIDE_PROOF_PRESENT', 'AMEND']) +@pytest.mark.parametrize('source_grade', CERTIFYING_GRADES + ('FUTURE_SOURCE_LABEL',)) +def test_known_noncertifying_d1_grade_is_not_source_label_promotion( + tmp_path, optimized, grade, source_grade): + g = graph() + g['claims'][D1]['grade'] = grade + g['claims'][D1]['source_grade_verbatim'] = source_grade + r = check(g, tmp_path, optimized) + assert r.returncode == 0, r.stdout + r.stderr diff --git a/tools/claims_check.py b/tools/claims_check.py index 17809df34..a67682dce 100644 --- a/tools/claims_check.py +++ b/tools/claims_check.py @@ -28,16 +28,22 @@ """ from __future__ import annotations +import hashlib import json import os import re import sys +from pathlib import Path ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) GRAPH = os.path.join(ROOT, "claims", "graph.json") MANIFEST = os.path.join(ROOT, "engine", "carriers", "MANIFEST.json") OPEN_STATUSES = {"OPEN", "NOT_CLOSED"} +# Closed discharge vocabulary for FW-RUNG-OPEN-PREMISE, matching the corrected +# hardening profile. A missing, unknown, or malformed status is not a discharge. +PREMISE_STATUS_COLUMNS = ("status_frozen_v2_2", "status_register_note") +PREMISE_DISCHARGED = {"CLOSED", "DISCHARGED", "PROMOTED", "SATISFIED", "CERTIFIED"} UNCONDITIONAL_GRADES = {"LIVE_ROOT_THEOREM", "FROZEN_CERTIFICATE", "RATIFIED_3D_ONLY"} # P0.2 is a distinct lane from the q0 pair-Palm law; it is grouped with the 2D # tracks here so that the 2D/3D and prize firewalls cover it too. Grouping only @@ -185,6 +191,78 @@ def closure(g: dict, name: str, seen: set[str] | None = None) -> set[str]: return seen +# Fixed source contract selected for the SI02 convergence proposal. The frozen +# d3_rn_unif.py _PINS entry and Z_LO parser consume exactly this recovered file. +# This is a refusal boundary, not a transition adapter or scientific admission. +# A successor source needs an explicitly reviewed contract change, not a graph- +# only re-pin that turns altered bytes into their own evidence. +RN_FLOOR_NODE = "H3-RUNG-FLOOR" +RN_FLOOR_CONSUMERS = ("RN3-FAR", "RN5-NEAR-POINT-CERTS") +RN_FLOOR_BINDING = { + "repo": "d6g8k5htny-coder/main", + "path": "engine/rn_engine/frozen/K3_SIDE24_LB/UPPER2D/H3_closure/H3_RUNG_FLOOR.md", + "extraction_rule": "whole_file", + "expected_bytes": 7003, + "expected_sha256": "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa", +} + + +def source_binding_problems(g: dict, repo_root: Path) -> list[str]: + """Refuse stale/misattributed rung input; never write any claim status. + + Only the two known frozen-runner consumers and their floor are in scope. + The reverse closure is diagnostic, not a claim of deployed invalidation. + """ + problems = [] + claims = g["claims"] + for consumer in RN_FLOOR_CONSUMERS: + deps = claims.get(consumer, {}).get("depends_on", []) + if not isinstance(deps, list) or RN_FLOOR_NODE not in deps or "H3-BAND-FLOOR" in deps: + problems.append( + f"FW-RN-FLOOR-DEPENDENCY: {consumer} must name {RN_FLOOR_NODE}, " + "the frozen runner's actual input, not H3-BAND-FLOOR") + affected = set(RN_FLOOR_CONSUMERS) + affected.update(name for name in claims if RN_FLOOR_NODE in closure(g, name) - {name}) + context = f"{RN_FLOOR_NODE}; affected consumers {', '.join(sorted(affected))}" + + def refuse(reason): + problems.append(f"FW-RN-FLOOR-SOURCE: {context}: {reason}") + + node = claims.get(RN_FLOOR_NODE, {}) + bindings = node.get("source_bindings") + if not isinstance(bindings, list) or len(bindings) != 1 or not isinstance(bindings[0], dict): + refuse("exactly one whole-file source binding is required") + return problems + binding = bindings[0] + # Exact typed identity also rejects absolute/traversal/noncanonical paths, + # unsupported repositories/extractions, malformed digests and bool lengths. + for field, expected in RN_FLOOR_BINDING.items(): + actual = binding.get(field) + if type(actual) is not type(expected) or actual != expected: + refuse(f"{field} differs from the frozen runner's source contract") + if any(p.startswith("FW-RN-FLOOR-SOURCE:") for p in problems): + return problems + source = repo_root + for component in Path(binding["path"]).parts: + source = source / component + if source.is_symlink(): + refuse("source path contains a symlink") + return problems + try: + if not source.is_file(): + refuse("source is absent or is not a regular file") + return problems + payload = source.read_bytes() + except OSError as exc: + refuse(f"source cannot be read ({type(exc).__name__})") + return problems + if len(payload) != binding["expected_bytes"]: + refuse("source byte length mismatch") + if hashlib.sha256(payload).hexdigest() != binding["expected_sha256"]: + refuse("source SHA-256 mismatch") + return problems + + def main(argv: list[str] | None = None) -> int: global GRAPH, MANIFEST argv = argv if argv is not None else sys.argv[1:] @@ -213,6 +291,18 @@ def main(argv: list[str] | None = None) -> int: known = set(claims) | set(premises) problems: list[str] = [] + # The repaired D1 mapping cannot evade its grade-family check with an + # unknown spelling or an unhashable value. This is deliberately scoped: + # unrelated historical labels are not a new global vocabulary migration. + if "D1-v2.2(1)" in claims: + grade = claims["D1-v2.2(1)"].get("grade") + if not isinstance(grade, str) or grade not in GRADE_STRENGTH: + print(f"FW-RUNG-OPEN-PREMISE: D1-v2.2(1) has unknown or malformed " + f"operational grade {grade!r}; a reviewed mapping is required") + print(f"claims={len(claims)} premises={len(premises)} " + f"firewalls={len(g['firewalls'])} problems=1") + return 1 + # 0. referential integrity and acyclicity for name, node in list(claims.items()) + list(premises.items()): for dep in (node.get("depends_on") or []) + (node.get("sub_obligations") or []): @@ -236,9 +326,14 @@ def find_cycle(name, stack): problems.append(f"dependency cycle: {' -> '.join(c)}") break + problems.extend(source_binding_problems(g, Path(ROOT))) + # FW-UNCONDITIONAL for name, claim in claims.items(): - if claim.get("grade") not in UNCONDITIONAL_GRADES: + # The overlapping certifying family is handled by the stronger, + # type-safe, both-column contract below (including FROZEN_CERTIFICATE). + if (claim.get("grade") not in UNCONDITIONAL_GRADES or + claim.get("grade") in CERTIFYING_GRADES): continue for node in closure(g, name) - {name}: p = premises.get(node) @@ -247,6 +342,32 @@ def find_cycle(name, stack): f"FW-UNCONDITIONAL: {name} is graded {claim['grade']} but rests on " f"{node} (frozen status {p['status_frozen_v2_2']})") + # FW-RUNG-OPEN-PREMISE. A source may historically call a rung + # "CERTIFIED" while simultaneously naming a load-bearing premise as open. + # Preserve that source word separately, but do not let the current claim + # graph treat the rung as certified until its dependency closes. All of + # the already declared certifying grades share this contract; changing + # CERTIFIED_RUNG to AUTHOR_SIDE_CERTIFIED cannot bypass it. + for name, claim in claims.items(): + if claim.get("grade") not in CERTIFYING_GRADES: + continue + for node in sorted(closure(g, name) - {name}): + if node not in premises: + continue + p = premises[node] + # Both columns, and the closed vocabulary, for the same reason as + # FW-UNCONDITIONAL: this firewall arrived reading only the frozen + # column against the two open words, so NAMED_HYPOTHESIS and a + # register note that disagrees both read as discharges. The migration + # base did carry D1 as CERTIFIED_RUNG; this proposal separately maps + # it to CONDITIONAL while preserving that original source label. + for col in PREMISE_STATUS_COLUMNS: + v = p.get(col) + if not isinstance(v, str) or v not in PREMISE_DISCHARGED: # absence included, deliberately + problems.append( + f"FW-RUNG-OPEN-PREMISE: {name} is graded {claim['grade']} but rests " + f"on {node}, whose {col} is {v!r} and is not a discharge") + # FW-2D-3D-COMPOSITION for name, claim in claims.items(): tracks = set()