WIP: fix InstanceNorm large-mean cancellation; CUDA regeneration pending

README.md

@@ -19,6 +19,13 @@ GPU-Kernel Benchmark Oracles*: the mutation operators, the verified CUDA
 substrates they mutate, the kill witnesses, and the pipeline that produced
 every number in the paper.
 
+**InstanceNorm repair pending CUDA verification:** this branch changes the
+InstanceNorm substrate to two-pass variance and adds shifted-input suites.
+Its existing `witnesses/instancenorm.json` and `summary.json` entry are historical
+records for revision `d04d6fc`, not measurements of the modified source. Do not
+merge or use them as current repair results until the GPU regeneration completes.
+See [repair status and reproduction](repairs/instancenorm/README.md).
+
 ## Layout
 
 ```

pipeline/repair_instancenorm.py

@@ -0,0 +1,244 @@
+"""Verify and regenerate only InstanceNorm, with fresh, source-bound journals.
+
+Requires NVIDIA CUDA 12.x, PyTorch and at least 40 GiB free GPU memory for the
+unchanged official inputs and the screening pipeline's two-seed cache.
+Run from any directory:
+  python pipeline/repair_instancenorm.py --run-dir /tmp/instancenorm-repair
+
+Writes admission/precision evidence, screening and full-matrix journals,
+witnesses and a per-problem summary. Does not modify published artifacts.
+"""
+import argparse
+import collections
+import ctypes
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import urllib.request
+
+ROOT = Path(__file__).resolve().parents[1]
+BASELINE_REVISION = "d04d6fc72504750804c4f4b45b4a8d7dc7c1880d"
+BASELINE_SHA256 = "356b305c8038dea0244ad08100da0b650ffc1210c46edc7c891ca35017ae9fad"
+PROBLEM = "instancenorm"
+KEPT_CLASSES = {"killed_by_T0", "high_value", "no_witness"}
+
+
+def fingerprint():
+    paths = [ROOT / "substrates/candidate_instancenorm.py",
+             ROOT / "pipeline/mutator.py", ROOT / "pipeline/nvrtc_tce.py",
+             ROOT / "pipeline/screen_mutants.py", ROOT / "pipeline/full_matrix.py",
+             ROOT / "pipeline/gate_candidates.py", ROOT / "pipeline/suite_filter.py",
+             ROOT / "pipeline/kernels_def.py", ROOT / "pipeline/problems_ext.py",
+             ROOT / "pipeline/candidates_loader.py",
+             Path(__file__).resolve(), *sorted((ROOT / "rules").glob("*.py"))]
+    return {str(p.relative_to(ROOT)): hashlib.sha256(p.read_bytes()).hexdigest()
+            for p in paths}
+
+
+def write_json(path, value):
+    path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n")
+
+
+def records(path):
+    return [json.loads(line) for line in path.read_text().splitlines() if line]
+
+
+def export_records(screen, matrix):
+    """Promote matrix-only kills as well, so summary and witnesses agree."""
+    outcomes = {r["id"]: r for r in screen if r["type"] == "RESULT"}
+    witnesses = {}
+    for mid, r in outcomes.items():
+        if r["cls"] in KEPT_CLASSES:
+            witnesses[mid] = dict(rule=r["rule"], family=r["category"],
+                                  site=r["site"], cls=r["cls"],
+                                  killed_by_official=r["cls"] == "killed_by_T0",
+                                  witness=r.get("witness"))
+    for cell in matrix:
+        if cell["type"] == "CELL" and cell["outcome"] == "killed":
+            witness = witnesses[cell["id"]]
+            if witness["cls"] == "no_witness":
+                witness.update(cls="high_value", witness=cell["suite"])
+    summary = dict(mutants=len(witnesses),
+                   witnessed=sum(r["cls"] != "no_witness" for r in witnesses.values()),
+                   killed_by_official=sum(r["killed_by_official"] for r in witnesses.values()),
+                   level=12)
+    return witnesses, summary
+
+
+def validate_records(screen, matrix, generated_ids, suite_names):
+    outcomes = {r["id"]: r for r in screen if r["type"] == "RESULT"}
+    if set(outcomes) != set(generated_ids):
+        raise RuntimeError("Screening results do not cover exactly the current mutation source")
+    cells = {(r["id"], r["suite"]) for r in matrix if r["type"] == "CELL"}
+    crash_reasons = {"crash", "probe_crash", "cuda_poisoned"}
+    expected = {(mid, suite) for mid, r in outcomes.items()
+                if r["cls"] in KEPT_CLASSES and r.get("reason") not in crash_reasons
+                for suite in suite_names}
+    if cells != expected:
+        raise RuntimeError("Full matrix is missing cells or contains stale/unknown cells")
+
+
+def check_infrastructure_failure(log, rows, returncode):
+    details = log.lower() + "\n" + "\n".join(str(r.get("detail", "")).lower() for r in rows)
+    memory_errors = ["out of memory", "out_of_memory", "alloc_failed", "std::bad_alloc",
+                     "can't allocate memory", "cannot allocate memory"]
+    if returncode in [-9, 137] or any(error in details for error in memory_errors):
+        raise RuntimeError("Infrastructure failure, cannot count mutant kills")
+
+
+def load_runtime(run_dir):
+    # The released artifact keeps rules and substrates alongside pipeline/.
+    # Load this candidate directly, without moving any source into accepted/.
+    sys.path[:0] = [str(ROOT), str(ROOT / "pipeline")]
+    import torch
+    import kernels_def as K
+    import screen_mutants as screen
+    import full_matrix as matrix
+    import suite_filter
+    import mutator
+    if len(mutator.RULES) != 124:
+        raise RuntimeError("Expected all 124 published mutation rules to be loaded")
+    spec = importlib.util.spec_from_file_location(
+        "repair_candidate", ROOT / "substrates/candidate_instancenorm.py")
+    candidate = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(candidate)
+    candidate.register(K, torch, ctypes)
+    screen.RESULTS = matrix.RESULTS = str(run_dir)
+    suite_filter._cache = {}  # all six suites must pass admission first
+    capability = torch.cuda.get_device_capability()
+    os.environ["NVRTC_ARCH"] = f"compute_{capability[0]}{capability[1]}"
+    return torch, K, screen, matrix
+
+
+def verify(run_dir):
+    torch, K, screen, _ = load_runtime(run_dir)
+    from nvrtc_tce import compile_ptx, externc, device_source
+    import gate_candidates
+    free, total = torch.cuda.mem_get_info()
+    if free < 40 * 1024**3:
+        raise RuntimeError("Official-input screening requires at least 40 GiB free GPU memory")
+    admitted, detail = gate_candidates.check(PROBLEM)
+    if not admitted:
+        raise RuntimeError(f"Fixed substrate failed admission: {detail}")
+    report = dict(admitted=True, detail=detail, baseline_revision=BASELINE_REVISION,
+                  gpu=torch.cuda.get_device_name(), torch=torch.__version__,
+                  cuda=torch.version.cuda, free_gpu_bytes=free, total_gpu_bytes=total,
+                  source_hashes=fingerprint(), runs=[])
+    url = ("https://huggingface.co/datasets/Elfsong/KernelBench-M/resolve/"
+           f"{BASELINE_REVISION}/substrates/candidate_instancenorm.py")
+    with urllib.request.urlopen(url, timeout=60) as response:
+        baseline_bytes = response.read()
+    if hashlib.sha256(baseline_bytes).hexdigest() != BASELINE_SHA256:
+        raise RuntimeError("Baseline source checksum mismatch")
+    baseline = baseline_bytes.decode().split('CUDA_SOURCE = r"""', 1)[1].split('"""', 1)[0]
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    kernels = {}
+    for label, source in [("baseline", baseline), ("fixed", K.PROBLEMS[PROBLEM]["cuda"])]:
+        image = compile_ptx(externc(device_source(source)), f"{label}.cu")
+        kernels[label] = screen.NvrtcKernel(cuda_lib, image, "instancenorm_kernel")
+    try:
+        for offset in [0, 10, 100, 1000, -1000]:
+            torch.manual_seed(0)
+            x = (torch.randn(8, 64, 128, 128) + offset).cuda()
+            with torch.no_grad():
+                truth = torch.nn.functional.instance_norm(x.double(), eps=1e-5)
+                reference = K.PROBLEMS[PROBLEM]["ref"](x)
+                row = {"offset": offset, "torch_fp32_max_abs_error":
+                       float((reference.double() - truth).abs().max())}
+                for label, kernel in kernels.items():
+                    out = kernel.launch(PROBLEM, [x], torch)
+                    error = float((out.double() - truth).abs().max())
+                    row[label + "_max_abs_error"] = error
+                    if label == "fixed":
+                        if not torch.isfinite(out).all() or error >= 1e-3:
+                            raise RuntimeError(f"Fixed precision regression failed: {row}")
+                        if screen.compare(reference, out, torch) != "survived":
+                            raise RuntimeError(f"Fixed benchmark comparison failed: {row}")
+                    del out
+                report["runs"].append(row)
+                print(json.dumps(row), flush=True)
+                del x, truth, reference
+                torch.cuda.empty_cache()
+    finally:
+        for kernel in kernels.values():
+            kernel.unload()
+    shifted = [r for r in report["runs"] if abs(r["offset"]) == 1000]
+    if not any(r["baseline_max_abs_error"] > 1e-2 for r in shifted):
+        raise RuntimeError("Original precision failure was not reproduced on this GPU")
+    write_json(run_dir / "verification.json", report)
+
+
+def run_phase(phase, run_dir):
+    torch, K, screen, matrix = load_runtime(run_dir)
+    functions = {"probe": screen.probe, "screen": screen.worker, "matrix": matrix.worker}
+    functions[phase](PROBLEM)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run-dir", required=True, type=Path)
+    parser.add_argument("--worker", choices=["verify", "probe", "screen", "matrix"])
+    args = parser.parse_args()
+    os.environ["MUTANT_CAP"] = "0"
+    run_dir = args.run_dir.resolve()
+    if args.worker:
+        if args.worker == "verify":
+            verify(run_dir)
+        else:
+            run_phase(args.worker, run_dir)
+        return
+    if run_dir.exists():
+        raise RuntimeError("Use a NEW run directory; never reuse old mutation journals")
+    run_dir.mkdir(parents=True)
+    write_json(run_dir / "manifest.json", dict(source_hashes=fingerprint(),
+                                              baseline_revision=BASELINE_REVISION,
+                                              status="running"))
+    command = [sys.executable, str(Path(__file__).resolve()), "--run-dir", str(run_dir)]
+    subprocess.run(command + ["--worker", "verify"], check=True, timeout=900)
+    for phase, filename, marker in [("probe", "screen_instancenorm.jsonl", "PROBE_DONE"),
+                                    ("screen", "screen_instancenorm.jsonl", "DONE"),
+                                    ("matrix", "matrix_instancenorm.jsonl", "MDONE")]:
+        journal = run_dir / filename
+        for attempt in range(120):
+            previous = journal.stat().st_size if journal.exists() else 0
+            log_path = run_dir / f"{phase}-{attempt}.log"
+            with log_path.open("w") as log:
+                result = subprocess.run(command + ["--worker", phase], stdout=log,
+                                        stderr=subprocess.STDOUT, timeout=1800)
+            log_text = log_path.read_text()
+            rows = records(journal) if journal.exists() else []
+            check_infrastructure_failure(log_text, rows, result.returncode)
+            if result.returncode == 0 and any(r["type"] == marker for r in rows):
+                break
+            if not journal.exists() or journal.stat().st_size <= previous:
+                raise RuntimeError(f"No journal progress; inspect {log_path}")
+            print(f"{phase}: recovering after mutant crash, attempt {attempt + 1}", flush=True)
+        else:
+            raise RuntimeError(f"{phase} did not finish")
+    if json.loads((run_dir / "manifest.json").read_text())["source_hashes"] != fingerprint():
+        raise RuntimeError("Source changed during measurement")
+    screen_rows = records(run_dir / "screen_instancenorm.jsonl")
+    matrix_rows = records(run_dir / "matrix_instancenorm.jsonl")
+    _, K, _, _ = load_runtime(run_dir)
+    import mutator
+    from nvrtc_tce import device_source
+    generated = list(mutator.generate(PROBLEM, device_source(K.PROBLEMS[PROBLEM]["cuda"])))
+    validate_records(screen_rows, matrix_rows, {r["id"] for r in generated},
+                     {n for n, _, _ in K.PROBLEMS[PROBLEM]["suites"]() if n != "T0_original"})
+    witnesses, summary = export_records(screen_rows, matrix_rows)
+    write_json(run_dir / "instancenorm.json", witnesses)
+    write_json(run_dir / "summary_instancenorm.json", summary)
+    manifest = json.loads((run_dir / "manifest.json").read_text())
+    manifest.update(status="complete", summary=summary,
+                    classifications=dict(collections.Counter(
+                        r["cls"] for r in screen_rows if r["type"] == "RESULT")))
+    write_json(run_dir / "manifest.json", manifest)
+    print(json.dumps(manifest, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

repairs/instancenorm/README.md

@@ -0,0 +1,88 @@
+# InstanceNorm cancellation repair — CUDA validation pending
+
+The central correctness finding in Jayden Vasquez's report is valid:
+`E[x^2] - mean^2` in fp32 loses precision when the input mean is large relative
+to its standard deviation. The fixed substrate computes the mean first, then
+reduces squared centered differences. The reference, launch geometry, original
+inputs, epsilon and benchmark comparison tolerance are unchanged.
+
+Source report: [reproduction](https://gist.github.com/jayden1711/b9c73089192deb6bc34e8b68318dfc78)
+and [proposed patch](https://gist.github.com/jayden1711/f9399cb65a1abfd9145ff6e40baaba0b).
+The variance change follows the proposed patch; this repair also adds positive
+and negative shifted-input suites and a fresh measurement/export entry point.
+
+## Independently checked
+
+Baseline: `d04d6fc72504750804c4f4b45b4a8d7dc7c1880d`. Its InstanceNorm source
+matches the local baseline byte-for-byte.
+
+The CPU regression compiles and runs the actual `CUDA_SOURCE` body, using
+256 CPU threads with shared arrays and barriers. It compares the output with a
+float64 calculation on the same fp32 input values. This is a numerical check,
+not CUDA execution or a GPU race/performance check.
+
+| Input | Baseline max absolute error | Fixed max absolute error |
+| --- | ---: | ---: |
+| Normal noise + 1000, 2 planes of 128 × 128 | 0.160885 | 0.000029383 |
+| Normal noise - 1000, 2 planes of 37 × 43 | 0.221997 | 0.000059989 |
+| Zero-centered noise, 2 planes of 37 × 43 | 0.000000297 | 0.000000297 |
+| Constant 1000, 2 planes of 17 × 19 | 0 | 0 |
+
+The old source fails both shifted regressions at a 1e-3 max-absolute-error
+threshold. The fixed source passes all four. Exact inputs, environment and
+source hashes are recorded in [cpu_results.json](cpu_results.json).
+
+Run the local numerical and export checks with NumPy and a C++17 compiler:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+The report's description of all existing suite means as near zero is imprecise:
+T0/T2 use uniform positive inputs and T3 includes positive spikes. The meaningful
+coverage gap is large absolute means with small within-plane variation.
+
+The reporter's exact RTX 5080 errors, two-pass GPU error and 1.33× timing ratio
+have not been independently reproduced. Nor does this check establish the
+correctness of other normalization substrates. Several fused substrates also
+contain raw-second-moment variance expressions and require separate analysis.
+
+## Mutation measurements must be regenerated
+
+All 124 published rules load in the repair runner. They generate 67 syntactic
+mutation candidates from the old source and 84 from the changed source, before
+compilation and equivalence filtering. The published 66 records describe the
+old filtered pool. Even reused mutation IDs must not inherit old classifications
+because the underlying source has changed.
+
+The baseline summary reports 64 witnessed mutants, while its witness JSON
+contains 48 official kills, 9 targeted kills and 9 no-witness entries. Full-matrix
+discoveries might explain that difference; the original raw matrix is not part
+of the release. The new exporter promotes matrix-only kills to explicit witnesses
+and calculates its summary from those exported records.
+
+On an NVIDIA GPU with CUDA 12.x, PyTorch and at least 40 GiB free device memory:
+
+```bash
+python pipeline/repair_instancenorm.py --run-dir /tmp/instancenorm-repair
+```
+
+Use a new directory each time. The runner loads this substrate directly despite
+the release's flattened substrate layout, checks all six suites against the
+unchanged reference, compares baseline/fixed outputs with float64 at offsets
+0, 10, 100, 1000 and -1000, then performs fresh probe, screening and full-matrix
+passes. It uses the published compiler and crash-isolation pipeline and records
+the GPU, software versions and source hashes. Infrastructure allocation failures
+abort the run instead of being counted as mutant kills.
+
+Only after `manifest.json` says `complete` and the source hashes match should
+the generated `instancenorm.json`, `summary_instancenorm.json`,
+`verification.json` and raw journals be incorporated into the release. Update
+only the InstanceNorm entry of `summary.json` and preserve all other problems.
+Publish its new admission evidence alongside those measurements in one commit.
+
+Until then, this is a repair proposal: existing witnesses, admission reports and
+summary entries still describe the baseline. Global paper aggregates, including
+holdout and ladder results, are also baseline snapshots and must remain labeled
+as such unless those analyses are rerun. No GPU validation or new witness
+classification is claimed by this branch.

repairs/instancenorm/cpu_results.json

@@ -0,0 +1,91 @@
+{
+  "method": "Actual CUDA_SOURCE compiled with C++17; __shared__ arrays shared among 256 CPU threads, __syncthreads mapped to a barrier. Not CUDA execution.",
+  "environment": "macOS-26.6.2-arm64-arm-64bit",
+  "numpy": "2.0.2",
+  "max_abs_error_threshold": 0.001,
+  "baseline_revision": "d04d6fc72504750804c4f4b45b4a8d7dc7c1880d",
+  "results": {
+    "baseline": {
+      "source_sha256": "356b305c8038dea0244ad08100da0b650ffc1210c46edc7c891ca35017ae9fad",
+      "cases": {
+        "large_positive_mean": {
+          "shape": [
+            2,
+            128,
+            128
+          ],
+          "max_abs_error": 0.1608845495314628,
+          "passed": false
+        },
+        "large_negative_mean_odd_spatial_size": {
+          "shape": [
+            2,
+            37,
+            43
+          ],
+          "max_abs_error": 0.22199731572928982,
+          "passed": false
+        },
+        "zero_centered": {
+          "shape": [
+            2,
+            37,
+            43
+          ],
+          "max_abs_error": 2.96955678713573e-07,
+          "passed": true
+        },
+        "constant_planes": {
+          "shape": [
+            2,
+            17,
+            19
+          ],
+          "max_abs_error": 0.0,
+          "passed": true
+        }
+      }
+    },
+    "fixed": {
+      "source_sha256": "4829cad8728bcc1c99c582fb1da28bc6aa3e2a83f845ae7d7c4c520b2eab6d52",
+      "cases": {
+        "large_positive_mean": {
+          "shape": [
+            2,
+            128,
+            128
+          ],
+          "max_abs_error": 2.9382815827982967e-05,
+          "passed": true
+        },
+        "large_negative_mean_odd_spatial_size": {
+          "shape": [
+            2,
+            37,
+            43
+          ],
+          "max_abs_error": 5.998870941592571e-05,
+          "passed": true
+        },
+        "zero_centered": {
+          "shape": [
+            2,
+            37,
+            43
+          ],
+          "max_abs_error": 2.96955678713573e-07,
+          "passed": true
+        },
+        "constant_planes": {
+          "shape": [
+            2,
+            17,
+            19
+          ],
+          "max_abs_error": 0.0,
+          "passed": true
+        }
+      }
+    }
+  }
+}

substrates/candidate_instancenorm.py

@@ -19,23 +19,39 @@ __global__ void instancenorm_kernel(const float* x, float* out,
         if (offset < spatial) {
             float value = x[base + offset];
             local_sum += value;
-            local_square_sum += value * value;
         }
     }
     sums[tid] = local_sum;
-    square_sums[tid] = local_square_sum;
     __syncthreads(); // sync-after-partial-sums
 
     for (int stride = 128; stride > 0; stride >>= 1) {
         if (tid < stride) {
             sums[tid] += sums[tid + stride];
-            square_sums[tid] += square_sums[tid + stride];
         }
         __syncthreads(); // sync-during-reduction
     }
 
     float mean = sums[0] / (float)spatial;
-    float variance = square_sums[0] / (float)spatial - mean * mean;
+
+    // Two-pass variance avoids cancellation when |mean| is much larger than std.
+    for (long long iteration = 0; iteration < iterations; iteration++) {
+        long long offset = iteration * 256 + tid;
+        if (offset < spatial) {
+            float centered = x[base + offset] - mean;
+            local_square_sum += centered * centered;
+        }
+    }
+    square_sums[tid] = local_square_sum;
+    __syncthreads(); // sync-after-partial-square-sums
+
+    for (int stride = 128; stride > 0; stride >>= 1) {
+        if (tid < stride) {
+            square_sums[tid] += square_sums[tid + stride];
+        }
+        __syncthreads(); // sync-during-square-reduction
+    }
+
+    float variance = square_sums[0] / (float)spatial;
     variance = fmaxf(variance, 0.0f);
     float inverse_std = rsqrtf(variance + 1.0e-5f);
     __syncthreads(); // sync-before-normalization
@@ -87,10 +103,20 @@ def register(K, torch, ctypes):
             x[:, :, -1, -1] = 50.0
             return [x]
 
+        def t4_large_positive_mean(t):
+            torch.manual_seed(5000 + t)
+            return [torch.randn(2, 4, 128, 128) + 1000.0]
+
+        def t5_large_negative_mean(t):
+            torch.manual_seed(6000 + t)
+            return [torch.randn(2, 3, 37, 43) - 1000.0]
+
         return [("T0_original", 5, t0_original),
                 ("T1_signed", 2, t1_signed),
                 ("T2_misaligned", 2, t2_misaligned),
-                ("T3_spatial_spike", 1, t3_spatial_spike)]
+                ("T3_spatial_spike", 1, t3_spatial_spike),
+                ("T4_large_positive_mean", 2, t4_large_positive_mean),
+                ("T5_large_negative_mean", 2, t5_large_negative_mean)]
 
     def probe(torch_module):
         torch_module.manual_seed(0)

tests/instancenorm_cpu_harness.cpp

@@ -0,0 +1,63 @@
+// Numerical regression harness only: executes one CUDA block at a time on CPU.
+// This checks the actual kernel body, but cannot validate GPU race behavior,
+// CUDA compilation, approximate rsqrt, or performance.
+#include <cmath>
+#include <condition_variable>
+#include <cstdlib>
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+struct Dim { int x = 0; int y = 0; int z = 0; };
+thread_local Dim blockIdx, threadIdx;
+
+class BlockBarrier {
+    std::mutex mutex;
+    std::condition_variable ready;
+    int arrived = 0;
+    int generation = 0;
+public:
+    void wait() {
+        std::unique_lock<std::mutex> lock(mutex);
+        int current = generation;
+        if (++arrived == 256) {
+            arrived = 0;
+            ++generation;
+            ready.notify_all();
+        } else {
+            ready.wait(lock, [&] { return generation != current; });
+        }
+    }
+};
+BlockBarrier barrier;
+#define __global__
+#define __shared__ static
+#define __syncthreads() barrier.wait()
+float rsqrtf(float x) { return 1.0f / std::sqrt(x); }
+
+// KERNEL_BODY
+
+int main(int argc, char** argv) {
+    if (argc != 4) return 2;
+    int planes = std::atoi(argv[1]);
+    int height = std::atoi(argv[2]);
+    int width = std::atoi(argv[3]);
+    size_t count = size_t(planes) * height * width;
+    std::vector<float> x(count), out(count, NAN);
+    std::cin.read(reinterpret_cast<char*>(x.data()), count * sizeof(float));
+    if (!std::cin) return 3;
+    std::vector<std::thread> workers;
+    for (int tid = 0; tid < 256; ++tid) {
+        workers.emplace_back([&, tid] {
+            threadIdx.x = tid;
+            for (int plane = 0; plane < planes; ++plane) {
+                blockIdx.x = plane;
+                instancenorm_kernel(x.data(), out.data(), planes, height, width);
+                barrier.wait();
+            }
+        });
+    }
+    for (auto& worker : workers) worker.join();
+    std::cout.write(reinterpret_cast<const char*>(out.data()), count * sizeof(float));
+}

tests/test_instancenorm.py

@@ -0,0 +1,69 @@
+"""Run the actual kernel arithmetic on CPU; real CUDA verification is separate.
+
+Requires NumPy and a C++17 compiler. No PyTorch or NVIDIA GPU is needed.
+"""
+import importlib.util
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+import numpy as np
+
+ARTIFACT = Path(__file__).resolve().parents[1]
+
+
+class InstanceNormNumerics(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        compiler = shutil.which("c++")
+        if compiler is None:
+            raise unittest.SkipTest("C++17 compiler required for CPU numerical harness")
+        spec = importlib.util.spec_from_file_location(
+            "candidate_instancenorm", ARTIFACT / "substrates/candidate_instancenorm.py")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        source = module.CUDA_SOURCE.replace("#include <cuda_fp16.h>", "")
+        harness = Path(__file__).with_name("instancenorm_cpu_harness.cpp").read_text()
+        cls.temp = tempfile.TemporaryDirectory()
+        cls.addClassCleanup(cls.temp.cleanup)
+        path = Path(cls.temp.name)
+        (path / "kernel.cpp").write_text(harness.replace("// KERNEL_BODY", source))
+        cls.binary = path / "kernel"
+        subprocess.run([compiler, "-std=c++17", "-O2", "-ffp-contract=fast", "-pthread",
+                        str(path / "kernel.cpp"), "-o", str(cls.binary)], check=True,
+                       capture_output=True)
+
+    def check_input(self, x):
+        planes, height, width = x.shape
+        result = subprocess.run([str(self.binary), str(planes), str(height), str(width)],
+                                input=x.tobytes(), capture_output=True, check=True,
+                                timeout=60)
+        actual = np.frombuffer(result.stdout, dtype=np.float32).reshape(x.shape)
+        double = x.astype(np.float64)
+        centered = double - double.mean(axis=(1, 2), keepdims=True)
+        expected = centered / np.sqrt(
+            (centered * centered).mean(axis=(1, 2), keepdims=True) + 1e-5)
+        error = float(np.max(np.abs(actual - expected)))
+        self.assertTrue(np.isfinite(actual).all())
+        self.assertLess(error, 1e-3, f"maximum error against float64: {error}")
+
+    def test_large_positive_mean(self):
+        x = np.random.default_rng(0).standard_normal((2, 128, 128), dtype=np.float32)
+        self.check_input(x + np.float32(1000))
+
+    def test_large_negative_mean_odd_spatial_size(self):
+        x = np.random.default_rng(1).standard_normal((2, 37, 43), dtype=np.float32)
+        self.check_input(x - np.float32(1000))
+
+    def test_zero_centered(self):
+        x = np.random.default_rng(2).standard_normal((2, 37, 43), dtype=np.float32)
+        self.check_input(x)
+
+    def test_constant_planes(self):
+        self.check_input(np.full((2, 17, 19), 1000, dtype=np.float32))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_instancenorm_export.py

@@ -0,0 +1,58 @@
+"""The repaired source must never inherit old witness classifications."""
+import importlib.util
+from pathlib import Path
+import unittest
+
+path = Path(__file__).resolve().parents[1] / "pipeline/repair_instancenorm.py"
+spec = importlib.util.spec_from_file_location("repair_instancenorm", path)
+repair = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(repair)
+
+
+def result(mid, cls):
+    return dict(type="RESULT", id=mid, cls=cls, rule="test-rule",
+                category="arithmetic", site="a * b", witness=None)
+
+
+class WitnessExport(unittest.TestCase):
+    def test_oom_hidden_in_journal_is_not_a_mutant_kill(self):
+        row = result("a", "killed_by_T0")
+        row.update(reason="crash", detail="CUDA out of memory. Tried to allocate 7 GiB")
+        with self.assertRaisesRegex(RuntimeError, "Infrastructure"):
+            repair.check_infrastructure_failure("", [row], 3)
+
+    def test_operating_system_kill_is_not_a_mutant_kill(self):
+        with self.assertRaisesRegex(RuntimeError, "Infrastructure"):
+            repair.check_infrastructure_failure("", [], -9)
+
+    def test_matrix_only_kill_updates_witness_and_denominator(self):
+        screening = [result("a", "killed_by_T0"), result("b", "no_witness"),
+                     result("c", "compile_fail"), result("d", "no_witness")]
+        matrix = [dict(type="CELL", id="b", suite="shifted", outcome="killed")]
+        witnesses, summary = repair.export_records(screening, matrix)
+        self.assertEqual(witnesses["b"]["cls"], "high_value")
+        self.assertEqual(witnesses["b"]["witness"], "shifted")
+        self.assertNotIn("c", witnesses)
+        self.assertEqual(summary, dict(mutants=3, witnessed=2,
+                                       killed_by_official=1, level=12))
+
+    def test_missing_screening_result_is_rejected(self):
+        with self.assertRaisesRegex(RuntimeError, "Screening"):
+            repair.validate_records([result("a", "no_witness")], [], {"a", "b"}, set())
+
+    def test_missing_matrix_cell_is_rejected(self):
+        with self.assertRaisesRegex(RuntimeError, "matrix"):
+            repair.validate_records([result("a", "no_witness")], [], {"a"}, {"shifted"})
+
+    def test_crash_records_do_not_require_unsafe_reexecution(self):
+        row = result("a", "killed_by_T0")
+        row["reason"] = "probe_crash"
+        repair.validate_records([row], [], {"a"}, {"shifted"})
+
+    def test_complete_matrix_is_accepted(self):
+        cell = dict(type="CELL", id="a", suite="shifted", outcome="survived")
+        repair.validate_records([result("a", "no_witness")], [cell], {"a"}, {"shifted"})
+
+
+if __name__ == "__main__":
+    unittest.main()