Qualify precision once per backend: 36% less time, full coverage

research/p104-single-pass-qualification/.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+runs/
+execution.lock

research/p104-single-pass-qualification/BENCHMARK-pair.json

@@ -0,0 +1,21 @@
+{
+  "complete_receipts_equal": true,
+  "medians": {
+    "B": {
+      "cpu": 60.949999999999996,
+      "wall": 61.007068632985465
+    },
+    "C": {
+      "cpu": 38.879999999999995,
+      "wall": 38.93709892901825
+    }
+  },
+  "order": [
+    "B1",
+    "C1"
+  ],
+  "saving": {
+    "cpu": 0.36210008203445454,
+    "wall": 0.36176086146244313
+  }
+}

research/p104-single-pass-qualification/BENCHMARK-remaining.json

@@ -0,0 +1,25 @@
+{
+  "complete_receipts_equal": true,
+  "medians": {
+    "B": {
+      "cpu": 60.949999999999996,
+      "wall": 61.007068632985465
+    },
+    "C": {
+      "cpu": 38.879999999999995,
+      "wall": 39.01491572102532
+    }
+  },
+  "order": [
+    "B1",
+    "C1",
+    "C2",
+    "B2",
+    "B3",
+    "C3"
+  ],
+  "saving": {
+    "cpu": 0.36210008203445454,
+    "wall": 0.3604853241558532
+  }
+}

research/p104-single-pass-qualification/BENCHMARK.json

@@ -0,0 +1,31 @@
+{
+  "complete_receipts_equal": true,
+  "medians": {
+    "B": {
+      "cpu": 60.949999999999996,
+      "wall": 61.007068632985465
+    },
+    "C": {
+      "cpu": 38.879999999999995,
+      "wall": 39.01491572102532
+    }
+  },
+  "order": [
+    "B1",
+    "C1",
+    "C2",
+    "B2",
+    "B3",
+    "C3"
+  ],
+  "saving": {
+    "cpu": 0.36210008203445454,
+    "wall": 0.3604853241558532
+  },
+  "limits": {
+    "per_command_seconds": 180,
+    "cumulative_seconds": 1500,
+    "group_rss_bytes": 1073741824
+  },
+  "scope": "Complete frozen qualification incl 27 new finite controls; four inherited custody controls are outside the benchmark stage and inside registered verification."
+}

research/p104-single-pass-qualification/COVERAGE.md

@@ -0,0 +1,33 @@
+# Coverage preservation
+
+The source is the complete official PR #5831 export at `7c5eb98e7439d778141d63e801e53d4cd7e1d587`, containing the unchanged PR #5826 source at `58f93cf41751920f3d6766a39caccc2974ce18b0`. `source.py` authenticates every outer file/mode and the entire archive before importing; the original source context authenticates the nested archive and checks every declared contract edit. Frozen files and the arithmetic backend are not edited.
+
+| Obligation | Frozen full qualification | Proposed qualification |
+|---|---|---|
+| Integer complete contract | Exact `contract.calculate(p, Engine(reference))` | Same calculation, with an observational proxy that forwards every call |
+| Fraction complete contract | Unchanged `original.calculate()` | Same function and newly loaded original module, observed via a scoped module-factory seam; restored in `finally` |
+| Actual dimensions | 25,984 events, 799 coordinates, every arbitrary-input/native/ownership check | Same word in both complete calculations |
+| Source result | Both complete encoded outputs equal original RESULT | Same two checks plus full output equality |
+| Ideal metadata and local weights | Extra full reference and integer ideal passes, compared | Compare complete deep-copied first-pass outputs from the two independent calculations |
+| Actual error trace and all signed witness dictionaries | Extra reference/integer error passes, compared | Compare complete deep-copied first-pass outputs from the two independent calculations |
+| Final transpose scores and signed coefficients | Each full calculation calls unchanged `reverse_all` and checks all values/hashes | Unchanged in both calculations |
+| Attaining prefix/input fixtures | Each complete contract uses unchanged `reverse_cut` and literal `execute` | All retained; no sampled rows |
+| Additive COPY/reset semantics | Both complete contracts run every original residual fixture and six rejections | All retained; malformed-word calls still reach the backend and cannot replace the actual observation |
+| Dyadic finite differential | Original seeded 120 programs/4,240 events, complete trace/witness and reverse equality | Call original `fixtures` unchanged with raw independent reference and integer backend |
+| Integer validity failures | Nondyadic scalar, inexact division, nondyadic weight | All three retained |
+| Precision guards and scale | Prefix/public/owned 26/23/22, coefficient scale 55 | Exact same receipt, not a weaker subset |
+| Source isolation | Distinct Fraction module and explicit contract/backend under authenticated source context | Same source authentication and distinct modules; no cross-backend value sharing |
+| Timeout | Original full qualification 180 seconds | 180 seconds; unchanged numerical or proof limits |
+| Shared tooling tests | Full CI plan has 513 tests and 22 platform skips | No shared script, test, wait, fixture or skip changes; nominated group all ten pass in profile |
+
+The omitted repeated calculations are deterministic calls of byte-identical functions with identical complete inputs inside one successful invocation. The replacement observations retain their complete output values. This is intra-invocation common-work elimination; it is not an independent extra scientific oracle. The two arithmetic representations and all original literal/transpose oracles still execute independently. Cold process/source authentication occurs on every qualification. Nested source scratch keeps the predecessor's private writable semantics; this contribution adds no claim that it is sealed.
+
+## Observation lifetime and failure rules
+
+A context binds the canonical complete word. Only the actual successful ideal and trace calls can be recorded, once each. The trace must use the observed ideal's exact weights and operation set. Arguments are checked before/after invocation, outputs are deep-copied, and snapshots are hashed again at consumption. Each backend has a separate context. Outputs cannot be consumed until the full enclosing contract has succeeded, and can be consumed only once. A backend exception on the actual word aborts its observations. Any exception in the complete candidate/parallel Fraction calculation aborts both contexts. The source module factory is restored even on failure. Nothing is persisted between commands.
+
+The finite feasibility gate uses the real frozen backends, a valid five-event COPY/SCALE/CLEAR word, complete fresh reruns, and 27 explicit failure/isolation controls. It runs both normally and under `-O`; checks use explicit exceptions. The original finite corpus and original scientific rejections are additional coverage.
+
+## Limits
+
+This covers the frozen contract only. Different source bytes, word, weights, operations, ownership semantics, backend or oracle require a fresh binding and feasibility gate. Assisted local review and CI do not prove the multiplication theorem, supplier admission, exact physical reset, a funded kappa gain or independent human review.

research/p104-single-pass-qualification/NOTICE

@@ -0,0 +1,30 @@
+Complete single-pass qualification
+==================================
+New source-bound observation, finite controls, profiling and complete Linux benchmark: Chris R / Clear1nsight, with substantial OpenAI Codex assistance; no subagents or independent human/kernel acceptance. Apache-2.0. Original arithmetic, source contract, expected records and mathematical claims are unchanged. No kappa gain.
+
+Retained PR5839 NOTICE, verbatim:
+
+Linux validation of PR5831
+==========================
+Exact integer engine, proof, explicit contract adaptation and original qualification: Ali Romman, with substantial OpenAI Codex assistance. Source PR5826/5819, Adam Gall, ywz65, PR2878, Mason Hale/PR5811 and all retained P104/native/compiler lineage keep their attribution and Apache-2.0 terms. Full source archives remain unchanged.
+
+New Linux source/coverage review, guarded measurements, custody controls, portable reproduction and reporting: Chris R / Clear1nsight, with substantial OpenAI Codex assistance; no subagents or independent human/kernel acceptance. The guard and export-custody pattern follow PR5816/5818/5832. Apache-2.0. No new kappa or supplier admission.
+
+Retained research/p104-noisy-copy-reset/inputs/caller-NOTICE
+Composition of accumulated native updates and two released P104 blocks.
+New integration, compatibility checks and complete price: Mason Hale with substantial OpenAI Codex assistance, including separate agent checks. Apache-2.0. No independent human acceptance is claimed.
+
+The accumulation and retained-source lineage is credited verbatim in vendor/accumulated/NOTICE. The block constructions and composition lineage are credited verbatim in vendor/blocks/NOTICE. These notices and every retained source byte are unchanged. Ali Romman supplied PR5802 and PR5795; Joel Pulikkan/GamingPuzzled supplied the R22 mechanism; Ali Romman supplied the second block PR5796 and the provisional role92 plan. All native/helper/controller/compiler/BIT/analytic credit remains in the retained notices.
+
+Dugongue (@Dugongue), PR5806 at 20e7289b63d240715aa96006571ae38a46291d97, supplied a concurrent informal proof of the same three-accumulation/two-block baseline join. The fourth role92 realization is additional to that shared composition.
+
+
+Retained research/p104-noisy-copy-reset/inputs/prior-NOTICE
+Copyright 2026 Ali Romman.
+Prepared with substantial OpenAI Codex assistance in research, proof, code and checks.
+Licensed under Apache-2.0.
+
+Source files are unchanged. See source/NOTICE and ORIGINS.json.
+The completed-error method credits Adam Gall, ywz65 and PR2878.
+PR5802 and its retained predecessors supply the native word and compiler premises.
+No independent scientific acceptance is claimed.

research/p104-single-pass-qualification/PROFILE.md

@@ -0,0 +1,35 @@
+# Measured nomination and rejected alternative
+
+Both profiles run the full unchanged entry points, serially, with fresh processes and private bytecode prefixes. Whole-call wall timers are observational and inclusive: nested totals overlap. They are excluded from speed statistics. Raw outputs and Linux resource receipts are retained in `evidence/`. The canonical base and fixture census appear in `evidence/HELPER-CLOSURE.json`.
+
+## Shared-helper group
+
+Existing hosted verbose-test timestamps suggested the descendant-source-role group. These were only screening proxies; buffered output is not an exact per-test profile. Before collection, all seven manifest inputs, six package files and exact original/historical Git rows were materialized/authenticated. No incomplete discovery or missing fixture was accepted as a pass.
+
+The complete group then passes **10 tests, zero errors/failures/skips** in 51.317 seconds wall /48.85 CPU. Fresh per-test fixture setup is 0.287 seconds across ten setups; 100 inclusive Git calls total0.305 seconds. The complete historical-source-substitution guard takes37.290 seconds, and the broken live cache-isolation regression12.125 seconds. These execute real historical/negative CLI behaviour; they are not removable setup.
+
+Even eliminating every fixture setup would save at most **0.56% of this group** on the observed run, far below15%. This rejects only this fixture-only nomination, not all shared-tooling optimization. No helper/test/skip/wait/source change is made. Required stale-import, historical-source, descendant and lifetime rejection coverage remains in CI.
+
+## Complete precision qualification
+
+The complete frozen PR5831 profile passes in61.609 seconds wall /61.55 CPU with the exact original scientific receipt. It includes:
+
+| Inclusive operation | Calls | Seconds |
+|---|---:|---:|
+| Full Fraction contract |1|28.038|
+| Fraction contract error trace |1|19.828|
+| Fraction contract ideal (actual+rejections) |4|4.077|
+| Fraction contract reverse-all |1|2.785|
+| Extra Fraction ideal |1|2.163|
+| Extra Fraction error trace (actual+120 finite cases) |121|21.102|
+| Full integer contract |1|6.052|
+| Integer error trace (two actual+120 finite) |122|6.104|
+| Integer ideal (two actual+rejections) |5|1.408|
+
+The full contract already computes the actual ideal/weights and trace/witness values later recomputed by qualification. The nomination retains both independent first-pass output pairs, then compares their complete values. Every original actual and finite oracle stays active. The profile justifies finite feasibility; it is not itself an optimization benchmark.
+
+## Gate history
+
+The preconstruction five-event fixture uses the actual authenticated Fraction and integer modules and complete fresh comparisons.27 explicit controls cover one-use/readiness, closed/duplicate calls, changed word/weights/rounding, caller-return alias isolation, original malformed-input exceptions, failed/aborted lifetimes, input mutation and no transfer from a previous context. Both normal and `-O` pass. An initial prototype normalized rounded arguments to a list; before construction it was hardened to preserve the original set object type while normalizing only its fingerprint. Both earlier and final receipts are retained, without claiming they are distinct backend implementations.
+
+No scientific failures occurred in these profiles/finite runs. A draft metadata outcome string was rejected before the registered entry point; its message and enum-only correction are retained separately. All later full measurements remain separately labelled and are never silently rerun.

research/p104-single-pass-qualification/PROOF.md

@@ -0,0 +1,13 @@
+# Source-bound elimination of duplicate qualification passes
+
+This is a verification-engineering argument about exact deterministic computations on one frozen word, not a proof of the multiplication theorem.
+
+Let I_B(w) return the complete ideal metadata and local weights and E_B(w,a,R) the complete error trace and signed witness dictionaries for backend B. In the authenticated source, Fraction `ideal`/`error_trace` and integer `Engine.ideal`/`Engine.error_trace` allocate their state locally, use exact arithmetic, and do not read random, time, file or caller-global state. They do not mutate w,a,R. The complete source contract calls I_B(w), defines R from all operation counts and then calls E_B(w,a,R). Qualification subsequently calls the byte-identical functions on the same complete word, weights and rounded operation set to obtain values for cross-backend comparison. These repeated calls are not additional independent scientific implementations.
+
+The replacement retains a deep copy of the full outputs of the first actual I_B and E_B calls in each separately executed complete contract. It does not replace either backend computation with the other's output. Canonical input fingerprints bind the whole word; the trace binding also requires the precise independently computed weights and full rounded operation set. Arguments are fingerprinted before and after each invocation. Only actual successful calls are recorded, exactly once each, and only a successful complete enclosing contract permits consumption. Corrupt source, missing calls, duplicate actual calls, input changes, failed complete contracts or output drift prevent admission. Deep copies isolate the retained values from later mutation of returned values. Output fingerprints are rechecked at one-use consumption.
+
+Consequently the complete ideal/weight and trace/witness equality predicates receive the same exact values as the unchanged qualifier's second calls. Full original RESULT equality is checked separately against each independent complete contract and between them. Every literal input/defect attaining fixture, signed final transpose check and original semantic rejection remains inside those untouched calculations. The original seeded 120-program differential is called unchanged with raw backends, including full trace/witness and reverse equality, plus all three integer failures. The coefficient scale and complete scientific receipt are still computed/compared to the original source record.
+
+The Fraction calculation retains its own newly loaded original precision module. Its factory is wrapped only to observe the first-pass returns; the factory is restored in `finally`. The raw reference module, integer arithmetic and literal/reverse oracle code stay unchanged and authenticated. A context has no cross-command storage or reuse. The argument assumes the normal deterministic interpreter model; this does not claim hardware-fault independence from two repetitions of the same computation.
+
+The finite gate precedes construction. The complete actual-word comparisons, six-process measurements, normal/optimized full commands and sealed export checks are additional implementation evidence. A source or word successor requires fresh purity/input/coverage review and finite feasibility. Physical native correctness, reset implementation, exact owned zero return, tapes, compiler/outer admission and the five framework assumptions remain predecessor obligations. No kappa change follows from this optimization.