KernelBench-M artifact: rules, substrates, witnesses, pipeline, summaries

LEVEL3_BRIEF.md

@@ -0,0 +1,59 @@
+# Brief: level-3 substrates (full architectures, multi-kernel)
+
+Level-3 KernelBench problems are whole networks. Their substrate is a PIPELINE
+of kernels — one `__global__` per layer — so that a mutation lands in a
+specific layer and we can measure how far a fault propagates through depth.
+
+Read `substrates/SPEC.md` first for the general contract, then the differences
+below. Read `problems_batch2.py` for the CUDA style, and at least two accepted
+substrates from `substrates/accepted/`.
+
+## What changes vs a level-1/2 substrate
+
+1. `cuda` holds SEVERAL `__global__` kernels, one per layer of the network
+   (e.g. `mlp_gemm_relu_kernel`, `mlp_gemm_kernel`). Name them so the layer is
+   identifiable.
+2. `kernel_name` is a LIST of those symbol names, in pipeline order.
+3. `launch` returns a DICT describing the sequence instead of a single tuple:
+
+```python
+def launch(inputs, torch):
+    x = inputs[0]
+    ...
+    bufs = [torch.zeros(...), ...]        # intermediate activations
+    seq = [
+        # (kernel_name, grid3, block3, [tensor args in order], [(ctype, scalar), ...])
+        ("layer0_kernel", (gx, gy, 1), (32, 32, 1), [x, w0, b0, bufs[0]],
+         [(ctypes.c_int, M), (ctypes.c_int, K), (ctypes.c_int, N)]),
+        ("layer1_kernel", ..., [bufs[0], w1, b1, out], [...]),
+    ]
+    return {"seq": seq, "out": out}
+```
+
+   Tensor arguments are passed as data pointers in the order listed; scalars
+   follow. Allocate intermediates inside `launch`.
+
+4. WEIGHTS: the reference `Model` owns nn.Parameters. Create them ONCE with a
+   fixed seed inside the substrate module (module-level, lazily on first use),
+   and have `ref` use THE SAME tensors, so reference and kernel see identical
+   weights. Put them on the input's device.
+
+5. `ref` must reproduce the KernelBench `Model.forward` exactly, using those
+   same weights (e.g. `torch.nn.functional.linear(x, W0, b0).relu()` ...).
+
+6. Suites: `T0_original` must reproduce the problem's `get_inputs()`; add 2-3
+   targeted suites. Keep the legitimate-variance ceiling in mind: prefer
+   same-sign large values over signed ones.
+
+## Performance does not matter
+
+Naive kernels are fine (one thread per output element, sequential loops). What
+matters is: correct, readable, and rich in mutation sites (explicit bounds
+guards, ceil-division, distinct `__syncthreads()` where relevant).
+
+## Deliverable
+
+`substrates/candidate_L3p<N>_<short>.py` with a `register(K, torch, ctypes)`
+function exactly as in SPEC.md, plus `kernel_name` as a list and the dict-style
+`launch` above. Import-safe, no GPU work at import time, do not modify other
+files.

README.md

@@ -0,0 +1,76 @@
+# KernelBench-M
+
+The measurement artifact for *Measuring the Checker: Mutation Analysis for
+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.
+
+## Layout
+
+```
+rules/          124 mutation rules, six families (mutator.py loads all of them)
+substrates/     208 gate-verified CUDA implementations, one per KernelBench
+                problem: the mutation targets. Never used as oracle.
+witnesses/      per-problem kill records: for every mutant, its rule, family,
+                mutated site, whether the official protocol kills it, and — when
+                it survives — a suite that does
+pipeline/       the measurement code (screening, kill matrix, audit, set cover)
+summary.json    per-problem mutant / witnessed / official-kill counts
+```
+
+Supporting records: `mechanism_curves.json` (Fig. 2b–c), `holdout.json`
+(dev/test split), `ladder_summary.json` (knowledge ladder),
+`gate_report.json` (substrate admission), `invalid_suites.json` (suites
+rejected for crossing the validity ceiling).
+
+## What a substrate is, and is not
+
+KernelBench ships PyTorch references whose GPU execution bottoms out in closed
+cuDNN/cuBLAS binaries, so there is no source to mutate. A *substrate* is a
+correct CUDA implementation of the same computation, used **only** as a
+mutation target. The oracle stays the benchmark's own PyTorch reference. Each
+substrate is admitted by `pipeline/gate_candidates.py`, which compares it
+against that reference on every suite before it may enter the pool
+(`gate_report.json` records admissions and rejections).
+
+## Witness format
+
+```json
+"softmax:barrier-drop:3": {
+  "rule": "barrier-drop", "family": "sync",
+  "site": "__syncthreads();",
+  "cls": "high_value",
+  "killed_by_official": false,
+  "witness": "T2_misaligned_batch"
+}
+```
+
+`cls` is `killed_by_T0` (the official inputs detect it), `high_value` (survives
+the official inputs, a targeted input detects it), or `no_witness` (nothing we
+have detects it — an equivalence or oracle-blindness candidate, excluded from
+every denominator in the paper).
+
+## Reproducing
+
+Requires an NVIDIA GPU with CUDA 12.x and PyTorch. From `pipeline/`:
+
+```bash
+python screen_mutants.py     # generate, filter, and screen mutants
+python full_matrix.py        # kill matrix over all suites
+python audit_matrix.py       # score competing protocols (§5)
+python analyze_cover.py      # set-cover suite synthesis (§6)
+python analyze_holdout.py    # dev/test holdout (§6)
+```
+
+Each stage writes append-only JSONL journals and resumes from them, so a
+crashed or preempted run can simply be restarted. `SHARD_ID`/`SHARD_N` split
+problems across GPUs; `STEAL=1` lets an idle worker pick up unclaimed problems.
+
+## Caveats
+
+Mutation score is adequacy relative to this fault model, not absolute
+correctness: these operators cannot express faults living in structures the
+substrates do not contain (tensor-core paths, double-buffered pipelines), nor
+multi-site interactions. The artifact supports comparative claims between
+protocols and existence claims about specific faults. It cannot certify that a
+kernel passing these suites is correct.

SPEC.md

@@ -0,0 +1,69 @@
+# Substrate candidate spec (for automated kernel authors)
+
+A substrate is a CORRECT CUDA implementation of one KernelBench level1 problem,
+used as the mutation target. It is NOT the correctness oracle (the official
+PyTorch reference is). Every candidate must pass an automated gate comparing it
+against the official reference on multiple input suites before admission.
+
+## Deliverable
+
+One Python file: `substrates/candidate_<name>.py` (snake_case short name).
+It must be import-safe (no GPU work at import time) and define exactly:
+
+```python
+def register(K, torch, ctypes):
+    K.PROBLEMS["<name>"] = dict(
+        kb_file="<original KernelBench filename>",
+        cuda=CUDA_SOURCE,          # device-only source, see rules below
+        kernel_name="<kernel symbol>",
+        ref=<callable>,            # torch reference, MUST match the KB Model's
+                                   # forward() semantics exactly (params from
+                                   # get_init_inputs() defaults)
+        launch=<callable>,         # (inputs, torch) -> (out_tensor, grid3,
+                                   # block3, [(ctypes_type, value), ...])
+        suites=<callable>,         # () -> [(name, n_trials, builder)]
+        probe=<callable>,          # (torch) -> [(name, [small cpu tensors])]
+    )
+```
+
+## CUDA source rules
+
+- Device code ONLY: `__global__` kernel(s) + `#include <cuda_fp16.h>` (and
+  `<math_constants.h>` if needed). NO torch headers, NO host wrapper.
+  It is compiled with NVRTC; the launch config lives in the Python `launch`.
+- fp32 in/out. Use `long long` for any index that can exceed 2^31.
+- One thread-block pattern from the proven set when applicable:
+  elementwise 1D grid; block-per-row with 256-thread shared-memory reduction;
+  32x32 shared-memory tiles for matmul; column-thread + row-loop for
+  dim-1 reductions. Look at ../problems_batch2.py for working examples of all
+  four patterns, including suites/probe conventions.
+- Structure the source so mutation sites are visible: keep bounds guards as
+  single-line `if (...) { ... }` or `if (...) return;`, use ceil-division
+  `(x + K - 1) / K`, label repeated `__syncthreads();` with distinct trailing
+  comments (e.g. `// sync-after-load`).
+
+## Suites rules
+
+- `T0_original`: EXACTLY the shapes/distribution of the problem's
+  `get_inputs()` (5 trials, seed `1000 + t`).
+- Plus 2-3 targeted suites: signed values, misaligned shapes (dims not
+  divisible by 32/256), and a structure-specific stressor (spike/large values)
+  where meaningful. Seed every builder deterministically.
+- CRITICAL: no suite may false-kill a correct implementation. Avoid
+  large-magnitude SIGNED values feeding long accumulations (catastrophic
+  cancellation exceeds the 1e-2 tolerance between two legitimate fp32
+  implementations); use positive-only values for large-magnitude suites.
+
+## Probe rules
+
+Tiny CPU tensors (<1 MB), 2 entries: one aligned T0-like, one misaligned.
+
+## Semantics rules
+
+- Read the KernelBench problem file CAREFULLY: match forward() exactly
+  (e.g. L1Norm divides by mean(|x|), NOT sum; reductions may or may not
+  keepdim; losses reduce to a scalar with 'mean').
+- Scalar outputs: return a 0-dim or shape-(1,) tensor from launch's out and
+  make ref produce the matching shape.
+- Integer-output ops (argmax/argmin): out dtype int64 in launch, ref returns
+  the indices tensor; comparison is exact.

WITNESS_BRIEF.md

@@ -0,0 +1,72 @@
+# Brief: write killer inputs for surviving mutants
+
+## Situation
+
+For your assigned task, a set of MUTANTS (deliberately faulty variants of the
+task's correct CUDA kernel) survives every test input we currently have — the
+benchmark's original inputs AND our targeted suites. Your job is to design
+additional test inputs that expose them.
+
+The correctness check is fixed and is NOT yours to change:
+    torch.allclose(reference_output, kernel_output, atol=1e-2, rtol=1e-2)
+where reference_output comes from the official PyTorch implementation.
+
+## Hard constraint (violating this fails the work)
+
+A new input MUST NOT make the CORRECT kernel fail the check. Two legitimate
+fp32 implementations differ by accumulation order; if you push magnitudes too
+far, cancellation makes the correct kernel itself exceed the tolerance and the
+input is worthless (it would reject valid submissions).
+
+Measured ceiling on a K=8192 reduction:
+    signed values (randn * s):   safe to s≈100, FALSE-KILLS at s≈300
+    positive values (|randn|* s): safe to s≈3000 and beyond
+So: to test large magnitudes, use SAME-SIGN large values, not signed ones.
+
+## Why mutants survive, and what input defeats each family
+
+- `loop-bound-minus1`, `loop-start-1`, `strided-tail-drop`: the kernel skips
+  the first/last element of a loop. Under uniform random input, one missing
+  term out of thousands is far below tolerance. KILLER: make the skipped
+  position carry almost all the mass — e.g. all entries tiny (1e-3) except
+  the first/last of the reduced axis set to a large positive value; or use a
+  reduction length short enough that one term matters.
+- `sync-remove`, `sync2syncwarp`: a barrier is gone, so a thread may read a
+  shared-memory slot before its partner wrote it. With uniform values the
+  stale and fresh values are close, so the error hides. KILLER: make adjacent
+  lanes carry wildly different magnitudes (e.g. alternate 1e-4 and 1e3 across
+  the reduced axis), so reading the wrong one is unmistakable.
+- `store-fp16`, precision-family: output rounded through fp16 (rel. error
+  ~1e-3). Hidden while |output| is small. KILLER: drive OUTPUT magnitude up
+  (positive-only large inputs), so rtol*|out| still bounds but the absolute
+  fp16 rounding error exceeds atol — or make outputs land near fp16 subnormal
+  or above 65504 (fp16 overflow -> inf).
+- `lt2le`, `ge2gt`, guard mutations: off-by-one at the boundary. KILLER: use
+  a MISALIGNED shape (dimension not divisible by 32/256) so a partial block
+  exists, and place extreme values in the final positions.
+- `mul2div`, `mul2plus` on index arithmetic: wrong element read. Under a
+  smooth random tensor neighbouring values are similar. KILLER: make the
+  tensor's value depend sharply on position (e.g. value = row*1000 + col),
+  so any index error yields a wildly wrong number.
+- tie-breaking / sentinel families: ties have probability zero under
+  continuous random input. KILLER: inputs with DUPLICATE values, all-negative
+  rows, or NaN/Inf entries where the reference has defined behaviour.
+
+## Deliverable
+
+Edit ONLY the `suites` function of the task's substrate file (path given in
+your prompt). Keep `T0_original` EXACTLY as it is. Append 2-4 new suites,
+each `(name, 1, builder)` with a deterministic seed, targeting the mutant
+families listed in your prompt. Name them descriptively, e.g.
+`T5_tail_mass_spike`, `T6_alternating_magnitude`, `T7_positional_ramp`.
+
+Rules:
+- Keep tensor shapes at or below the original problem's element count (memory).
+- Same dtype and rank as T0; shapes may be misaligned.
+- No NaN/Inf unless the reference implementation defines behaviour for them.
+- Do not modify the CUDA source, ref, launch, or probe.
+- The file must remain import-safe; do not run GPU code.
+
+Think about what the FUSED chain does end-to-end: a value that is extreme at
+the input may be squashed by a sigmoid/softmax later, making the fault
+invisible again. Choose inputs whose extremeness SURVIVES to the output.

gate_report.json

@@ -0,0 +1,102 @@
+[
+ {
+  "problem": "L2p100_convtranspose3d_clamp",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p10_convtranspose2d_maxpoo",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p26_convtranspose3d_add_hardswish",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p60_convtranspose3d_swish",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p77_convtranspose3d_scale",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p7_conv3d_relu_leakyrelu",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p92_conv2d_groupnorm_tanh",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p94_gemm_biasadd_hardtanh",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p95_matmul_add_swish_tanh",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L2p9_matmul_subtract_multiply_relu",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L3p20_mobilenetv2",
+  "admitted": false,
+  "detail": "T3_positive_spikes/t0: value max_diff=0.01602"
+ },
+ {
+  "problem": "L3p24_efficientnetb2",
+  "admitted": false,
+  "detail": "T0_original/t0: value max_diff=1.422"
+ },
+ {
+  "problem": "L3p25_shufflenetunit",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L3p43_attention",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "L3p45_unetsoftmax",
+  "admitted": false,
+  "detail": "T0_original/t0: value max_diff=0.3798"
+ },
+ {
+  "problem": "L3p48_mamba2returny",
+  "admitted": false,
+  "detail": "T0_original/t0: value max_diff=8.576e+13"
+ },
+ {
+  "problem": "L3p49_mamba2returnfinalsta",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "batched_matrix_multiplication",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "matmul_with_large_k_dimension",
+  "admitted": true,
+  "detail": "ok"
+ },
+ {
+  "problem": "matmul_with_small_k_dimension",
+  "admitted": true,
+  "detail": "ok"
+ }
+]

holdout.json

@@ -0,0 +1,10 @@
+{
+ "problems": 152,
+ "official_T0_on_test": 0.8289722147288913,
+ "dev_selected_on_test": {
+  "1": 0.8448880496358241,
+  "2": 0.9482060965740491,
+  "3": 0.9638521715673051,
+  "5": 0.9660102508767198
+ }
+}

invalid_suites.json

@@ -0,0 +1,54 @@
+{
+ "elu": [
+  "T4_branch_threshold_sweep",
+  "T5_negative_exponential_ladder",
+  "T6_misaligned_alternating_tail"
+ ],
+ "gelu": [
+  "T4_misaligned_fp16_overflow",
+  "T5_erf_transition_grid"
+ ],
+ "leakyrelu": [
+  "T4_misaligned_tail_spikes",
+  "T5_threshold_transition_grid"
+ ],
+ "logsoftmax": [
+  "T3_spiky",
+  "T4_tail_spike_misaligned",
+  "T5_first_iteration_mass",
+  "T6_alternating_lane_magnitude",
+  "T7_fp16_overflow_misaligned"
+ ],
+ "matmul": [
+  "T4_last_tile_spike"
+ ],
+ "matmul_mk": [
+  "T4_last_tile_spike"
+ ],
+ "matmul_ta": [
+  "T4_last_tile_spike",
+  "T5_boundary_positional_ramps",
+  "T6_single_tail_mass_spike",
+  "T7_tile_minus1_alternating"
+ ],
+ "max": [
+  "T4_edge_row_spike",
+  "T5_all_negative",
+  "T6_alternating_duplicate_maxima",
+  "T7_first_middle_last_ties",
+  "T8_signed_zero_tie_order"
+ ],
+ "selu": [
+  "T4_branch_threshold_neighborhood",
+  "T5_misaligned_negative_stripes",
+  "T6_negative_exponential_sweep"
+ ],
+ "sigmoid": [
+  "T4_misaligned_alternating_tail",
+  "T5_fp16_transition_grid"
+ ],
+ "softmax": [
+  "T3_spiky",
+  "T4_tail_spike_misaligned"
+ ]
+}

ladder/BRIEF_R1.md

@@ -0,0 +1,27 @@
+# Task: write extra test inputs for a GPU kernel benchmark problem
+
+The benchmark checks a candidate CUDA kernel against a PyTorch reference with
+torch.allclose(atol=1e-2, rtol=1e-2) on a few input tensors. You suspect the
+current inputs may miss subtle bugs. Write 2 ADDITIONAL test-input suites for
+the assigned problem.
+
+Deliverable: ladder/suites_R1_<problem>.py containing exactly:
+
+```python
+import torch
+
+def suites():
+    def s1(trial):
+        g = torch.Generator().manual_seed(1000 + trial)
+        # return the SAME list of CPU tensors get_inputs() returns
+        # (same count, dtypes, and any shape constraints the kernel requires)
+        return [ ... ]
+    def s2(trial):
+        ...
+    return [("R1_a", 2, s1), ("R1_b", 2, s2)]
+```
+
+Read the substrate file you are pointed at to learn the input shapes/dtypes
+(its T0_original suite reproduces the official get_inputs()). Builders must be
+deterministic (seed from trial), return CPU tensors, and respect any shape
+constraints baked into the kernel/launcher. Do not modify any other file.

ladder/BRIEF_R3.md

@@ -0,0 +1,38 @@
+# Task: kill specific surviving mutants of a GPU kernel (white-box)
+
+The assigned problem has known SURVIVING MUTANTS: buggy variants of a correct
+CUDA kernel that the benchmark's current inputs cannot distinguish from the
+correct kernel (checker: torch.allclose(atol=1e-2, rtol=1e-2) vs the PyTorch
+reference). You get the mutant list (rule + mutated source site) in the info
+file you are pointed at. Write 2 test-input suites that make these mutants
+produce detectably different output.
+
+How to think: read each mutated site and construct inputs whose correct output
+is sensitive to that exact code path — boundary sizes that exercise remainder
+blocks for guard/bounds mutants, values with distinct magnitudes per position
+for indexing mutants, inputs that stress accumulation for precision mutants,
+non-uniform data for tie-breaking mutants.
+
+HARD VALIDITY CONSTRAINT: the CORRECT kernel must still pass. Two correct fp32
+implementations legitimately differ by accumulation order; measured on long
+reductions, SIGNED inputs (randn*s) are safe to about s=100 and falsely flag
+the correct kernel by s=300, while SAME-SIGN inputs stay safe past s=1000.
+Prefer same-sign magnitudes, moderate spikes, structured patterns — not huge
+signed values.
+
+Deliverable: ladder/suites_R3_<problem>.py, exactly this contract:
+
+```python
+import torch
+
+def suites():
+    def s1(trial):
+        g = torch.Generator().manual_seed(3000 + trial)
+        return [ ... ]  # same list of CPU tensors as get_inputs()
+    def s2(trial):
+        ...
+    return [("R3_a", 2, s1), ("R3_b", 2, s2)]
+```
+
+Deterministic builders, CPU tensors, keep every shape constraint the kernel
+requires (read the substrate file's T0_original). Do not modify other files.

ladder_summary.json

@@ -0,0 +1 @@
+{"total": 1154, "R0": 249, "R1": [495, 1154], "R2": 704, "R3": [626, 1092]}

mechanism_curves.json

@@ -0,0 +1,154 @@
+{
+ "vacuity": [
+  {
+   "dim": 64,
+   "mean_output": 0.015625,
+   "zeros_pass": false,
+   "max_undetected_rel_error": 0.3911769908881979
+  },
+  {
+   "dim": 512,
+   "mean_output": 0.001953125,
+   "zeros_pass": true,
+   "max_undetected_rel_error": 3.14493727273657
+  },
+  {
+   "dim": 4096,
+   "mean_output": 0.000244140625,
+   "zeros_pass": true,
+   "max_undetected_rel_error": 25.862332340693683
+  },
+  {
+   "dim": 32768,
+   "mean_output": 3.0517578125e-05,
+   "zeros_pass": true,
+   "max_undetected_rel_error": 208.68726348453492
+  },
+  {
+   "dim": 262144,
+   "mean_output": 3.814697265625e-06,
+   "zeros_pass": true,
+   "max_undetected_rel_error": 1671.7297973627865
+  },
+  {
+   "dim": 393216,
+   "mean_output": 2.543131586207892e-06,
+   "zeros_pass": true,
+   "max_undetected_rel_error": 2508.5181884696794
+  }
+ ],
+ "variance_ceiling": [
+  {
+   "dist": "signed",
+   "scale": 1,
+   "max_diff": 0.00091552734375,
+   "worst_margin": -0.009912180714309216,
+   "false_kill": false
+  },
+  {
+   "dist": "signed",
+   "scale": 3,
+   "max_diff": 0.002685546875,
+   "worst_margin": -0.009806494228541851,
+   "false_kill": false
+  },
+  {
+   "dist": "signed",
+   "scale": 10,
+   "max_diff": 0.00927734375,
+   "worst_margin": -0.009194783866405487,
+   "false_kill": false
+  },
+  {
+   "dist": "signed",
+   "scale": 30,
+   "max_diff": 0.0234375,
+   "worst_margin": -0.007786626927554607,
+   "false_kill": false
+  },
+  {
+   "dist": "signed",
+   "scale": 100,
+   "max_diff": 0.083984375,
+   "worst_margin": -0.0010235980153083801,
+   "false_kill": false
+  },
+  {
+   "dist": "signed",
+   "scale": 300,
+   "max_diff": 0.3125,
+   "worst_margin": 0.021475525572896004,
+   "false_kill": true
+  },
+  {
+   "dist": "signed",
+   "scale": 1000,
+   "max_diff": 0.84375,
+   "worst_margin": 0.06371429562568665,
+   "false_kill": true
+  },
+  {
+   "dist": "signed",
+   "scale": 3000,
+   "max_diff": 2.5625,
+   "worst_margin": 0.28810545802116394,
+   "false_kill": true
+  },
+  {
+   "dist": "positive",
+   "scale": 1,
+   "max_diff": 0.013916015625,
+   "worst_margin": -30.65578269958496,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 3,
+   "max_diff": 0.048828125,
+   "worst_margin": -91.94537353515625,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 10,
+   "max_diff": 0.1328125,
+   "worst_margin": -306.4940185546875,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 30,
+   "max_diff": 0.5,
+   "worst_margin": -919.3250122070312,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 100,
+   "max_diff": 1.5625,
+   "worst_margin": -3064.599609375,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 300,
+   "max_diff": 4.0,
+   "worst_margin": -9193.2548828125,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 1000,
+   "max_diff": 16.0,
+   "worst_margin": -30642.939453125,
+   "false_kill": false
+  },
+  {
+   "dist": "positive",
+   "scale": 3000,
+   "max_diff": 47.0,
+   "worst_margin": -91944.0078125,
+   "false_kill": false
+  }
+ ]
+}

miss_patterns.json

@@ -0,0 +1,157 @@
+{
+ "note": "Miss-pattern table behind figs/fig_matrix.pdf (operator scale, witnessed accounting). Each pattern lists which protocols miss the mutant; 'other' collapses the long tail of rarer patterns. Derived from results/audit_*.jsonl, screen_*.jsonl, matrix_*.jsonl, recheck_*.jsonl.",
+ "protocols": [
+  "Official",
+  "KBV x3",
+  "KBV x0.01",
+  "KBV x-1",
+  "CI-style fuzz",
+  "Ours"
+ ],
+ "denominator": 7320,
+ "caught_by_all": 6083,
+ "contested": 1237,
+ "patterns": [
+  {
+   "missed_by": [
+    true,
+    true,
+    true,
+    true,
+    true,
+    false
+   ],
+   "count": 643
+  },
+  {
+   "missed_by": [
+    true,
+    true,
+    true,
+    true,
+    false,
+    false
+   ],
+   "count": 254
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    true,
+    true,
+    false,
+    false
+   ],
+   "count": 135
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    true,
+    true,
+    true,
+    false
+   ],
+   "count": 51
+  },
+  {
+   "missed_by": [
+    true,
+    true,
+    false,
+    true,
+    false,
+    false
+   ],
+   "count": 46
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    false,
+    false,
+    false,
+    false
+   ],
+   "count": 38
+  },
+  {
+   "missed_by": [
+    true,
+    true,
+    true,
+    false,
+    false,
+    false
+   ],
+   "count": 13
+  },
+  {
+   "missed_by": [
+    true,
+    true,
+    false,
+    true,
+    true,
+    false
+   ],
+   "count": 10
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    true,
+    false,
+    false,
+    false
+   ],
+   "count": 7
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    false,
+    true,
+    true,
+    false
+   ],
+   "count": 6
+  },
+  {
+   "missed_by": [
+    true,
+    false,
+    true,
+    false,
+    true,
+    false
+   ],
+   "count": 6
+  },
+  {
+   "missed_by": [
+    true,
+    true,
+    true,
+    false,
+    true,
+    false
+   ],
+   "count": 6
+  }
+ ],
+ "other": 22,
+ "total_missed": [
+  1237,
+  985,
+  1124,
+  1155,
+  727,
+  10
+ ]
+}

pipeline/adjudicate.py

@@ -0,0 +1,207 @@
+"""Adjudicate the still-unkilled (no-witness) mutants: equivalent, or
+oracle-blind?
+
+Phase 1 — random bombardment: each surviving mutant gets N randomized inputs
+(mixed distributions, scales, AND shapes incl. misaligned) under the standard
+allclose oracle. A kill => witness found; record it (these mutants move into
+the killable pool).
+
+Phase 2 — compute-sanitizer: survivors of phase 1 run once on a small input
+under compute-sanitizer. Memory errors reported => real bug, oracle-blind
+(needs a sanitizer channel in the harness). Clean => likely equivalent.
+
+Output: results/adjudicate.jsonl + summary. Resume-safe like other runners.
+Usage: python3 adjudicate.py [--worker P]
+"""
+import ctypes
+import json
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import kernels_def as K  # noqa: E402
+import problems_ext      # noqa: E402,F401
+import mutator           # noqa: E402
+from nvrtc_tce import compile_ptx, device_source  # noqa: E402
+from screen_mutants import NvrtcKernel, compare, kernel_name, ref_fn_for  # noqa: E402
+from full_matrix import screening_classes  # noqa: E402
+
+FUZZ_TRIALS = 60
+
+
+def surviving_ids(problem):
+    """no_witness mutants not killed by the full matrix either."""
+    cls = screening_classes(problem)
+    nw = {i for i, r in cls.items() if r["cls"] == "no_witness"}
+    mpath = os.path.join(RESULTS, f"matrix_{problem}.jsonl")
+    if os.path.exists(mpath):
+        for line in open(mpath):
+            r = json.loads(line)
+            if r["type"] == "CELL" and r["outcome"] == "killed":
+                nw.discard(r["id"])
+    return nw
+
+
+def rand_inputs(problem, trial, torch):
+    """Randomized shapes (aligned AND misaligned) + distributions."""
+    g = torch.Generator().manual_seed(7000 + trial)
+    torch.manual_seed(7000 + trial)
+
+    def d(lo, hi):
+        return int(torch.randint(lo, hi, (1,), generator=g).item())
+
+    def vals(*shape):
+        fam = d(0, 4)
+        scale = float(10.0 ** d(-2, 3))
+        base = (torch.rand(*shape) if fam == 0 else
+                torch.randn(*shape) if fam == 1 else
+                (torch.rand(*shape) - 0.5) * 2 if fam == 2 else
+                torch.randn(*shape).abs())
+        return base * scale
+
+    if problem in ("relu", "leakyrelu", "gelu", "sigmoid"):
+        return [vals(d(1, 64), d(200, 5000))]
+    if problem in ("softmax", "logsoftmax"):
+        return [vals(d(1, 48), d(200, 8000))]
+    if problem == "matmul":
+        n = d(30, 700)
+        return [vals(n, n), vals(n, n)]
+    if problem in ("matmul_mk", "matmul_ta"):
+        m, k, n = d(30, 500), d(30, 700), d(30, 500)
+        A = vals(k, m) if problem == "matmul_ta" else vals(m, k)
+        return [A, vals(k, n)]
+    if problem in ("sum", "mean", "max"):
+        return [vals(d(2, 16), d(50, 800), d(50, 800))]
+    if problem == "rmsnorm":
+        return [vals(d(2, 8), d(3, 32), d(5, 40), d(5, 40))]
+    raise ValueError(problem)
+
+
+def worker(problem):
+    import torch
+    jpath = os.path.join(RESULTS, "adjudicate.jsonl")
+    done = set()
+    pending = None
+    if os.path.exists(jpath):
+        for line in open(jpath):
+            r = json.loads(line)
+            if r["type"] == "ASTART" and r["problem"] == problem:
+                pending = r["id"]
+            elif r["type"] == "ADJ" and r["problem"] == problem:
+                done.add(r["id"])
+                pending = None
+    journal = open(jpath, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    if pending is not None:
+        emit(type="ADJ", problem=problem, id=pending, verdict="oracle_blind",
+             detail="crashed during fuzz (crash witness found)")
+        done.add(pending)
+
+    ids = sorted(surviving_ids(problem) - done)
+    if not ids:
+        return
+    mutants = {m["id"]: m for m in
+               mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"]))}
+    ref_fn = ref_fn_for(problem)
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+
+    for mid in ids:
+        src = mutants[mid]["src"].replace("__global__ void",
+                                          'extern "C" __global__ void')
+        ptx = compile_ptx(src, "m.cu")
+        emit(type="ASTART", problem=problem, id=mid)
+        kern = NvrtcKernel(cuda_lib, ptx, kernel_name(problem))
+        witness = None
+        try:
+            for t in range(FUZZ_TRIALS):
+                cpu_in = rand_inputs(problem, t, torch)
+                gpu_in = [x.cuda() for x in cpu_in]
+                with torch.no_grad():
+                    ref = ref_fn(*gpu_in).cpu()
+                out = kern.launch(problem, gpu_in, torch)
+                r = compare(ref, out.cpu(), torch)
+                del gpu_in, out, ref
+                torch.cuda.empty_cache()
+                if r != "survived":
+                    witness = t
+                    break
+            kern.unload()
+        except RuntimeError as e:
+            emit(type="ADJ", problem=problem, id=mid, verdict="oracle_blind",
+                 detail=f"cuda crash in fuzz t{t}: {str(e)[:60]}")
+            journal.close()
+            sys.exit(3)
+        if witness is not None:
+            emit(type="ADJ", problem=problem, id=mid, verdict="witness_found",
+                 detail=f"fuzz trial {witness}")
+        else:
+            emit(type="ADJ", problem=problem, id=mid, verdict="fuzz_survivor")
+    journal.close()
+
+
+def sanitizer_phase():
+    """Run each fuzz_survivor once under compute-sanitizer on a small input."""
+    jpath = os.path.join(RESULTS, "adjudicate.jsonl")
+    surv = []
+    for line in open(jpath):
+        r = json.loads(line)
+        if r["type"] == "ADJ" and r["verdict"] == "fuzz_survivor":
+            surv.append((r["problem"], r["id"]))
+    results = []
+    for problem, mid in surv:
+        env = dict(os.environ, PYTORCH_NO_CUDA_MEMORY_CACHING="1")
+        p = subprocess.run(
+            ["/usr/local/cuda/bin/compute-sanitizer", "--tool", "memcheck",
+             sys.executable, os.path.join(HERE, "sanitizer_probe.py"),
+             problem, mid],
+            capture_output=True, text=True, timeout=300, env=env)
+        txt = p.stdout + p.stderr
+        clean = "ERROR SUMMARY: 0 errors" in txt
+        verdict = "likely_equivalent" if clean else "oracle_blind_memerror"
+        results.append(dict(type="SAN", problem=problem, id=mid, verdict=verdict))
+        print(f"[sanitizer] {problem}/{mid}: {verdict}", flush=True)
+    with open(jpath, "a") as f:
+        for r in results:
+            f.write(json.dumps(r) + "\n")
+
+
+def summary():
+    import collections
+    jpath = os.path.join(RESULTS, "adjudicate.jsonl")
+    adj, san = {}, {}
+    for line in open(jpath):
+        r = json.loads(line)
+        if r["type"] == "ADJ":
+            adj[(r["problem"], r["id"])] = r["verdict"]
+        elif r["type"] == "SAN":
+            san[(r["problem"], r["id"])] = r["verdict"]
+    c = collections.Counter()
+    for k, v in adj.items():
+        c[san.get(k, v)] += 1
+    print("adjudication:", dict(c), flush=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2 and sys.argv[1] == "--worker":
+        worker(sys.argv[2])
+    else:
+        for problem in K.PROBLEMS:
+            for attempt in range(40):
+                rc = subprocess.run(
+                    [sys.executable, __file__, "--worker", problem]).returncode
+                if rc == 0:
+                    break
+            print(f"[adjudicate] {problem}: fuzz done", flush=True)
+        sanitizer_phase()
+        summary()
+        print("[adjudicate] ALL DONE", flush=True)

pipeline/analyze_cover.py

@@ -0,0 +1,119 @@
+"""Greedy set-cover over the full kill matrix.
+
+Answers: per problem, what is the minimal number of targeted inputs needed to
+kill every killable mutant, and what does the kill-rate-vs-budget curve look
+like vs the original KernelBench inputs.
+
+Killable mutant = classified killed_by_T0 / high_value in screening, plus any
+no_witness mutant that the full matrix newly killed. Crash-killed mutants use
+their screening witness as their kill column.
+"""
+import json
+import os
+import collections
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+RESULTS = os.path.join(HERE, "results")
+
+import sys
+sys.path.insert(0, HERE)
+import kernels_def as K  # noqa: E402
+import problems_ext      # noqa: E402,F401
+from suite_filter import valid_suites  # noqa: E402
+
+
+def probe_witness_to_suite(problem, w):
+    """Map a probe crash witness to the closest targeted-suite column."""
+    w = w.split(":", 1)[-1]
+    names = [n for n, _, _ in valid_suites(problem) if n != "T0_original"]
+    if "misaligned" in w or "spike" in w:
+        for n in names:
+            if "misaligned" in n or "spike" in n:
+                return n
+    if "large" in w:
+        for n in names:
+            if "large" in n:
+                return n
+    return names[0]
+
+
+def load(problem):
+    """Return (kills: suite -> set(mutant), killable: set, t0_killed: set)."""
+    cls = {}
+    for line in open(os.path.join(RESULTS, f"screen_{problem}.jsonl")):
+        r = json.loads(line)
+        if r["type"] == "RESULT":
+            cls[r["id"]] = r
+    kills = collections.defaultdict(set)
+    t0_killed = set()
+    killable = set()
+    for mid, r in cls.items():
+        c = r["cls"]
+        if c == "killed_by_T0":
+            t0_killed.add(mid)
+            killable.add(mid)
+            if r.get("reason") in ("crash", "probe_crash", "cuda_poisoned"):
+                # crashes on T0-like inputs; no targeted data — T0 column only
+                kills["__T0__"].add(mid)
+        elif c == "high_value":
+            killable.add(mid)
+            w = r.get("witness")
+            if w and w.startswith("probe:"):
+                kills[probe_witness_to_suite(problem, w)].add(mid)
+    mpath = os.path.join(RESULTS, f"matrix_{problem}.jsonl")
+    if os.path.exists(mpath):
+        for line in open(mpath):
+            r = json.loads(line)
+            if r["type"] == "CELL" and r["outcome"] == "killed":
+                kills[r["suite"]].add(r["id"])
+                killable.add(r["id"])  # no_witness mutants newly killed
+    kills["__T0__"] |= t0_killed
+    return kills, killable, t0_killed
+
+
+def greedy_cover(kills, universe):
+    chosen, covered = [], set()
+    pool = {s: m & universe for s, m in kills.items() if s != "__T0__"}
+    while covered != universe:
+        best = max(pool, key=lambda s: len(pool[s] - covered), default=None)
+        if best is None or not (pool[best] - covered):
+            break
+        chosen.append((best, len(pool[best] - covered)))
+        covered |= pool[best]
+    return chosen, covered
+
+
+def main():
+    grand_universe = grand_covered = 0
+    rows = []
+    newly = 0
+    for problem in K.PROBLEMS:
+        kills, killable, t0_killed = load(problem)
+        targeted_killable = set()
+        for s, m in kills.items():
+            if s != "__T0__":
+                targeted_killable |= m
+        # universe for the cover: everything killable by targeted inputs
+        chosen, covered = greedy_cover(kills, targeted_killable & killable)
+        uncovered_total = killable - covered  # only killable via T0/crash
+        rows.append((problem, len(killable), len(t0_killed), chosen,
+                     len(covered), len(uncovered_total)))
+        grand_universe += len(killable)
+        grand_covered += len(covered)
+        print(f"{problem:12s} killable={len(killable):3d} (T0-killed {len(t0_killed):3d})  "
+              f"greedy cover: {[(s, k) for s, k in chosen]}  "
+              f"covered={len(covered)}  T0/crash-only={len(uncovered_total)}")
+    print()
+    print(f"TOTAL killable={grand_universe}, covered by targeted inputs={grand_covered}")
+    # budget curve: fraction of all killable mutants killed with k inputs/problem
+    print("\nkill-rate vs inputs-per-problem budget:")
+    for k in range(1, 6):
+        tot = 0
+        for problem, killable_n, t0_n, chosen, covered_n, unc in rows:
+            tot += sum(c for _, c in chosen[:k])
+        print(f"  k={k}: {tot}/{grand_universe} = {tot / grand_universe:.1%}")
+    print("  (原版 KernelBench 5 组输入对高价值池的杀伤率: 0%)")
+
+
+if __name__ == "__main__":
+    main()

pipeline/analyze_holdout.py

@@ -0,0 +1,92 @@
+"""Dev/test holdout for the set-cover suites (anti-overfitting check, §7).
+
+Within each problem, killable mutants are split 50/50 by a stable hash of the
+mutant id. Suites are selected greedily on the DEV half only; detection is then
+reported on the held-out TEST half. If the optimized-suite numbers were an
+artifact of selecting on the full pool, they collapse here.
+"""
+import glob, hashlib, json, os, collections
+
+RESULTS = "results"
+# consult the invalid-suite blocklist directly (no registry import needed)
+try:
+    _bl = json.load(open(f"{RESULTS}/invalid_suites.json"))
+    BLOCK = {(p, s) for p, ss in _bl.items() for s in ss} if isinstance(_bl, dict) \
+        else {(r["problem"], r["suite"]) for r in _bl}
+except Exception:
+    BLOCK = set()
+
+
+def load_problem(p):
+    t0, cover = set(), collections.defaultdict(set)
+    sf = f"{RESULTS}/screen_{p}.jsonl"
+    if not os.path.exists(sf):
+        return None
+    for line in open(sf):
+        r = json.loads(line)
+        if r["type"] == "RESULT" and r["cls"] == "killed_by_T0":
+            t0.add(r["id"])
+    ok = lambda s: (p, s) not in BLOCK
+    for jf, key in ((f"{RESULTS}/matrix_{p}.jsonl", "CELL"),
+                    (f"{RESULTS}/recheck_{p}.jsonl", "RCELL")):
+        if not os.path.exists(jf):
+            continue
+        for line in open(jf):
+            r = json.loads(line)
+            if r["type"] == key and r["outcome"] == "killed" and ok(r["suite"]):
+                cover[r["suite"]].add(r["id"])
+    return t0, cover
+
+
+def greedy(cover, universe, budget):
+    chosen, covered = [], set()
+    for _ in range(budget):
+        best = max(cover, key=lambda s: len((cover[s] & universe) - covered),
+                   default=None)
+        if best is None or not (cover[best] & universe) - covered:
+            break
+        chosen.append(best)
+        covered |= cover[best] & universe
+    return chosen
+
+
+def main():
+    budgets = [1, 2, 3, 5]
+    agg = {b: [0, 0] for b in budgets}   # killed, total on TEST
+    t0_agg = [0, 0]
+    n_prob = 0
+    for f in sorted(glob.glob(f"{RESULTS}/screen_*.jsonl")):
+        p = os.path.basename(f)[7:-6]
+        if p.startswith("L3"):
+            continue
+        loaded = load_problem(p)
+        if not loaded:
+            continue
+        t0, cover = loaded
+        cover = dict(cover)
+        cover["T0_original"] = set(t0)   # T0 selectable like any suite
+        killable = set().union(t0, *cover.values()) if cover else set(t0)
+        if len(killable) < 4:
+            continue
+        n_prob += 1
+        dev = {m for m in killable
+               if int(hashlib.md5(m.encode()).hexdigest(), 16) % 2 == 0}
+        test = killable - dev
+        if not test:
+            continue
+        t0_agg[0] += len(t0 & test); t0_agg[1] += len(test)
+        for b in budgets:
+            chosen = greedy(cover, dev, b)
+            killed = set().union(*(cover[s] for s in chosen)) if chosen else set()
+            agg[b][0] += len(killed & test); agg[b][1] += len(test)
+    out = dict(problems=n_prob,
+               official_T0_on_test=t0_agg[0] / t0_agg[1],
+               dev_selected_on_test={b: agg[b][0] / agg[b][1] for b in budgets})
+    json.dump(out, open(f"{RESULTS}/holdout.json", "w"), indent=1)
+    print(f"problems={n_prob}  test-half detection:")
+    print(f"  official 5 random inputs : {out['official_T0_on_test']:.1%}")
+    for b in budgets:
+        print(f"  dev-selected, budget {b}  : {out['dev_selected_on_test'][b]:.1%}")
+
+if __name__ == "__main__":
+    main()

pipeline/audit_matrix.py

@@ -0,0 +1,314 @@
+"""Audit competitor test recipes on our validated mutant pool.
+
+For every problem: evaluate the CORRECT kernel plus every killable mutant
+against the competitor suite columns (KBV_* four distributions from
+KernelBench-Verified; CI_fuzz seeded fuzzing from The Correctness Illusion).
+
+Reports, per column family:
+  - mutation score  = killable mutants killed / all killable
+  - false-kill rate = does the column reject the CORRECT kernel? (per problem)
+
+Journal: results/audit_<problem>.jsonl (same START/CELL resume protocol).
+Usage: python3 audit_matrix.py            # orchestrator
+       python3 audit_matrix.py --worker P
+"""
+import ctypes
+import json
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import kernels_def as K            # noqa: E402
+import problems_ext                # noqa: E402,F401
+import mutator                     # noqa: E402
+import competitor_suites as C      # noqa: E402
+from nvrtc_tce import externc, compile_ptx, device_source  # noqa: E402
+from screen_mutants import install_watchdog, pet_watchdog, NvrtcKernel, compare, kernel_name, ref_fn_for  # noqa: E402
+from full_matrix import screening_classes  # noqa: E402
+
+
+SHARD_ID = int(os.environ.get("SHARD_ID", "0"))
+SHARD_N = int(os.environ.get("SHARD_N", "1"))
+
+
+AUDIT_STEAL = os.environ.get("STEAL", "0") == "1"
+
+
+def my_problems():
+    """Hash slice, or (STEAL=1) any problem with no audit journal yet — used
+    when a worker disappears and its slice would otherwise go unaudited."""
+    import hashlib
+    if AUDIT_STEAL:
+        out = []
+        for p in K.PROBLEMS:
+            jp = os.path.join(RESULTS, f"audit_{p}.jsonl")
+            if os.path.exists(jp) and "ADONE" in open(jp).read():
+                continue
+            claim = os.path.join(RESULTS, f".aclaim_{p}")
+            try:
+                os.close(os.open(claim, os.O_CREAT | os.O_EXCL | os.O_WRONLY))
+                out.append(p)
+            except FileExistsError:
+                continue
+        return out
+    return [p for p in K.PROBLEMS
+            if int(hashlib.md5(p.encode()).hexdigest()[:8], 16) % SHARD_N == SHARD_ID]
+
+
+def killable_ids(problem):
+    cls = screening_classes(problem)
+    ids = {i for i, r in cls.items()
+           if r["cls"] in ("killed_by_T0", "high_value")
+           and r.get("reason") not in ("crash", "probe_crash", "cuda_poisoned")}
+    mpath = os.path.join(RESULTS, f"matrix_{problem}.jsonl")
+    if os.path.exists(mpath):
+        for line in open(mpath):
+            r = json.loads(line)
+            if r["type"] == "CELL" and r["outcome"] == "killed":
+                ids.add(r["id"])
+    return ids
+
+
+def worker(problem):
+    install_watchdog()
+    import torch
+    jpath = os.path.join(RESULTS, f"audit_{problem}.jsonl")
+    done, pending = set(), None
+    if os.path.exists(jpath):
+        for line in open(jpath):
+            r = json.loads(line)
+            if r["type"] == "START":
+                pending = (r["id"], r["suite"], r.get("trial", 0))
+            elif r["type"] == "CELL":
+                done.add((r["id"], r["suite"], r.get("trial", 0)))
+                pending = None
+    journal = open(jpath, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    if pending is not None:
+        emit(type="CELL", id=pending[0], suite=pending[1], trial=pending[2],
+             outcome="killed", reason="crash")
+        done.add(pending)
+
+    ids = killable_ids(problem)
+    _ms = list(mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"])))
+    _cap = int(os.environ.get("MUTANT_CAP", "0"))
+    if _cap:
+        _ms = mutator.stratified_sample(_ms, _cap)   # same sample as screening
+    mutants = {m["id"]: m for m in _ms}
+    variants = [("correct", device_source(K.PROBLEMS[problem]["cuda"]))]
+    variants += [(mid, mutants[mid]["src"]) for mid in sorted(ids) if mid in mutants]
+
+    columns = C.competitor_columns(problem)
+    ref_fn = ref_fn_for(problem)
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+
+    cache = {}
+
+    # Columns are derived ON THE GPU from a single uploaded base: KBV's D2/D3/D4
+    # are scalar multiples, and CI's fuzz values can be drawn directly on device.
+    # Building each column as a fresh multi-GB CPU tensor dominated the runtime.
+    gpu_base = {}
+
+    def _base_gpu():
+        if not gpu_base:
+            import competitor_suites as _C
+            gpu_base["t"] = [t.cuda() for t in _C._base_inputs(problem)]
+        return gpu_base["t"]
+
+    KBV_FACTOR = {"KBV_D2_large": 3.0, "KBV_D3_small": 0.01,
+                  "KBV_D4_negated": -1.0}
+
+    def get_pair(sname, builder, trial):
+        key = (sname, trial)
+        if key not in cache:
+            cache.clear()
+            torch.cuda.empty_cache()
+            base = _base_gpu()
+            if sname in KBV_FACTOR:
+                f = KBV_FACTOR[sname]
+                gpu_in = [t * f if t.dtype.is_floating_point else t
+                          for t in base]
+            elif sname == "CI_fuzz":
+                g = torch.Generator(device="cuda").manual_seed(90000 + trial)
+                fam = int(torch.randint(0, 4, (1,), generator=g,
+                                        device="cuda").item())
+                scale = float(10.0 ** int(torch.randint(-3, 4, (1,), generator=g,
+                                                        device="cuda").item()))
+                gpu_in = []
+                for t in base:
+                    if not t.dtype.is_floating_point:
+                        gpu_in.append(t)
+                        continue
+                    if fam == 0:
+                        v = torch.rand(t.shape, generator=g, device="cuda") * scale
+                    elif fam == 1:
+                        v = torch.randn(t.shape, generator=g, device="cuda") * scale
+                    elif fam == 2:
+                        v = (torch.rand(t.shape, generator=g, device="cuda")
+                             - 0.5) * 2 * scale
+                    else:
+                        v = torch.randn(t.shape, generator=g,
+                                        device="cuda").abs() * scale
+                    gpu_in.append(v)
+            else:
+                gpu_in = [t.cuda() for t in builder(trial)]
+            with torch.no_grad():
+                cache[key] = (gpu_in, ref_fn(*gpu_in))   # ref stays on GPU
+        return cache[key]
+
+    ptx_cache = {}
+    # column-major so at most one input set lives on the GPU
+    for sname, n_trials, builder in columns:
+        for trial in range(n_trials):
+            for vid, src in variants:
+                if (vid, sname, trial) in done:
+                    continue
+                if vid not in ptx_cache:
+                    s = externc(src)
+                    ptx_cache[vid] = compile_ptx(s, "m.cu")
+                emit(type="START", id=vid, suite=sname, trial=trial)
+                kern = NvrtcKernel(cuda_lib, ptx_cache[vid], kernel_name(problem))
+                try:
+                    gpu_in, ref = get_pair(sname, builder, trial)
+                    pet_watchdog()
+                    out = kern.launch(problem, gpu_in, torch)
+                    # Compare ON THE GPU: pulling each multi-GB output back
+                    # over PCIe dominated runtime (~2s x mutants x columns).
+                    r = compare(ref, out, torch)
+                    # KBV's own oracle is atol=rtol=1e-3; record it too so we
+                    # can separate the contribution of their INPUTS from the
+                    # contribution of their tighter TOLERANCE.
+                    strict = ("survived" if out.shape == ref.shape
+                              and torch.allclose(ref, out, atol=1e-3, rtol=1e-3)
+                              else "value_mismatch")
+                    del out
+                    torch.cuda.empty_cache()
+                    kern.unload()
+                except RuntimeError as e:
+                    emit(type="CELL", id=vid, suite=sname, trial=trial,
+                         outcome="killed", reason="crash", detail=str(e)[:80])
+                    journal.close()
+                    sys.exit(3)
+                emit(type="CELL", id=vid, suite=sname, trial=trial,
+                     outcome="survived" if r == "survived" else "killed",
+                     strict="survived" if strict == "survived" else "killed")
+    emit(type="ADONE", problem=problem)
+
+
+def aggregate():
+    import collections
+    fam_of = lambda s: "KBV(4-dist)" if s.startswith("KBV") else "CI_fuzz"
+    kills = collections.defaultdict(set)      # family -> set (problem, mutant)
+    false_kill = collections.defaultdict(set)  # family -> set problem
+    universe = set()
+
+    # crash-classified mutants: scored analytically (competitor recipes never
+    # vary shape, so shape-triggered crashers are unreachable for them; value/
+    # any-input crashers are reachable by every family).
+    for problem in K.PROBLEMS:
+        cls = screening_classes(problem)
+        for mid, r in cls.items():
+            if r.get("reason") not in ("crash", "probe_crash", "cuda_poisoned"):
+                continue
+            universe.add((problem, mid))
+            w = str(r.get("witness") or "")
+            crash_on_aligned = r["cls"] == "killed_by_T0"
+            shape_triggered = ("misaligned" in w) or ("spike" in w and "misaligned" in w)
+            if crash_on_aligned:
+                kills["KBV(4-dist)"].add((problem, mid))
+                kills["CI_fuzz"].add((problem, mid))
+            elif not shape_triggered:  # value-triggered (e.g. large-value probe)
+                kills["KBV(4-dist)"].add((problem, mid))
+                kills["CI_fuzz"].add((problem, mid))
+            # shape-triggered crashers: no credit — their inputs are unreachable
+
+    for problem in K.PROBLEMS:
+        jpath = os.path.join(RESULTS, f"audit_{problem}.jsonl")
+        if not os.path.exists(jpath):
+            continue
+        for mid in killable_ids(problem):
+            universe.add((problem, mid))
+        for line in open(jpath):
+            r = json.loads(line)
+            if r["type"] != "CELL" or r["outcome"] != "killed":
+                continue
+            fam = fam_of(r["suite"])
+            if r["id"] == "correct":
+                false_kill[fam].add((problem, r["suite"]))
+            else:
+                kills[fam].add((problem, r["id"]))
+    # KBV's D1 column is byte-identical to the benchmark's own T0 input, so
+    # every mutant screening recorded as killed_by_T0 is also killed by KBV.
+    for problem in K.PROBLEMS:  # D1 credit
+        for mid, r in screening_classes(problem).items():
+            if r["cls"] == "killed_by_T0" and (problem, mid) in universe:
+                kills["KBV(4-dist)"].add((problem, mid))
+    print(f"universe (killable mutants incl. crash-class): {len(universe)}")
+    for fam in ("KBV(4-dist)", "CI_fuzz"):
+        k = len(kills[fam] & universe)
+        print(f"{fam:12s} mutation score {k}/{len(universe)} = {k/len(universe):.1%}   "
+              f"false-kills-correct: {sorted(false_kill[fam]) or 'none'}")
+    print("(ours, 2 inputs/problem: 98.2%; original KernelBench 5 inputs: 81.2%)")
+
+
+def worker_batch(problems):
+    """Process several problems in ONE process: importing the 188-substrate
+    registry costs ~85s, and paying that per problem dominated the runtime.
+    Crash isolation is preserved by the orchestrator, which restarts the batch
+    and skips whatever the journals show as finished."""
+    install_watchdog()
+    for p in problems:
+        try:
+            worker(p)
+        except SystemExit:
+            raise
+        except Exception as e:
+            print(f"[audit] {p}: error {str(e)[:80]}", flush=True)
+        print(f"[audit] {p}: done", flush=True)
+
+
+def orchestrate():
+    """Registry stays in THIS process; each problem runs in a forked child, so
+    a poisoned CUDA context costs one fork (microseconds) instead of an 85s
+    registry re-import."""
+    from forkpool import isolated_loop
+    isolated_loop(my_problems(), worker, label="audit", timeout=2400)
+    aggregate()
+    print("[audit] ALL DONE", flush=True)
+
+
+def _orchestrate_old():
+    for problem in my_problems():
+        for attempt in range(60):
+            try:
+                rc = subprocess.run([sys.executable, __file__, "--worker", problem],
+                                    timeout=2700).returncode
+            except subprocess.TimeoutExpired:
+                print(f"[{'matrix' if 'full' in __file__ else 'audit'}] {problem}: TIMEOUT, skipping", flush=True)
+                rc = 0
+            if rc == 0:
+                break
+        print(f"[audit] {problem}: done", flush=True)
+    aggregate()
+    print("[audit] ALL DONE", flush=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2 and sys.argv[1] == "--batch":
+        worker_batch(sys.argv[2:])
+    elif len(sys.argv) > 2 and sys.argv[1] == "--worker":
+        worker(sys.argv[2])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--aggregate":
+        aggregate()
+    else:
+        orchestrate()

pipeline/candidates_loader.py

@@ -0,0 +1,49 @@
+"""Load substrate candidate files into the registry.
+
+Pending candidates live in substrates/candidate_*.py; gate-approved ones are
+moved to substrates/accepted/. Accepted substrates are loaded automatically by
+problems_ext; pending ones only when explicitly requested (validation gate).
+"""
+import ctypes
+import glob
+import importlib.util
+import os
+
+import torch
+
+import kernels_def as K
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def _load_file(path):
+    name = os.path.splitext(os.path.basename(path))[0]
+    spec = importlib.util.spec_from_file_location(f"substrate_{name}", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    before = set(K.PROBLEMS)
+    mod.register(K, torch, ctypes)
+    return sorted(set(K.PROBLEMS) - before)
+
+
+def load_accepted():
+    """One broken candidate must not silently drop every other one: load each
+    file independently, report failures loudly, keep going."""
+    added = []
+    for path in sorted(glob.glob(os.path.join(HERE, "substrates", "accepted",
+                                              "candidate_*.py"))):
+        try:
+            added += _load_file(path)
+        except Exception as e:
+            import sys
+            print(f"[candidates] FAILED to load {os.path.basename(path)}: "
+                  f"{type(e).__name__}: {e}", file=sys.stderr, flush=True)
+    return added
+
+
+def load_pending():
+    added = []
+    for path in sorted(glob.glob(os.path.join(HERE, "substrates",
+                                              "candidate_*.py"))):
+        added += _load_file(path)
+    return added

pipeline/competitor_suites.py

@@ -0,0 +1,93 @@
+"""Competitor test-suite replications, audited on our mutant pool.
+
+A) KernelBench-Verified (arXiv:2607.16241, facebookresearch/kernel_bench_verified)
+   Verified against their released source (scripts/generate_hidden_inputs.py):
+   four DETERMINISTIC scalings of the problem's own get_inputs() tensors —
+
+       D1  x * 1.0    original (as-is)
+       D2  x * 3.0    large magnitude   (overflow / precision hacks)
+       D3  x * 0.01   near-zero         (underflow / skip-small hacks)
+       D4  x * -1.0   negated           (ReLU / positivity-assumption hacks)
+
+   Shapes are never varied; integer/bool tensors are never scaled; configs
+   whose reference output is NaN/Inf are dropped at generation time.
+   Their oracle uses atol=rtol=1e-3 for fp32 (src/eval.py), stricter than
+   KernelBench's 1e-2 — we audit under BOTH so the comparison separates the
+   input recipe from the tolerance change.
+
+B) The Correctness Illusion (arXiv:2606.20128) — op-schema-aware seeded
+   fuzzing over values (no released code; parameters follow the paper text).
+
+NOTE: an earlier version of this file guessed `randn * 1e4` for D2. That was
+our error, not theirs — it exceeded the legitimate-variance ceiling and
+false-killed correct kernels. Their actual x3.0 cannot do that.
+"""
+import torch as _torch
+
+# D1 (x1.0) is byte-identical to the benchmark's own T0 input, whose verdict
+# screening already recorded; re-running it would only burn CPU regenerating
+# the same tensors. It is credited analytically at aggregation time.
+KBV_SCALINGS = [("D2_large", 3.0), ("D3_small", 0.01), ("D4_negated", -1.0)]
+
+
+def _t0_builder(problem):
+    import kernels_def as K
+    for n, _, b in K.PROBLEMS[problem]["suites"]():
+        if n == "T0_original":
+            return b
+    return K.PROBLEMS[problem]["suites"]()[0][2]
+
+
+_BASE_CACHE = {}
+
+
+def _base_inputs(problem):
+    """Generate the problem's T0 tensors once and reuse across all columns."""
+    if problem not in _BASE_CACHE:
+        _BASE_CACHE.clear()          # one problem in memory at a time
+        _torch.manual_seed(1000)
+        _BASE_CACHE[problem] = _t0_builder(problem)(0)
+    return _BASE_CACHE[problem]
+
+
+def kbv_suites(problem):
+    """Their exact protocol: scale the problem's own inputs by a constant."""
+
+    def make(factor):
+        def build(trial):
+            return [t * factor if t.dtype.is_floating_point else t
+                    for t in _base_inputs(problem)]
+        return build
+
+    return [(f"KBV_{name}", 1, make(f)) for name, f in KBV_SCALINGS]
+
+
+def ci_fuzz_suites(problem, n_trials=3):
+    """Seeded value-fuzzing at the original shapes (paper description)."""
+
+    def build(trial):
+        _torch.manual_seed(90000 + trial)
+        fam = int(_torch.randint(0, 4, (1,)).item())
+        scale = float(10.0 ** int(_torch.randint(-3, 4, (1,)).item()))
+        out = []
+        for t in _base_inputs(problem):
+            if not t.dtype.is_floating_point:
+                out.append(t)
+                continue
+            s = t.shape
+            if fam == 0:
+                v = _torch.rand(*s) * scale
+            elif fam == 1:
+                v = _torch.randn(*s) * scale
+            elif fam == 2:
+                v = (_torch.rand(*s) - 0.5) * 2 * scale
+            else:
+                v = _torch.randn(*s).abs() * scale
+            out.append(v)
+        return out
+
+    return [("CI_fuzz", n_trials, build)]
+
+
+def competitor_columns(problem):
+    return kbv_suites(problem) + ci_fuzz_suites(problem)

pipeline/coverage_report.py

@@ -0,0 +1,85 @@
+"""Per-task survivor coverage: does every task carry enough mutants that the
+benchmark's ORIGINAL inputs fail to kill?
+
+A task with no survivors contributes nothing when scoring a test-input
+generator (nothing left to discriminate on), so the artifact targets a floor
+of MIN_SURVIVORS per task. Tasks below the floor are reported with their
+kernel structure so new subtle-fault rules can be aimed at them.
+
+Usage: python3 coverage_report.py [min_survivors]
+"""
+import collections
+import glob
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+MIN_SURVIVORS = int(sys.argv[1]) if len(sys.argv) > 1 else 3
+
+
+def structure_hint(problem):
+    """Coarse structural class, to guide which rule families could apply."""
+    try:
+        import kernels_def as K
+        import problems_ext  # noqa: F401
+        import candidates_loader
+        candidates_loader.load_accepted()
+        from nvrtc_tce import device_source
+        src = device_source(K.PROBLEMS[problem]["cuda"])
+    except Exception:
+        return "?"
+    tags = []
+    if "__shared__" in src:
+        tags.append("shared-mem")
+    if "__syncthreads" in src:
+        tags.append("barrier")
+    if src.count("for (") >= 2:
+        tags.append("nested-loop")
+    elif "for (" in src:
+        tags.append("loop")
+    else:
+        tags.append("elementwise")
+    if "CUDART_INF" in src:
+        tags.append("sentinel-reduce")
+    if "long long" in src and "out[" in src:
+        tags.append("index-out")
+    return ",".join(tags)
+
+
+def main():
+    rows = []
+    for f in sorted(glob.glob(os.path.join(RESULTS, "screen_*.jsonl"))):
+        p = os.path.basename(f)[7:-6]
+        c = collections.Counter()
+        for line in open(f):
+            r = json.loads(line)
+            if r["type"] == "RESULT":
+                c[r["cls"]] += 1
+        total = c["high_value"] + c["killed_by_T0"] + c["no_witness"]
+        if not total:
+            continue
+        surv = c["high_value"] + c["no_witness"]
+        rows.append((surv, c["high_value"], total, p))
+
+    rows.sort()
+    thin = [r for r in rows if r[0] < MIN_SURVIVORS]
+    print(f"tasks screened: {len(rows)}   floor: {MIN_SURVIVORS} survivors/task")
+    print(f"below floor: {len(thin)}")
+    if thin:
+        print(f"\n{'task':30s} {'surv':>4s} {'hv':>3s} {'total':>5s}  structure")
+        for surv, hv, total, p in thin:
+            print(f"{p:30s} {surv:4d} {hv:3d} {total:5d}  {structure_hint(p)}")
+    agg_s = sum(r[0] for r in rows)
+    agg_t = sum(r[2] for r in rows)
+    print(f"\npool: {agg_t} mutants, {agg_s} survive original inputs "
+          f"({agg_s/agg_t:.1%})")
+    print(f"median survivors/task: "
+          f"{sorted(r[0] for r in rows)[len(rows)//2]}")
+
+
+if __name__ == "__main__":
+    main()

pipeline/driver.py

@@ -0,0 +1,113 @@
+"""Orchestrates the mutation experiment on the GPU worker.
+
+1. Pre-compiles all kernel variants in parallel (nvcc, cached by torch ext dir).
+2. Runs eval_kernel.py per problem in a subprocess, respawning on crash
+   (crashing mutants are recorded as killed and skipped on resume).
+3. Aggregates journals into results/summary.json and results/summary.md.
+"""
+import concurrent.futures as cf
+import json
+import os
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+RESULTS = os.path.join(HERE, "results")
+os.makedirs(RESULTS, exist_ok=True)
+
+sys.path.insert(0, HERE)
+import kernels_def as K  # noqa: E402
+
+
+def precompile():
+    def build(job):
+        problem, variant_id, src = job
+        t0 = time.time()
+        try:
+            import eval_kernel
+            eval_kernel.build_ext(problem, variant_id, src)
+            return (problem, variant_id, "ok", time.time() - t0)
+        except Exception as e:
+            return (problem, variant_id, f"compile_error: {str(e)[:200]}", time.time() - t0)
+
+    jobs = [(prob, vid, src) for prob in K.PROBLEMS for vid, src in K.all_variants(prob)]
+    print(f"[driver] compiling {len(jobs)} variants ...", flush=True)
+    with cf.ThreadPoolExecutor(max_workers=5) as ex:
+        for prob, vid, status, dt in ex.map(build, jobs):
+            print(f"[compile] {prob}/{vid}: {status} ({dt:.0f}s)", flush=True)
+
+
+def run_problem(problem):
+    journal = os.path.join(RESULTS, f"{problem}.jsonl")
+    for attempt in range(40):
+        proc = subprocess.run(
+            [sys.executable, os.path.join(HERE, "eval_kernel.py"), problem, journal],
+            timeout=7200)
+        if proc.returncode == 0:
+            print(f"[driver] {problem}: done", flush=True)
+            return
+        print(f"[driver] {problem}: process exited rc={proc.returncode}, respawning "
+              f"(attempt {attempt + 1})", flush=True)
+    print(f"[driver] {problem}: too many respawns, giving up", flush=True)
+
+
+def aggregate():
+    summary = {}
+    for problem in K.PROBLEMS:
+        journal = os.path.join(RESULTS, f"{problem}.jsonl")
+        if not os.path.exists(journal):
+            continue
+        res = {}
+        for line in open(journal):
+            rec = json.loads(line)
+            if rec["type"] == "RESULT":
+                res[(rec["variant"], rec["suite"])] = rec
+        summary[problem] = {f"{v}|{s}": r for (v, s), r in res.items()}
+    with open(os.path.join(RESULTS, "summary.json"), "w") as f:
+        json.dump(summary, f, indent=1)
+
+    lines = ["# Mutation experiment results", ""]
+    for problem in K.PROBLEMS:
+        if problem not in summary:
+            continue
+        p = K.PROBLEMS[problem]
+        suites = [s for s, _, _ in p["suites"]()]
+        res = summary[problem]
+        lines.append(f"## {problem}  ({os.path.basename(p['kb_file'])})")
+        lines.append("")
+        lines.append("| mutant | category | description | " + " | ".join(suites) + " |")
+        lines.append("|---" * (3 + len(suites)) + "|")
+        t0_survivors = []
+        for vid_info in [dict(id="correct", category="-", desc="correct implementation")] + p["mutants"]:
+            vid = vid_info["id"]
+            cells = []
+            for s in suites:
+                r = res.get(f"{vid}|{s}")
+                if r is None:
+                    cells.append("?")
+                elif r["status"] == "survived":
+                    cells.append("SURVIVED")
+                elif r["status"] == "skipped_after_crash":
+                    cells.append("(skipped)")
+                else:
+                    cells.append(f"killed:{r.get('reason', '?')}")
+            if vid != "correct" and res.get(f"{vid}|T0_original", {}).get("status") == "survived":
+                t0_survivors.append(vid)
+            lines.append(f"| {vid} | {vid_info['category']} | {vid_info['desc']} | " + " | ".join(cells) + " |")
+        n_mut = len(p["mutants"])
+        lines.append("")
+        lines.append(f"**T0 (original KernelBench inputs, 5 trials) survivors: "
+                     f"{len(t0_survivors)}/{n_mut}: {', '.join(t0_survivors) or 'none'}**")
+        lines.append("")
+    with open(os.path.join(RESULTS, "summary.md"), "w") as f:
+        f.write("\n".join(lines))
+    print("[driver] summary written", flush=True)
+
+
+if __name__ == "__main__":
+    precompile()
+    for problem in K.PROBLEMS:
+        run_problem(problem)
+    aggregate()
+    print("[driver] ALL DONE", flush=True)

pipeline/eval_kernel.py

@@ -0,0 +1,177 @@
+"""Evaluate all variants (correct + mutants) of one problem against all test suites.
+
+Kill criterion follows KernelBench eval: runtime error, shape mismatch, or
+!torch.allclose(ref, out, atol=1e-2, rtol=1e-2)  => killed.
+
+Writes JSONL journal (one line per variant x suite). Resumable: already-journaled
+(variant, suite) pairs are skipped; a START line without a matching RESULT line
+(previous process died there) is recorded as killed:process_crash, and all
+remaining suites of that variant are skipped.
+
+Usage: python3 eval_kernel.py <problem> <journal_path>
+"""
+import importlib.util
+import json
+import os
+import sys
+
+import torch
+
+import kernels_def as K
+
+ATOL = RTOL = 1e-2
+
+
+def load_ref_model(problem):
+    p = K.PROBLEMS[problem]
+    spec = importlib.util.spec_from_file_location(f"kb_{problem}", p["kb_file"])
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    init = mod.get_init_inputs()
+    return mod.Model(*init), init
+
+
+def build_ext(problem, variant_id, cuda_src):
+    from torch.utils.cpp_extension import load_inline
+    p = K.PROBLEMS[problem]
+    return load_inline(
+        name=f"{problem}_{variant_id}",
+        cpp_sources=p["cpp"],
+        cuda_sources=cuda_src,
+        functions=[p["func"]],
+        verbose=False,
+    )
+
+
+def compare(ref, out):
+    if not isinstance(out, torch.Tensor):
+        return dict(status="killed", reason="not_a_tensor")
+    if out.shape != ref.shape:
+        return dict(status="killed", reason="shape_mismatch",
+                    detail=f"{tuple(out.shape)} vs {tuple(ref.shape)}")
+    ok = torch.allclose(ref, out, atol=ATOL, rtol=RTOL)
+    if ok:
+        return dict(status="survived")
+    diff = (ref - out).abs()
+    finite = torch.isfinite(out).all().item()
+    return dict(status="killed", reason="value_mismatch",
+                max_diff=float(diff.nan_to_num(nan=float("inf")).max()),
+                out_finite=bool(finite))
+
+
+def main():
+    problem, journal_path = sys.argv[1], sys.argv[2]
+    p = K.PROBLEMS[problem]
+
+    done = {}        # (variant, suite) -> True
+    crashed = set()  # variants that crashed a previous process
+    pending_start = None
+    if os.path.exists(journal_path):
+        for line in open(journal_path):
+            rec = json.loads(line)
+            if rec["type"] == "START":
+                pending_start = (rec["variant"], rec["suite"])
+            elif rec["type"] == "RESULT":
+                done[(rec["variant"], rec["suite"])] = True
+                pending_start = None
+
+    journal = open(journal_path, "a")
+
+    def emit(rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    # a START without RESULT means the previous process died on that (variant, suite)
+    if pending_start is not None:
+        v, s = pending_start
+        emit(dict(type="RESULT", variant=v, suite=s, trial=-1,
+                  status="killed", reason="process_crash"))
+        done[(v, s)] = True
+        crashed.add(v)
+
+    ref_model, _ = load_ref_model(problem)
+    ref_model = ref_model.cuda().eval()
+    suites = p["suites"]()
+
+    # cache reference outputs on CPU: (suite, trial) -> ref_out
+    ref_cache = {}
+
+    def ref_out_for(suite_name, builder, trial):
+        key = (suite_name, trial)
+        if key not in ref_cache:
+            inputs = builder(trial)
+            with torch.no_grad():
+                gpu_in = [t.cuda() for t in inputs]
+                ref_cache[key] = ref_model(*gpu_in).cpu()
+                del gpu_in
+                torch.cuda.empty_cache()
+        return ref_cache[key]
+
+    for variant_id, cuda_src in K.all_variants(problem):
+        if variant_id in crashed:
+            for suite_name, _, _ in suites:
+                if (variant_id, suite_name) not in done:
+                    emit(dict(type="RESULT", variant=variant_id, suite=suite_name, trial=-1,
+                              status="skipped_after_crash"))
+            continue
+
+        try:
+            ext = build_ext(problem, variant_id, cuda_src)
+        except Exception as e:
+            for suite_name, _, _ in suites:
+                if (variant_id, suite_name) not in done:
+                    emit(dict(type="RESULT", variant=variant_id, suite=suite_name, trial=-1,
+                              status="killed", reason="compile_error", detail=str(e)[:300]))
+            continue
+
+        wrapper_cls = p["wrapper"]
+        if problem == "sum":
+            model_new = wrapper_cls(ext, 1)
+        else:
+            model_new = wrapper_cls(ext)
+        model_new = model_new.cuda().eval()
+
+        variant_dead = False
+        for suite_name, n_trials, builder in suites:
+            if (variant_id, suite_name) in done:
+                continue
+            if variant_dead:
+                emit(dict(type="RESULT", variant=variant_id, suite=suite_name, trial=-1,
+                          status="skipped_after_crash"))
+                continue
+            emit(dict(type="START", variant=variant_id, suite=suite_name))
+            result = dict(status="survived")
+            for trial in range(n_trials):
+                ref_out = ref_out_for(suite_name, builder, trial)
+                inputs = builder(trial)
+                try:
+                    with torch.no_grad():
+                        gpu_in = [t.cuda() for t in inputs]
+                        out = model_new(*gpu_in)
+                        torch.cuda.synchronize()
+                        r = compare(ref_out.cuda(), out)
+                        del gpu_in, out
+                        torch.cuda.empty_cache()
+                except RuntimeError as e:
+                    r = dict(status="killed", reason="runtime_error", detail=str(e)[:300])
+                    if "CUDA" in str(e) or "cuda" in str(e):
+                        # context may be poisoned; record and let the driver restart us
+                        r["trial"] = trial
+                        emit(dict(type="RESULT", variant=variant_id, suite=suite_name, **r))
+                        journal.close()
+                        sys.exit(3)
+                if r["status"] == "killed":
+                    r["trial"] = trial
+                    result = r
+                    break
+            if "trial" not in result:
+                result["trial"] = n_trials
+            emit(dict(type="RESULT", variant=variant_id, suite=suite_name, **result))
+
+    emit(dict(type="DONE", problem=problem))
+    journal.close()
+
+
+if __name__ == "__main__":
+    main()

pipeline/find_substrate.py

@@ -0,0 +1,8 @@
+import glob, sys
+p = sys.argv[1]
+cands = glob.glob('substrates/accepted/candidate_*.py') + ['problems_ext.py', 'problems_batch2.py']
+for f in cands:
+    try: s = open(f).read()
+    except OSError: continue
+    if f'"{p}"' in s or f"'{p}'" in s:
+        print(f); break

pipeline/forkpool.py

@@ -0,0 +1,73 @@
+"""Fork-based crash isolation with a preloaded registry.
+
+Problem: importing the 188-substrate registry costs ~85s, and a mutant that
+triggers an illegal memory access poisons the CUDA context so unrecoverably
+that the process must exit. Paying the import per problem (for isolation) wastes
+most of the runtime.
+
+Solution: the PARENT loads the registry once and never touches CUDA. For each
+unit of work it fork()s a child; the child inherits the registry through
+copy-on-write (no reload, no serialization), initializes CUDA itself, does the
+work, and exits. If the child dies — poisoned context, watchdog kill, OOM —
+the parent is unaffected and forks the next one.
+
+Constraint: the parent must NOT initialize CUDA (a CUDA context cannot be
+inherited across fork), so keep all torch.cuda calls inside run_fn.
+"""
+import os
+import sys
+
+
+def run_isolated(run_fn, *args, timeout=None):
+    """Run run_fn(*args) in a forked child. Returns the child's exit code.
+
+    0 = completed; 3 = the runner's "context poisoned, respawn me" signal;
+    other = crash/kill. The parent never shares CUDA state with the child.
+    """
+    pid = os.fork()
+    if pid == 0:                      # child
+        code = 0
+        try:
+            run_fn(*args)
+        except SystemExit as e:
+            code = e.code if isinstance(e.code, int) else 1
+        except Exception:
+            import traceback
+            traceback.print_exc()
+            code = 1
+        finally:
+            sys.stdout.flush()
+            sys.stderr.flush()
+            os._exit(code)            # never run parent's atexit/finalizers
+    if timeout is None:
+        _, status = os.waitpid(pid, 0)
+        return os.waitstatus_to_exitcode(status)
+    # bounded wait: kill the child if it exceeds the wall-clock budget
+    import time
+    deadline = time.monotonic() + timeout
+    while True:
+        done, status = os.waitpid(pid, os.WNOHANG)
+        if done:
+            return os.waitstatus_to_exitcode(status)
+        if time.monotonic() > deadline:
+            os.kill(pid, 9)
+            os.waitpid(pid, 0)
+            return 124
+        time.sleep(0.5)
+
+
+def isolated_loop(problems, run_fn, label="run", timeout=2400, retries=6):
+    """Process problems one at a time, each in its own forked child.
+
+    The registry stays resident in the parent, so a crash costs only the work
+    in flight — never a re-import.
+    """
+    for p in problems:
+        for attempt in range(retries):
+            rc = run_isolated(run_fn, p, timeout=timeout)
+            if rc == 0:
+                break
+            if rc == 124:
+                print(f"[{label}] {p}: TIMEOUT (child killed)", flush=True)
+                break
+        print(f"[{label}] {p}: done", flush=True)

pipeline/full_matrix.py

@@ -0,0 +1,180 @@
+"""Full kill matrix: every non-trivial mutant x every targeted suite, no early exit.
+
+Uses the screening journals to scope work:
+  - mutants classified killed_by_T0 (value kill), high_value, no_witness are
+    evaluated against EVERY targeted suite (T0 outcome is already known);
+  - mutants that killed via crash (reason=crash / probe_crash) are excluded
+    from re-execution — their journal witness stands in for their kill vector.
+
+Output: results/matrix_<problem>.jsonl lines
+  {"type":"CELL","id":...,"suite":...,"outcome":"killed"/"survived"[,"reason"]}
+Crash-safe with the same START/respawn pattern as screening.
+
+Usage: python3 full_matrix.py            # orchestrator
+       python3 full_matrix.py --worker P # one problem
+"""
+import ctypes
+import json
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import kernels_def as K            # noqa: E402
+import problems_ext                # noqa: E402,F401
+import mutator                     # noqa: E402
+from suite_filter import valid_suites  # noqa: E402
+from nvrtc_tce import externc, compile_ptx, device_source, normalized_hash  # noqa: E402
+from screen_mutants import (install_watchdog, pet_watchdog, NvrtcKernel,  # noqa: E402
+                            compare, kernel_name, launch_spec, ref_fn_for)
+
+
+SHARD_ID = int(os.environ.get("SHARD_ID", "0"))
+SHARD_N = int(os.environ.get("SHARD_N", "1"))
+
+
+STEAL = os.environ.get("STEAL", "0") == "1"
+
+
+def my_problems():
+    """Own hash slice, or (STEAL=1) any problem without an MDONE marker, so an
+    idle GPU helps finish the tail. Claim files keep two stealers off the same
+    problem; duplicate work would still be safe (journals dedupe by cell)."""
+    import hashlib
+    if STEAL:
+        out = []
+        for p in K.PROBLEMS:
+            jp = os.path.join(RESULTS, f"matrix_{p}.jsonl")
+            if os.path.exists(jp) and "MDONE" in open(jp).read():
+                continue
+            claim = os.path.join(RESULTS, f".mclaim_{p}")
+            try:
+                fd = os.open(claim, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                os.close(fd)
+                out.append(p)
+            except FileExistsError:
+                continue
+        return out
+    return [p for p in K.PROBLEMS
+            if int(hashlib.md5(p.encode()).hexdigest()[:8], 16) % SHARD_N == SHARD_ID]
+
+
+def screening_classes(problem):
+    path = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+    res = {}
+    if not os.path.exists(path):
+        return res  # problem not screened yet (e.g. newly added substrate)
+    for line in open(path):
+        r = json.loads(line)
+        if r["type"] == "RESULT":
+            res[r["id"]] = r
+    return res
+
+
+def worker(problem):
+    install_watchdog()
+    import torch
+    cls = screening_classes(problem)
+    todo_ids = {i for i, r in cls.items()
+                if r["cls"] in ("killed_by_T0", "high_value", "no_witness")
+                and r.get("reason") not in ("crash", "probe_crash", "cuda_poisoned")}
+
+    jpath = os.path.join(RESULTS, f"matrix_{problem}.jsonl")
+    done, pending = set(), None
+    if os.path.exists(jpath):
+        for line in open(jpath):
+            r = json.loads(line)
+            if r["type"] == "START":
+                pending = (r["id"], r["suite"])
+            elif r["type"] == "CELL":
+                done.add((r["id"], r["suite"]))
+                pending = None
+    journal = open(jpath, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    if pending is not None:
+        emit(type="CELL", id=pending[0], suite=pending[1],
+             outcome="killed", reason="crash")
+        done.add(pending)
+
+    _ms = list(mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"])))
+    _cap = int(os.environ.get("MUTANT_CAP", "0"))
+    if _cap:
+        _ms = mutator.stratified_sample(_ms, _cap)   # same sample as screening
+    mutants = {m["id"]: m for m in _ms}
+    suites = [(n, min(t, 1), b) for n, t, b in valid_suites(problem)
+              if n != "T0_original"]
+
+    # suite-major order so only ONE suite's inputs live on the GPU at a time
+    # (fits 24GB cards); reference outputs stay on CPU and comparison runs there.
+    remaining = [(mid, sname) for sname, _, _ in suites for mid in sorted(todo_ids)
+                 if (mid, sname) not in done]
+    if not remaining:
+        emit(type="MDONE", problem=problem)
+        return
+
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    ref_fn = ref_fn_for(problem)
+    cache = {}
+
+    def get_pair(sname, builder):
+        if sname not in cache:
+            cache.clear()
+            torch.cuda.empty_cache()
+            gpu_in = [t.cuda() for t in builder(0)]
+            with torch.no_grad():
+                ref = ref_fn(*gpu_in)      # keep on GPU: CPU round-trips dominated runtime
+            cache[sname] = (gpu_in, ref)
+        return cache[sname]
+
+    suite_map = {n: b for n, _, b in suites}
+    ptx_cache = {}
+    for mid, sname in remaining:
+        if mid not in ptx_cache:
+            src = externc(mutants[mid]["src"])
+            ptx_cache[mid] = compile_ptx(src, "m.cu")
+        emit(type="START", id=mid, suite=sname)
+        kern = NvrtcKernel(cuda_lib, ptx_cache[mid], kernel_name(problem))
+        try:
+            gpu_in, ref = get_pair(sname, suite_map[sname])
+            pet_watchdog()
+            out = kern.launch(problem, gpu_in, torch)
+            r = compare(ref, out, torch)
+            del out
+            torch.cuda.empty_cache()
+            kern.unload()
+        except RuntimeError as e:
+            emit(type="CELL", id=mid, suite=sname, outcome="killed",
+                 reason="crash", detail=str(e)[:80])
+            journal.close()
+            sys.exit(3)
+        emit(type="CELL", id=mid, suite=sname,
+             outcome="survived" if r == "survived" else "killed")
+    emit(type="MDONE", problem=problem)
+
+
+def orchestrate():
+    """Fork-per-problem: substrate registry loaded once in the parent."""
+    from forkpool import run_isolated
+    for problem in my_problems():
+        for attempt in range(120):
+            rc = run_isolated(worker, problem, timeout=2700)
+            if rc in (0, 124):
+                break
+        print(f"[matrix] {problem}: done", flush=True)
+    print("[matrix] ALL DONE", flush=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2 and sys.argv[1] == "--worker":
+        worker(sys.argv[2])
+    else:
+        orchestrate()

pipeline/gate_candidates.py

@@ -0,0 +1,85 @@
+"""GPU admission gate for substrate candidates.
+
+Loads substrates/candidate_*.py (pending), validates each against the OFFICIAL
+torch reference on all its suites (T0 capped at 2 trials) plus probes.
+Passers move to substrates/accepted/ (auto-loaded thereafter); failures stay
+pending with a report line — never admitted.
+"""
+import ctypes
+import json
+import os
+import shutil
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import torch  # noqa: E402
+
+import candidates_loader  # noqa: E402
+import kernels_def as K   # noqa: E402
+import problems_ext       # noqa: E402,F401
+from nvrtc_tce import externc, compile_ptx, device_source  # noqa: E402
+from screen_mutants import NvrtcKernel, kernel_name, launch_spec, ref_fn_for  # noqa: E402
+
+ATOL = RTOL = 1e-2
+
+
+def check(problem):
+    src = externc(device_source(K.PROBLEMS[problem]["cuda"]))
+    try:
+        ptx = compile_ptx(src, f"{problem}.cu")
+    except RuntimeError as e:
+        return False, f"nvrtc_fail: {str(e)[:120]}"
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    kern = NvrtcKernel(cuda_lib, ptx, kernel_name(problem))
+    ref_fn = ref_fn_for(problem)
+    try:
+        for sname, n_trials, builder in K.PROBLEMS[problem]["suites"]():
+            for trial in range(min(n_trials, 2)):
+                gpu_in = [t.cuda() for t in builder(trial)]
+                with torch.no_grad():
+                    ref = ref_fn(*gpu_in)
+                out = kern.launch(problem, gpu_in, torch)
+                if out.shape != ref.shape:
+                    return False, f"{sname}/t{trial}: shape {tuple(out.shape)} vs {tuple(ref.shape)}"
+                if out.dtype.is_floating_point:
+                    ok = torch.allclose(ref, out, atol=ATOL, rtol=RTOL)
+                else:
+                    ok = bool((ref == out).all())
+                if not ok:
+                    diff = (ref.float() - out.float()).abs().nan_to_num(nan=float("inf"))
+                    return False, f"{sname}/t{trial}: value max_diff={float(diff.max()):.4g}"
+                del gpu_in, ref, out
+                torch.cuda.empty_cache()
+    except RuntimeError as e:
+        return False, f"runtime: {str(e)[:120]}"
+    finally:
+        kern.unload()
+    return True, "ok"
+
+
+def main():
+    torch.zeros(1, device="cuda")
+    os.makedirs(os.path.join(HERE, "substrates", "accepted"), exist_ok=True)
+    added = candidates_loader.load_pending()
+    report = []
+    for problem in added:
+        ok, detail = check(problem)
+        report.append(dict(problem=problem, admitted=ok, detail=detail))
+        print(f"[gate] {problem:14s} {'ADMIT' if ok else 'REJECT'}  {detail}",
+              flush=True)
+        if ok:
+            src = os.path.join(HERE, "substrates", f"candidate_{problem}.py")
+            if os.path.exists(src):
+                shutil.move(src, os.path.join(HERE, "substrates", "accepted",
+                                              f"candidate_{problem}.py"))
+    with open(os.path.join(RESULTS, "gate_report.json"), "w") as f:
+        json.dump(report, f, indent=1)
+    n_ok = sum(1 for r in report if r["admitted"])
+    print(f"[gate] admitted {n_ok}/{len(report)}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

pipeline/kernels_def.py

@@ -0,0 +1,437 @@
+"""Definitions: 4 correct CUDA kernels for KernelBench problems, their mutants,
+and test suites (original KernelBench inputs + targeted inputs).
+
+Mutants are string substitutions on the CUDA source (universalmutator-style),
+covering categories: boundary/guard, indexing, sync, precision, semantic.
+"""
+import os
+import torch
+import torch.nn as nn
+
+KB_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "KernelBench", "KernelBench")
+
+# ---------------------------------------------------------------- ReLU (level1/19)
+
+RELU_CUDA = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cuda_fp16.h>
+
+__global__ void relu_kernel(const float* x, float* out, long long n) {
+    long long idx = (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) { float val = x[idx]; out[idx] = fmaxf(val, 0.0f); }
+}
+
+torch::Tensor relu_cuda(torch::Tensor x) {
+    auto xc = x.contiguous();
+    auto out = torch::zeros_like(xc);
+    long long n = xc.numel();
+    const int block = 256;
+    long long grid = (n + block - 1) / block;
+    relu_kernel<<<(unsigned int)grid, block>>>(xc.data_ptr<float>(), out.data_ptr<float>(), n);
+    return out;
+}
+"""
+RELU_CPP = "torch::Tensor relu_cuda(torch::Tensor x);"
+
+RELU_MUTANTS = [
+    dict(id="R1", category="semantic", desc="remove ReLU: fmaxf(val,0) -> val",
+         subs=[("fmaxf(val, 0.0f)", "val")]),
+    dict(id="R2", category="boundary", desc="remove idx<n guard (OOB write)",
+         subs=[("if (idx < n) { float val", "{ float val")]),
+    dict(id="R3", category="boundary", desc="grid ceil-div -> floor-div (tail not computed)",
+         subs=[("(n + block - 1) / block", "n / block")]),
+    dict(id="R4", category="boundary", desc="guard < -> <= (single OOB element)",
+         subs=[("if (idx < n)", "if (idx <= n)")]),
+    dict(id="R5", category="semantic", desc="fmaxf -> fminf (sanity: should be killed)",
+         subs=[("fmaxf(val, 0.0f)", "fminf(val, 0.0f)")]),
+    dict(id="R6", category="precision", desc="fp16 roundtrip on output",
+         subs=[("out[idx] = fmaxf(val, 0.0f);",
+                "out[idx] = __half2float(__float2half(fmaxf(val, 0.0f)));")]),
+    dict(id="R7", category="indexing", desc="threadIdx.x -> threadIdx.y (GPU-specific op)",
+         subs=[("blockDim.x + threadIdx.x;", "blockDim.x + threadIdx.y;")]),
+]
+
+# ------------------------------------------------------------ MatMul (level1/1)
+
+MATMUL_CUDA = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cuda_fp16.h>
+
+#define TILE 32
+
+__global__ void matmul_kernel(const float* A, const float* B, float* C, int N) {
+    __shared__ float As[TILE][TILE];
+    __shared__ float Bs[TILE][TILE];
+    int row = blockIdx.y * TILE + threadIdx.y;
+    int col = blockIdx.x * TILE + threadIdx.x;
+    float acc = 0.0f;
+    int numTiles = (N + TILE - 1) / TILE;
+    for (int t = 0; t < numTiles; t++) {
+        int a_col = t * TILE + threadIdx.x;
+        int b_row = t * TILE + threadIdx.y;
+        As[threadIdx.y][threadIdx.x] = (row < N && a_col < N) ? A[row * N + a_col] : 0.0f;
+        Bs[threadIdx.y][threadIdx.x] = (b_row < N && col < N) ? B[b_row * N + col] : 0.0f;
+        __syncthreads(); // sync-after-load
+        for (int k = 0; k < TILE; k++) {
+            acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];
+        }
+        __syncthreads(); // sync-after-compute
+    }
+    if (row < N && col < N) { C[row * N + col] = acc; }
+}
+
+torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B) {
+    auto Ac = A.contiguous(); auto Bc = B.contiguous();
+    int N = Ac.size(0);
+    auto C = torch::zeros({N, N}, Ac.options());
+    dim3 block(TILE, TILE);
+    dim3 grid((N + TILE - 1) / TILE, (N + TILE - 1) / TILE);
+    matmul_kernel<<<grid, block>>>(Ac.data_ptr<float>(), Bc.data_ptr<float>(), C.data_ptr<float>(), N);
+    return C;
+}
+"""
+MATMUL_CPP = "torch::Tensor matmul_cuda(torch::Tensor A, torch::Tensor B);"
+
+MATMUL_MUTANTS = [
+    dict(id="M1", category="boundary", desc="remove tile-load edge guards",
+         subs=[("(row < N && a_col < N) ? A[row * N + a_col] : 0.0f", "A[row * N + a_col]"),
+               ("(b_row < N && col < N) ? B[b_row * N + col] : 0.0f", "B[b_row * N + col]")]),
+    dict(id="M2", category="boundary", desc="numTiles ceil-div -> floor-div",
+         subs=[("int numTiles = (N + TILE - 1) / TILE;", "int numTiles = N / TILE;")]),
+    dict(id="M3", category="sync", desc="remove __syncthreads after tile load",
+         subs=[("__syncthreads(); // sync-after-load", "// removed sync-after-load")]),
+    dict(id="M4", category="sync", desc="remove __syncthreads after compute",
+         subs=[("__syncthreads(); // sync-after-compute", "// removed sync-after-compute")]),
+    dict(id="M5", category="precision", desc="fp16 accumulator",
+         subs=[("float acc = 0.0f;", "__half acc = __float2half(0.0f);"),
+               ("acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];",
+                "acc = __hadd(acc, __float2half(As[threadIdx.y][k] * Bs[k][threadIdx.x]));"),
+               ("C[row * N + col] = acc;", "C[row * N + col] = __half2float(acc);")]),
+    dict(id="M6", category="indexing", desc="transposed read of A tile (sanity: should be killed)",
+         subs=[("acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];",
+                "acc += As[k][threadIdx.y] * Bs[k][threadIdx.x];")]),
+    dict(id="M7", category="semantic", desc="acc += -> acc = (sanity: should be killed)",
+         subs=[("acc += As[threadIdx.y][k]", "acc = As[threadIdx.y][k]")]),
+    dict(id="M8", category="boundary", desc="drop last K tile (t < numTiles-1)",
+         subs=[("t < numTiles; t++", "t < numTiles - 1; t++")]),
+    dict(id="M9", category="indexing", desc="swap blockIdx.x/blockIdx.y (GPU-specific op)",
+         subs=[("int row = blockIdx.y * TILE + threadIdx.y;", "int row = blockIdx.x * TILE + threadIdx.y;"),
+               ("int col = blockIdx.x * TILE + threadIdx.x;", "int col = blockIdx.y * TILE + threadIdx.x;")]),
+]
+
+# ----------------------------------------------------------- Softmax (level1/23)
+
+SOFTMAX_CUDA = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cuda_fp16.h>
+#include <math_constants.h>
+
+__global__ void softmax_kernel(const float* x, float* out, int dim) {
+    long long row = blockIdx.x;
+    const float* xr = x + row * dim;
+    float* outr = out + row * dim;
+    __shared__ float sdata[256];
+    int tid = threadIdx.x;
+    int iters = (dim + 255) / 256;
+
+    float local_max = -CUDART_INF_F;
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { local_max = fmaxf(local_max, xr[i]); }
+    }
+    sdata[tid] = local_max;
+    __syncthreads(); // sync-max-store
+    for (int s = 128; s > 0; s >>= 1) { // max-reduce
+        if (tid < s) { sdata[tid] = fmaxf(sdata[tid], sdata[tid + s]); }
+        __syncthreads();
+    }
+    float row_max = sdata[0];
+    __syncthreads(); // sync-max-read
+
+    float local_sum = 0.0f;
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { local_sum += expf(xr[i] - row_max); }
+    }
+    sdata[tid] = local_sum;
+    __syncthreads(); // sync-sum-store
+    for (int s = 128; s > 0; s >>= 1) { // sum-reduce
+        if (tid < s) { sdata[tid] = sdata[tid] + sdata[tid + s]; }
+        __syncthreads();
+    }
+    float row_sum = sdata[0];
+    __syncthreads(); // sync-sum-read
+
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { outr[i] = expf(xr[i] - row_max) / row_sum; }
+    }
+}
+
+torch::Tensor softmax_cuda(torch::Tensor x) {
+    auto xc = x.contiguous();
+    int batch = xc.size(0);
+    int dim = xc.size(1);
+    auto out = torch::zeros_like(xc);
+    softmax_kernel<<<batch, 256>>>(xc.data_ptr<float>(), out.data_ptr<float>(), dim);
+    return out;
+}
+"""
+SOFTMAX_CPP = "torch::Tensor softmax_cuda(torch::Tensor x);"
+
+SOFTMAX_MUTANTS = [
+    dict(id="S1", category="precision", desc="no max subtraction (numerically unstable)",
+         subs=[("local_sum += expf(xr[i] - row_max);", "local_sum += expf(xr[i]);"),
+               ("outr[i] = expf(xr[i] - row_max) / row_sum;", "outr[i] = expf(xr[i]) / row_sum;")]),
+    dict(id="S2", category="semantic", desc="output all zeros (extreme cheat mutant)",
+         subs=[("outr[i] = expf(xr[i] - row_max) / row_sum;", "outr[i] = 0.0f;")]),
+    dict(id="S3", category="boundary", desc="iters ceil-div -> floor-div (tail elements dropped)",
+         subs=[("int iters = (dim + 255) / 256;", "int iters = dim / 256;")]),
+    dict(id="S4", category="precision", desc="fp16 accumulation of exp-sum",
+         subs=[("local_sum += expf(xr[i] - row_max);",
+                "local_sum = __half2float(__hadd(__float2half(local_sum), __float2half(expf(xr[i] - row_max))));")]),
+    dict(id="S5", category="semantic", desc="row max computed as row min",
+         subs=[("local_max = fmaxf(local_max, xr[i]);", "local_max = fminf(local_max, xr[i]);"),
+               ("sdata[tid] = fmaxf(sdata[tid], sdata[tid + s]);", "sdata[tid] = fminf(sdata[tid], sdata[tid + s]);")]),
+    dict(id="S6", category="boundary", desc="sum-reduce starts at s=64 (drops half of partials)",
+         subs=[("for (int s = 128; s > 0; s >>= 1) { // sum-reduce",
+                "for (int s = 64; s > 0; s >>= 1) { // sum-reduce")]),
+    dict(id="S7", category="sync", desc="remove __syncthreads before sum-reduce",
+         subs=[("__syncthreads(); // sync-sum-store", "// removed sync-sum-store")]),
+]
+
+# ------------------------------------------------- Sum reduction (level1/47)
+
+SUM_CUDA = r"""
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+#include <cuda_fp16.h>
+
+__global__ void sum_dim1_kernel(const float* x, float* out, int B, int R, int C) {
+    int c = blockIdx.x * blockDim.x + threadIdx.x;
+    int b = blockIdx.y;
+    if (c >= C) return;
+    float acc = 0.0f;
+    for (int r = 0; r < R; r++) {
+        acc += x[(long long)b * R * C + (long long)r * C + c];
+    }
+    out[(long long)b * C + c] = acc;
+}
+
+torch::Tensor sum_dim1_cuda(torch::Tensor x) {
+    auto xc = x.contiguous();
+    int B = xc.size(0); int R = xc.size(1); int C = xc.size(2);
+    auto out = torch::zeros({B, 1, C}, xc.options());
+    const int block = 256;
+    dim3 grid((C + block - 1) / block, B);
+    sum_dim1_kernel<<<grid, block>>>(xc.data_ptr<float>(), out.data_ptr<float>(), B, R, C);
+    return out;
+}
+"""
+SUM_CPP = "torch::Tensor sum_dim1_cuda(torch::Tensor x);"
+
+SUM_MUTANTS = [
+    dict(id="U1", category="precision", desc="fp16 accumulator",
+         subs=[("float acc = 0.0f;", "__half acc = __float2half(0.0f);"),
+               ("acc += x[(long long)b * R * C + (long long)r * C + c];",
+                "acc = __hadd(acc, __float2half(x[(long long)b * R * C + (long long)r * C + c]));"),
+               ("out[(long long)b * C + c] = acc;", "out[(long long)b * C + c] = __half2float(acc);")]),
+    dict(id="U2", category="boundary", desc="drop last row (r < R-1)",
+         subs=[("r < R; r++", "r < R - 1; r++")]),
+    dict(id="U3", category="boundary", desc="remove c>=C guard (OOB, C=4095 misaligned)",
+         subs=[("if (c >= C) return;", "")]),
+    dict(id="U4", category="boundary", desc="grid ceil-div -> floor-div over columns",
+         subs=[("dim3 grid((C + block - 1) / block, B);", "dim3 grid(C / block, B);")]),
+    dict(id="U5", category="boundary", desc="skip first row (r starts at 1)",
+         subs=[("for (int r = 0; r < R; r++)", "for (int r = 1; r < R; r++)")]),
+    dict(id="U6", category="indexing", desc="swap row/col strides (sanity: should be killed)",
+         subs=[("acc += x[(long long)b * R * C + (long long)r * C + c];",
+                "acc += x[(long long)b * R * C + (long long)c * C + r];")]),
+]
+
+# ---------------------------------------------------------------- wrappers
+
+
+class ReluNew(nn.Module):
+    def __init__(self, ext):
+        super().__init__()
+        self.ext = ext
+
+    def forward(self, x):
+        return self.ext.relu_cuda(x)
+
+
+class MatmulNew(nn.Module):
+    def __init__(self, ext):
+        super().__init__()
+        self.ext = ext
+
+    def forward(self, A, B):
+        return self.ext.matmul_cuda(A, B)
+
+
+class SoftmaxNew(nn.Module):
+    def __init__(self, ext):
+        super().__init__()
+        self.ext = ext
+
+    def forward(self, x):
+        return self.ext.softmax_cuda(x)
+
+
+class SumNew(nn.Module):
+    def __init__(self, ext, dim=1):
+        super().__init__()
+        assert dim == 1
+        self.ext = ext
+
+    def forward(self, x):
+        return self.ext.sum_dim1_cuda(x)
+
+
+# ---------------------------------------------------------------- test suites
+# Each suite: (name, n_trials, builder(trial) -> list of input tensors (CPU)).
+# T0_original replicates the KernelBench protocol: get_inputs() under 5 seeds.
+
+
+def _seeded(seed):
+    torch.manual_seed(seed)
+
+
+def relu_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [torch.randn(4096, 393216)]
+
+    def t3(t):
+        _seeded(8)
+        return [torch.randn(127, 4097)]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1), ("T3_misaligned", 1, t3)]
+
+
+def matmul_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [torch.rand(4096, 4096), torch.rand(4096, 4096)]
+
+    def t1(t):
+        _seeded(7)
+        return [torch.randn(4096, 4096), torch.randn(4096, 4096)]
+
+    def t2(t):
+        _seeded(9)
+        return [torch.randn(4096, 4096) * 100.0, torch.randn(4096, 4096) * 100.0]
+
+    def t3(t):
+        _seeded(11)
+        return [torch.randn(1031, 1031), torch.randn(1031, 1031)]
+
+    def t4(t):
+        _seeded(13)
+        A = torch.rand(4096, 4096)
+        B = torch.rand(4096, 4096)
+        A[:, -32:] = 100.0
+        B[-32:, :] = 100.0
+        return [A, B]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1), ("T2_large", 1, t2),
+            ("T3_misaligned", 1, t3), ("T4_last_tile_spike", 1, t4)]
+
+
+def softmax_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [torch.rand(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(11)
+        x = torch.zeros(4096, 393216)
+        spike_cols = torch.randint(0, 393216, (4096,))
+        x[torch.arange(4096), spike_cols] = 20.0
+        return [x]
+
+    def t4(t):
+        _seeded(13)
+        x = torch.randn(64, 4099) * 0.01
+        x[:, -1] = 20.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T2_large", 1, t2),
+            ("T3_spiky", 1, t3), ("T4_tail_spike_misaligned", 1, t4)]
+
+
+def sum_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [torch.rand(128, 4096, 4095)]
+
+    def t1(t):
+        _seeded(7)
+        return [torch.randn(128, 4096, 4095)]
+
+    def t2(t):
+        _seeded(9)
+        return [torch.randn(128, 4096, 4095) * 1000.0]
+
+    def t4(t):
+        _seeded(13)
+        x = torch.rand(128, 4096, 4095)
+        x[:, 0, :] += 100.0
+        x[:, -1, :] += 100.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1), ("T2_large", 1, t2),
+            ("T4_edge_row_spike", 1, t4)]
+
+
+PROBLEMS = {
+    "relu": dict(
+        kb_file=os.path.join(KB_ROOT, "level1", "19_ReLU.py"),
+        cuda=RELU_CUDA, cpp=RELU_CPP, func="relu_cuda",
+        mutants=RELU_MUTANTS, wrapper=ReluNew, suites=relu_suites,
+    ),
+    "matmul": dict(
+        kb_file=os.path.join(KB_ROOT, "level1", "1_Square_matrix_multiplication_.py"),
+        cuda=MATMUL_CUDA, cpp=MATMUL_CPP, func="matmul_cuda",
+        mutants=MATMUL_MUTANTS, wrapper=MatmulNew, suites=matmul_suites,
+    ),
+    "softmax": dict(
+        kb_file=os.path.join(KB_ROOT, "level1", "23_Softmax.py"),
+        cuda=SOFTMAX_CUDA, cpp=SOFTMAX_CPP, func="softmax_cuda",
+        mutants=SOFTMAX_MUTANTS, wrapper=SoftmaxNew, suites=softmax_suites,
+    ),
+    "sum": dict(
+        kb_file=os.path.join(KB_ROOT, "level1", "47_Sum_reduction_over_a_dimension.py"),
+        cuda=SUM_CUDA, cpp=SUM_CPP, func="sum_dim1_cuda",
+        mutants=SUM_MUTANTS, wrapper=SumNew, suites=sum_suites,
+    ),
+}
+
+
+def mutated_source(problem, mutant):
+    src = PROBLEMS[problem]["cuda"]
+    for old, new in mutant["subs"]:
+        assert old in src, f"{problem}/{mutant['id']}: pattern not found: {old!r}"
+        src = src.replace(old, new)
+    assert src != PROBLEMS[problem]["cuda"], f"{problem}/{mutant['id']}: no-op mutation"
+    return src
+
+
+def all_variants(problem):
+    """Yield (variant_id, cuda_source). 'correct' first, then mutants."""
+    p = PROBLEMS[problem]
+    yield "correct", p["cuda"]
+    for m in p["mutants"]:
+        yield m["id"], mutated_source(problem, m)

pipeline/mechanism_curves.py

@@ -0,0 +1,99 @@
+"""Two mechanism studies for the paper (§5), pure oracle analysis + one kernel.
+
+Curve A — tolerance vacuity vs output magnitude:
+  softmax over increasing dim; at each dim, find the largest perturbation of
+  the reference output that still PASSES allclose(atol=rtol=1e-2). Shows the
+  oracle's blind band growing as outputs shrink (zeros pass for dim >~ 1/atol).
+
+Curve B — legitimate-variance ceiling:
+  our correct tiled matmul vs torch.matmul at (2048x8192)x(8192x4096), input
+  magnitude sweep. Signed (randn*s) inputs cross the tolerance line (false
+  kill of a CORRECT kernel); positive (rand*s) never do. Quantifies the
+  input-aggressiveness ceiling and its fix.
+
+Output: results/mechanism_curves.json + printed tables.
+"""
+import ctypes
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import torch  # noqa: E402
+
+import kernels_def as K  # noqa: E402
+import problems_ext      # noqa: E402,F401
+from nvrtc_tce import externc, compile_ptx, device_source  # noqa: E402
+from screen_mutants import NvrtcKernel, kernel_name  # noqa: E402
+
+ATOL = RTOL = 1e-2
+
+
+def curve_vacuity():
+    rows = []
+    for dim in [64, 512, 4096, 32768, 262144, 393216]:
+        torch.manual_seed(1)
+        x = torch.rand(64, dim, device="cuda")
+        ref = torch.softmax(x, dim=1)
+        mag = float(ref.mean())
+        zeros_pass = bool(torch.allclose(ref, torch.zeros_like(ref),
+                                         atol=ATOL, rtol=RTOL))
+        # largest multiplicative error (1+delta) that still passes
+        lo, hi = 0.0, 1e4
+        for _ in range(40):
+            mid = (lo + hi) / 2
+            if torch.allclose(ref, ref * (1 + mid), atol=ATOL, rtol=RTOL):
+                lo = mid
+            else:
+                hi = mid
+        rows.append(dict(dim=dim, mean_output=mag, zeros_pass=zeros_pass,
+                         max_undetected_rel_error=lo))
+        print(f"dim={dim:7d} mean_out={mag:.3g} zeros_pass={zeros_pass} "
+              f"max_undetected_rel_err={lo:.3g}", flush=True)
+    return rows
+
+
+def curve_variance_ceiling():
+    """Uses the sum-reduction op: torch reduces pairwise, our kernel
+    sequentially — accumulation orders are guaranteed to differ, so the
+    legitimate fp32 variance between two CORRECT implementations is nonzero
+    and grows with input magnitude under cancellation. (On matmul at some
+    shapes cuBLAS happens to match our K-order bitwise — variance is
+    implementation-pair-specific, which is itself a finding.)"""
+    src = externc(device_source(K.PROBLEMS["sum"]["cuda"]))
+    ptx = compile_ptx(src, "sum.cu")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    kern = NvrtcKernel(cuda_lib, ptx, kernel_name("sum"))
+    rows = []
+    for dist in ("signed", "positive"):
+        for scale in [1, 3, 10, 30, 100, 300, 1000, 3000]:
+            torch.manual_seed(2)
+            x = torch.randn(128, 4096, 4095, device="cuda") * scale
+            if dist == "positive":
+                x = x.abs()
+            with torch.no_grad():
+                ref = torch.sum(x, dim=1, keepdim=True)
+            out = kern.launch("sum", [x], torch)
+            diff = (ref - out).abs()
+            thresh = ATOL + RTOL * out.abs()
+            margin = float((diff - thresh).max())
+            false_kill = bool((diff > thresh).any())
+            rows.append(dict(dist=dist, scale=scale, max_diff=float(diff.max()),
+                             worst_margin=margin, false_kill=false_kill))
+            print(f"{dist:8s} scale={scale:5d} max_diff={float(diff.max()):.4g} "
+                  f"false_kill={false_kill}", flush=True)
+            del x, ref, out, diff, thresh
+            torch.cuda.empty_cache()
+    kern.unload()
+    return rows
+
+
+if __name__ == "__main__":
+    torch.zeros(1, device="cuda")
+    out = dict(vacuity=curve_vacuity(), variance_ceiling=curve_variance_ceiling())
+    with open(os.path.join(RESULTS, "mechanism_curves.json"), "w") as f:
+        json.dump(out, f, indent=1)
+    print("CURVES DONE", flush=True)

pipeline/mutator.py

@@ -0,0 +1,288 @@
+"""Universal mutator for CUDA device code.
+
+Pattern-level rules (generalized from the 29 validated hand-written mutants)
+are applied to arbitrary kernel source: each rule is a regex; each match site
+yields one mutant (replace that single occurrence). Deterministic: same source
++ same rules => same mutant set, ids stable.
+
+Categories mirror the validated taxonomy: boundary, sync, precision,
+indexing, arithmetic, semantic.
+"""
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class Rule:
+    name: str
+    category: str
+    pattern: str          # regex, applied to device source
+    replacement: str      # regex template (\1 etc.)
+    note: str = ""
+
+
+RULES = [
+    # ---- boundary -------------------------------------------------------
+    Rule("ceil2floor", "boundary",
+         r"\(\s*(\w+)\s*\+\s*(\w+)\s*-\s*1\s*\)\s*/\s*\2",
+         r"\1 / \2",
+         "ceil-div -> floor-div: tail block never processed"),
+    Rule("ceil2floor-lit", "boundary",
+         r"\(\s*(\w+)\s*\+\s*(\d+)\s*\)\s*/\s*(\d+)",
+         r"\1 / \3",
+         "(x + K-1)/K with literal K -> floor"),
+    Rule("lt2le", "boundary",
+         r"(\w[\w\.\[\]]*) < (\w[\w\.\[\]]*)\)",
+         r"\1 <= \2)",
+         "guard/loop bound < -> <= : off-by-one overrun"),
+    Rule("le2lt", "boundary",
+         r"(\w[\w\.\[\]]*) <= (\w[\w\.\[\]]*)\)",
+         r"\1 < \2)",
+         "<= -> < : off-by-one underrun"),
+    Rule("ge2gt", "boundary",
+         r"(\w[\w\.\[\]]*) >= (\w[\w\.\[\]]*)\)",
+         r"\1 > \2)",
+         "early-return guard >= -> > : one OOB lane slips through"),
+    Rule("guard-drop-if", "boundary",
+         r"if \((\w+) < (\w+)\) ",
+         r"",
+         "remove single-line bounds guard entirely (silent OOB)"),
+    Rule("guard-drop-ternary", "boundary",
+         r"\(([^?\n]{1,80})\) \? ([^:\n]{1,80}) : 0\.0f",
+         r"\2",
+         "remove edge-tile ternary guard: unconditional load"),
+    Rule("loop-bound-minus1", "boundary",
+         r"; (\w+) < ([\w\.\[\]]+); \1\+\+",
+         r"; \1 < \2 - 1; \1++",
+         "drop last loop iteration (last tile / last row missing)"),
+    Rule("loop-start-1", "boundary",
+         r"for \(int (\w+) = 0;",
+         r"for (int \1 = 1;",
+         "skip first loop iteration"),
+    # ---- sync -----------------------------------------------------------
+    Rule("sync-remove", "sync",
+         r"__syncthreads\(\);",
+         r"",
+         "remove barrier: shared-memory race"),
+    # ---- precision ------------------------------------------------------
+    Rule("acc-fp16", "precision",
+         r"float (\w*(?:acc|sum)\w*) = 0\.0f;",
+         r"__half \1 = __float2half(0.0f); #define ACCH_\1",
+         "fp32 accumulator declared fp16 (paired by fixup below)"),
+    Rule("store-fp16", "precision",
+         r"(\w+)\[(\w[\w \+\*\.]*)\] = ([\w\(\)\[\]\.\+\-\*/, ]+);",
+         r"\1[\2] = __half2float(__float2half(\3));",
+         "output store through fp16 roundtrip"),
+    Rule("expf-fast", "precision",
+         r"expf\(",
+         r"__expf(",
+         "expf -> fast-math __expf approximation"),
+    Rule("fdividef-fast", "precision",
+         r"([\w\(\)\[\]\. ]+) / (\w*sum\w*)",
+         r"__fdividef(\1, \2)",
+         "true division -> fast approximate division"),
+    # ---- indexing (GPU-specific) ----------------------------------------
+    Rule("tidx2tidy", "indexing",
+         r"threadIdx\.x",
+         r"threadIdx.y",
+         "wrong thread axis"),
+    Rule("bidx2bidy", "indexing",
+         r"blockIdx\.x",
+         r"blockIdx.y",
+         "wrong block axis (single site, unlike consistent-swap)"),
+    Rule("bdim2gdim", "indexing",
+         r"blockDim\.x",
+         r"gridDim.x",
+         "blockDim -> gridDim in index math"),
+    # ---- arithmetic / semantic -----------------------------------------
+    Rule("plus2minus", "arithmetic",
+         r"(\w[\w\]\[\.]*) \+ (\w[\w\]\[\.]*)",
+         r"\1 - \2",
+         "AOR: + -> -"),
+    Rule("acc-overwrite", "semantic",
+         r"(\w+) \+= ",
+         r"\1 = ",
+         "accumulate -> overwrite (keeps last term only)"),
+    Rule("acc-minus", "semantic",
+         r"(\w+) \+= ",
+         r"\1 -= ",
+         "accumulate -> subtract"),
+    Rule("fmax2fmin", "semantic",
+         r"fmaxf\(",
+         r"fminf(",
+         "max -> min"),
+    Rule("fmin2fmax", "semantic",
+         r"fminf\(",
+         r"fmaxf(",
+         "min -> max"),
+    Rule("sentinel-zero", "semantic",
+         r"-CUDART_INF_F",
+         r"0.0f",
+         "reduction sentinel -inf -> 0 (breaks all-negative rows)"),
+    Rule("const0to1", "semantic",
+         r"= 0\.0f;",
+         r"= 1.0f;",
+         "init constant 0 -> 1"),
+    # ---- ROR completion --------------------------------------------------
+    Rule("lt2gt", "boundary",
+         r"(\w[\w\.\[\]]*) < (\w[\w\.\[\]]*)\)",
+         r"\1 > \2)",
+         "ROR: < -> > (inverted guard)"),
+    Rule("gt2ge", "boundary",
+         r"(\w[\w\.\[\]]*) > (\w[\w\.\[\]]*)\)",
+         r"\1 >= \2)",
+         "ROR: > -> >="),
+    Rule("return-guard-drop", "boundary",
+         r"if \((\w+) >= (\w+)\) return;",
+         r"",
+         "remove early-return bounds guard (silent OOB)"),
+    # ---- AOR completion --------------------------------------------------
+    Rule("mul2div", "arithmetic",
+         r"(\w[\w\]\[\.]*) \* (\w[\w\]\[\.]*)",
+         r"\1 / \2",
+         "AOR: * -> /"),
+    Rule("mul2plus", "arithmetic",
+         r"(\w[\w\]\[\.]*) \* (\w[\w\]\[\.]*)",
+         r"\1 + \2",
+         "AOR: * -> +"),
+    Rule("minus2plus", "arithmetic",
+         r"(\w[\w\]\[\.]*) - (\w[\w\]\[\.]*)",
+         r"\1 + \2",
+         "AOR: - -> +"),
+    Rule("negate-store", "arithmetic",
+         r"= (expf\([^;]+\));",
+         r"= -(\1);",
+         "UOI: negate stored expression"),
+    # ---- GPU-specific additions ------------------------------------------
+    Rule("sync2syncwarp", "sync",
+         r"__syncthreads\(\);",
+         r"__syncwarp();",
+         "block barrier -> warp barrier (insufficient sync, realistic bug)"),
+    Rule("reduce-shift2", "boundary",
+         r">>= 1\)",
+         r">>= 2)",
+         "tree reduction skips levels"),
+    Rule("smem-index-off1", "indexing",
+         r"\[(\w+) \+ (\w+)\]",
+         r"[\1 + \2 + 1]",
+         "shared-memory partner index off by one"),
+    Rule("warpsize-16", "indexing",
+         r"= (\d{2,3}) / 2;",
+         r"= \1 / 4;",
+         "reduction start half -> quarter"),
+]
+
+# acc-fp16 needs paired rewrites of the += line and the final store; a single
+# regex site can't do that, so it is expanded structurally here.
+
+
+def _expand_fp16_acc(src, var):
+    out = src
+    out = out.replace(f"float {var} = 0.0f;", f"__half {var} = __float2half(0.0f);")
+    m = re.search(rf"{re.escape(var)} \+= ([^;]+);", out)
+    if not m:
+        return None
+    out = out.replace(m.group(0), f"{var} = __hadd({var}, __float2half({m.group(1)}));")
+    m2 = re.search(rf"= {re.escape(var)};", out)
+    if m2:
+        out = out.replace(m2.group(0), f"= __half2float({var});")
+    return out if out != src else None
+
+
+def layer_of(src, pos):
+    """Which __global__ (i.e. which network layer) contains this offset?
+    Multi-kernel level-3 substrates hold one kernel per layer, so this labels
+    each mutant with its depth and lets us measure fault propagation."""
+    idx, kname = -1, "?"
+    for i, m in enumerate(re.finditer(r"__global__\s+void\s+(\w+)", src)):
+        if m.start() <= pos:
+            idx, kname = i, m.group(1)
+        else:
+            break
+    return idx, kname
+
+
+def stratified_sample(mutants, cap, seed=0):
+    """Cap the pool per problem while preserving the (rule, layer) mix.
+
+    Level-3 substrates yield thousands of mutants per problem (one kernel per
+    layer); exhaustive screening is neither affordable nor necessary. We keep a
+    proportional share of every (rule, layer) stratum so the class distribution
+    — and every layer's representation — survives the cut.
+    """
+    import collections
+    import random
+    if len(mutants) <= cap:
+        return mutants
+    strata = collections.defaultdict(list)
+    for m in mutants:
+        strata[(m["rule"], m.get("layer", -1))].append(m)
+    rng = random.Random(seed)
+    keep, order = [], sorted(strata)
+    # one from every stratum first, so no rule or layer disappears
+    for k in order:
+        keep.append(strata[k][0])
+    remaining = cap - len(keep)
+    if remaining > 0:
+        rest = [m for k in order for m in strata[k][1:]]
+        rng.shuffle(rest)
+        keep.extend(rest[:remaining])
+    keep.sort(key=lambda m: m["id"])
+    return keep
+
+
+def generate(name, src):
+    """Yield dicts: one mutant per (rule, match site). Deterministic order."""
+    seen_src = {src}
+    for rule in RULES:
+        if rule.name == "acc-fp16":
+            for m in re.finditer(r"float (\w*(?:acc|sum)\w*) = 0\.0f;", src):
+                mutated = _expand_fp16_acc(src, m.group(1))
+                if mutated and mutated not in seen_src:
+                    seen_src.add(mutated)
+                    li, lname = layer_of(src, m.start())
+                    yield dict(id=f"{name}:acc-fp16:{m.start()}", rule=rule.name,
+                               category=rule.category, site=m.group(1),
+                               src=mutated, layer=li, layer_name=lname)
+            continue
+        for i, m in enumerate(re.finditer(rule.pattern, src)):
+            mutated = src[:m.start()] + m.expand(rule.replacement) + src[m.end():]
+            if "#define ACCH" in mutated:  # acc-fp16 placeholder path, handled above
+                continue
+            if mutated == src or mutated in seen_src:
+                continue
+            seen_src.add(mutated)
+            snippet = " ".join(m.group(0).split())[:48]
+            li, lname = layer_of(src, m.start())
+            yield dict(id=f"{name}:{rule.name}:{i}", rule=rule.name,
+                       category=rule.category, site=snippet, src=mutated,
+                       layer=li, layer_name=lname)
+
+
+if __name__ == "__main__":
+    import kernels_def as K
+    from nvrtc_tce import device_source
+    total = 0
+    for prob in K.PROBLEMS:
+        muts = list(generate(prob, device_source(K.PROBLEMS[prob]["cuda"])))
+        by_cat = {}
+        for mu in muts:
+            by_cat[mu["category"]] = by_cat.get(mu["category"], 0) + 1
+        print(f"{prob:8s}: {len(muts):4d} mutants  {by_cat}")
+        total += len(muts)
+    print(f"total   : {total}")
+
+
+# ---- mined rules (LLM-designed, empirically validated; see rules/BRIEF.md) --
+try:
+    import os as _os, sys as _sys
+    _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+    from rules.mined_rules import MINED_RULES as _MINED
+    from rules.structural_rules import STRUCTURAL_RULES as _STRUCT
+    from rules.fine_rules import FINE_RULES as _FINE
+    _existing = {r.pattern for r in RULES}
+    for _r in list(_MINED) + list(_STRUCT) + list(_FINE):
+        if _r.pattern not in _existing:
+            RULES.append(_r); _existing.add(_r.pattern)
+except Exception:
+    pass

pipeline/nvrtc_tce.py

@@ -0,0 +1,161 @@
+"""NVRTC compile-time benchmark + TCE (Trivial Compiler Equivalence) dedup.
+
+For every variant in kernels_def, extract the device code (the __global__
+kernels, dropping the torch host wrapper), compile with NVRTC to PTX for
+sm_90, time it, and hash the normalized PTX. Variants with identical PTX
+hashes are trivially equivalent *at the device-code level* (note: mutants
+that only touch the host-side launch config will collide with 'correct' —
+in an NVRTC harness the launch config lives in Python and needs no nvcc).
+
+Also does one end-to-end sanity run: loads the NVRTC-compiled correct ReLU
+via the CUDA driver API and runs it on a torch tensor.
+"""
+import ctypes
+import ctypes.util
+import hashlib
+import re
+import time
+
+import kernels_def as K
+
+nvrtc = ctypes.CDLL("libnvrtc.so.12")
+
+
+def check(rc, what):
+    if rc != 0:
+        raise RuntimeError(f"{what} failed rc={rc}")
+
+
+def compile_ptx(src, name="k.cu"):
+    prog = ctypes.c_void_p()
+    check(nvrtc.nvrtcCreateProgram(ctypes.byref(prog), src.encode(), name.encode(),
+                                   0, None, None), "nvrtcCreateProgram")
+    import os as _os
+    arch = _os.environ.get("NVRTC_ARCH", "compute_90").encode()
+    # The driver (535.x = CUDA 12.2) rejects PTX emitted for newer toolkits
+    # with cuModuleLoadData rc=222; pin the PTX ISA to what it accepts.
+    # Driver 535.x (CUDA 12.2) refuses PTX emitted by the 12.6 NVRTC
+    # (cuModuleLoadData rc=222). Emitting CUBIN instead skips the driver's
+    # PTX JIT entirely: it is already SASS for this exact architecture.
+    use_cubin = _os.environ.get("NVRTC_CUBIN", "1") == "1"
+    if use_cubin:
+        arch = arch.replace(b"compute_", b"sm_")
+    opts = [b"--gpu-architecture=" + arch, b"-I/usr/local/cuda/include",
+            b"--std=c++17", b"-default-device"]
+    arr = (ctypes.c_char_p * len(opts))(*opts)
+    rc = nvrtc.nvrtcCompileProgram(prog, len(opts), arr)
+    logsz = ctypes.c_size_t()
+    nvrtc.nvrtcGetProgramLogSize(prog, ctypes.byref(logsz))
+    log = ctypes.create_string_buffer(logsz.value)
+    nvrtc.nvrtcGetProgramLog(prog, log)
+    if rc != 0:
+        nvrtc.nvrtcDestroyProgram(ctypes.byref(prog))
+        raise RuntimeError(f"nvrtc compile error:\n{log.value.decode()[:800]}")
+    sz = ctypes.c_size_t()
+    if use_cubin:
+        check(nvrtc.nvrtcGetCUBINSize(prog, ctypes.byref(sz)), "nvrtcGetCUBINSize")
+        buf = ctypes.create_string_buffer(sz.value)
+        check(nvrtc.nvrtcGetCUBIN(prog, buf), "nvrtcGetCUBIN")
+        nvrtc.nvrtcDestroyProgram(ctypes.byref(prog))
+        return buf.raw[:sz.value]          # bytes: image for cuModuleLoadData
+    check(nvrtc.nvrtcGetPTXSize(prog, ctypes.byref(sz)), "nvrtcGetPTXSize")
+    buf = ctypes.create_string_buffer(sz.value)
+    check(nvrtc.nvrtcGetPTX(prog, buf), "nvrtcGetPTX")
+    nvrtc.nvrtcDestroyProgram(ctypes.byref(prog))
+    return buf.value.decode()
+
+
+def externc(src):
+    """Give every __global__ C linkage so cuModuleGetFunction can find it by
+    name. Optimized kernels often write `__global__ __launch_bounds__(256) void
+    foo(...)`, so a plain "__global__ void" replacement misses them and the
+    symbol stays C++-mangled."""
+    import re as _re
+    return _re.sub(r'(?<!extern "C" )__global__(\s+(?:__launch_bounds__\s*\([^)]*\)\s*)?)',
+                   r'extern "C" __global__\1', src)
+
+
+def device_source(cuda_src):
+    """Keep everything up to the torch host wrapper; drop host-only includes."""
+    body = cuda_src.split("torch::Tensor")[0]
+    for inc in ("#include <torch/extension.h>", "#include <cuda_runtime.h>"):
+        body = body.replace(inc, "")
+    return body
+
+
+def normalized_hash(image):
+    """TCE hash over the compiled image (PTX text or CUBIN bytes)."""
+    if isinstance(image, bytes):
+        return hashlib.sha256(image).hexdigest()[:16]
+    lines = [l for l in image.splitlines() if not l.strip().startswith("//")]
+    return hashlib.sha256("\n".join(lines).encode()).hexdigest()[:16]
+
+
+def main():
+    rows = []
+    t_all = time.time()
+    for prob in K.PROBLEMS:
+        for vid, src in K.all_variants(prob):
+            dsrc = device_source(src)
+            t0 = time.time()
+            try:
+                ptx = compile_ptx(dsrc, f"{prob}_{vid}.cu")
+                dt = time.time() - t0
+                rows.append((prob, vid, dt, normalized_hash(ptx)))
+            except RuntimeError as e:
+                rows.append((prob, vid, time.time() - t0, f"COMPILE_FAIL: {e}"))
+    total = time.time() - t_all
+
+    print(f"== NVRTC compile times (sm_90), {len(rows)} variants, "
+          f"total {total:.2f}s ==")
+    times = [r[2] for r in rows if not str(r[3]).startswith("COMPILE_FAIL")]
+    print(f"per-variant: min {min(times)*1000:.0f}ms  max {max(times)*1000:.0f}ms  "
+          f"mean {sum(times)/len(times)*1000:.0f}ms")
+    print()
+    print("== TCE dedup (identical device PTX hash) ==")
+    by_hash = {}
+    for prob, vid, dt, h in rows:
+        by_hash.setdefault((prob, h), []).append(vid)
+    for (prob, h), vids in sorted(by_hash.items()):
+        if len(vids) > 1:
+            print(f"  {prob}: {vids}  <- identical device code (hash {h})")
+    print()
+    for prob, vid, dt, h in rows:
+        print(f"  {prob:8s} {vid:8s} {dt*1000:6.0f}ms  {h}")
+
+    # ---- end-to-end: run NVRTC-compiled correct ReLU on a torch tensor ----
+    print()
+    print("== end-to-end launch of NVRTC-compiled ReLU via driver API ==")
+    import torch
+    x = torch.randn(1_000_003, device="cuda")  # deliberately misaligned size
+    out = torch.zeros_like(x)
+    torch.cuda.synchronize()
+
+    cuda = ctypes.CDLL("libcuda.so.1")
+    dsrc = device_source(K.PROBLEMS["relu"]["cuda"]).replace(
+        "__global__ void", 'extern "C" __global__ void')
+    ptx = compile_ptx(dsrc, "relu.cu")
+    module = ctypes.c_void_p()
+    check(cuda.cuModuleLoadData(ctypes.byref(module), ptx.encode()), "cuModuleLoadData")
+    func = ctypes.c_void_p()
+    check(cuda.cuModuleGetFunction(ctypes.byref(func), module, b"relu_kernel"),
+          "cuModuleGetFunction")
+
+    n = ctypes.c_longlong(x.numel())
+    xp = ctypes.c_void_p(x.data_ptr())
+    op = ctypes.c_void_p(out.data_ptr())
+    args = (ctypes.c_void_p * 3)(
+        ctypes.cast(ctypes.byref(xp), ctypes.c_void_p),
+        ctypes.cast(ctypes.byref(op), ctypes.c_void_p),
+        ctypes.cast(ctypes.byref(n), ctypes.c_void_p))
+    block = 256
+    grid = (x.numel() + block - 1) // block
+    check(cuda.cuLaunchKernel(func, grid, 1, 1, block, 1, 1, 0, None, args, None),
+          "cuLaunchKernel")
+    torch.cuda.synchronize()
+    ok = torch.equal(out, torch.relu(x))
+    print(f"  launch ok, output matches torch.relu exactly: {ok}")
+
+
+if __name__ == "__main__":
+    main()

pipeline/problems_batch2.py

@@ -0,0 +1,799 @@
+"""Substrate batch 2: 14 more KernelBench level1 problems.
+
+8 activations (elementwise), 3 matmul variants, min-reduction, L1/L2 row norm.
+Self-contained (no imports from problems_ext to avoid circular imports);
+registered into kernels_def.PROBLEMS on import.
+"""
+import ctypes
+
+import torch as _torch
+
+import kernels_def as K
+
+
+def _seeded(seed):
+    _torch.manual_seed(seed)
+
+
+# --------------------------------------------------------------- elementwise
+
+_EW_TMPL = r"""
+#include <cuda_fp16.h>
+
+__global__ void {kname}(const float* x, float* out, long long n) {{
+    long long idx = (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) {{ float val = x[idx]; out[idx] = {expr}; }}
+}}
+"""
+
+
+def _ew_launch(inputs, torch):
+    x = inputs[0]
+    out = torch.zeros_like(x)
+    n = x.numel()
+    return out, ((n + 255) // 256, 1, 1), (256, 1, 1), [(ctypes.c_longlong, n)]
+
+
+def _ew_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3)]
+
+
+def _swish_suites():
+    def t4(t):
+        _seeded(73)
+        x = _torch.full((31, 257), 65536.0, dtype=_torch.float32)
+        x[:, 0::4] = 65520.0
+        x[:, 1::4] = 65568.0
+        x[:, 2::4] = 70000.0
+        x[:, -1] = 131072.0
+        return [x]
+
+    def t5(t):
+        _seeded(79)
+        x = _torch.tensor([[1.0, 8.0, 64.0, 65520.0, 70000.0]],
+                          dtype=_torch.float32)
+        return [x]
+
+    return _ew_suites() + [
+        ("T4_misaligned_fp16_overflow_stripes", 1, t4),
+        ("T5_small_partial_block_fp16_boundary", 1, t5),
+    ]
+
+
+def _tanh_suites():
+    def t4(t):
+        _seeded(73)
+        x = _torch.full((1, 257), 8.0, dtype=_torch.float32)
+        x[:, 0::4] = 0.125
+        x[:, 1::4] = 0.54930615
+        x[:, 2::4] = 1.0986123
+        x[:, -1] = 16.0
+        return [x]
+
+    def t5(t):
+        _seeded(79)
+        values = _torch.tensor([
+            0.010003, 0.031257, 0.062519, 0.125061,
+            0.255413, 0.549306, 1.098612, 2.0,
+            4.0, 8.0, 16.0,
+        ], dtype=_torch.float32)
+        x = values.repeat(23, 24)[:, :259]
+        x[:, -1] = 32.0
+        return [x]
+
+    return _ew_suites() + [
+        ("T4_misaligned_positive_tail_spike", 1, t4),
+        ("T5_positive_fp16_rounding_lattice", 1, t5),
+    ]
+
+
+def _hardsigmoid_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    def t4(t):
+        _seeded(61)
+        values = _torch.tensor([
+            -3.001, -3.0, -2.999, -2.75, -2.0, -1.0,
+            -0.003, 0.0, 0.003, 1.0, 2.0, 2.75,
+            2.999, 3.0, 3.001,
+        ], dtype=_torch.float32)
+        return [values.repeat(33, 18)[:, :257]]
+
+    def t5(t):
+        _seeded(67)
+        x = _torch.full((31, 257), 2.999, dtype=_torch.float32)
+        x[:, 0::4] = -2.999
+        x[:, 1::4] = -1.5015
+        x[:, 2::4] = 1.5015
+        x[:, -1] = 3000.0
+        return [x]
+
+    def t6(t):
+        _seeded(71)
+        outputs = (_torch.arange(255, dtype=_torch.float32) + 0.5) / 256.0
+        x = (outputs * 6.0 - 3.0).reshape(3, 85)
+        x[0, 0] = -3000.0
+        x[-1, -1] = 3000.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3),
+            ("T4_transition_threshold_stripes", 1, t4),
+            ("T5_misaligned_tail_spike", 1, t5),
+            ("T6_fp16_rounding_lattice", 1, t6)]
+
+
+def _hardtanh_suites():
+    def t4(t):
+        _seeded(67)
+        x = _torch.full((33, 257), 2.0, dtype=_torch.float32)
+        x[:, 0::4] = 0.999
+        x[:, 1::4] = 1.0
+        x[:, 2::4] = 1.001
+        x[:, -1] = 64.0
+        return [x]
+
+    def t5(t):
+        _seeded(71)
+        values = _torch.tensor([
+            -64.0, -1.001, -1.0, -0.999, -0.5002442,
+            -0.3332519, 0.3332519, 0.5002442, 0.9989,
+            0.999, 0.9991, 1.0, 1.001, 64.0,
+        ], dtype=_torch.float32)
+        return [values.repeat(19, 20)[:, :259]]
+
+    return _ew_suites() + [
+        ("T4_misaligned_upper_clamp_tail", 1, t4),
+        ("T5_clamp_and_fp16_neighborhoods", 1, t5),
+    ]
+
+
+def _softsign_suites():
+    def t4(t):
+        _seeded(73)
+        x = _torch.full((3, 257), 1.0e-4, dtype=_torch.float32)
+        x[:, 0::2] = 4096.0
+        x[:, -1] = 32768.0
+        return [x]
+
+    def t5(t):
+        _seeded(79)
+        outputs = (_torch.arange(1, 256, dtype=_torch.float32) + 0.5) / 256.0
+        x = (outputs / (1.0 - outputs)).reshape(3, 85)
+        x[0, 0] = 65504.0
+        x[-1, -1] = 1.0e8
+        return [x]
+
+    return _ew_suites() + [
+        ("T4_misaligned_alternating_tail_spike", 1, t4),
+        ("T5_positive_fp16_rounding_lattice", 1, t5),
+    ]
+
+
+def _selu_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    def t4(t):
+        _seeded(27)
+        values = _torch.tensor([
+            -8.0, -4.0, -2.0, -1.0, -0.5, -0.125,
+            -2.0e-6, -1.0e-6, -0.0, 0.0, 5.0e-7, 1.0e-6,
+            1.5e-6, 2.0e-6, 0.125, 0.5, 1.0, 4.0,
+        ], dtype=_torch.float32)
+        return [values.repeat(17, 15)[:, :257]]
+
+    def t5(t):
+        _seeded(28)
+        x = _torch.full((31, 257), -0.5, dtype=_torch.float32)
+        x[:, 0::4] = -8.0
+        x[:, 1::4] = -2.0
+        x[:, 2::4] = -0.125
+        x[:, -1] = -1.0e-6
+        return [x]
+
+    def t6(t):
+        _seeded(29)
+        x = _torch.linspace(-9.0, -1.0e-4, 259, dtype=_torch.float32)
+        return [x.repeat(33, 1)]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3),
+            ("T4_branch_threshold_neighborhood", 1, t4),
+            ("T5_misaligned_negative_stripes", 1, t5),
+            ("T6_negative_exponential_sweep", 1, t6)]
+
+
+def _elu_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    def t4(t):
+        _seeded(61)
+        values = _torch.tensor([
+            -1.0, -0.75, -0.5, -0.25, -0.125, -0.03125,
+            -1.0e-3, -1.0e-5, -0.0, 0.0, 1.0e-5, 1.0e-3,
+            0.03125, 0.125, 0.25, 0.5, 0.75, 1.0,
+        ], dtype=_torch.float32)
+        return [values.repeat(17, 15)[:, :257]]
+
+    def t5(t):
+        _seeded(67)
+        values = _torch.tensor([
+            -0.015625, -0.03125, -0.0625, -0.125, -0.25,
+            -0.5, -1.0, -2.0, -4.0, -8.0, -16.0,
+        ], dtype=_torch.float32)
+        return [values.repeat(31, 24)[:, :259]]
+
+    def t6(t):
+        _seeded(71)
+        x = _torch.full((3, 257), -0.5, dtype=_torch.float32)
+        x[:, 0::4] = -8.0
+        x[:, 1::4] = 0.25
+        x[:, 2::4] = -0.03125
+        x[:, -1] = -16.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3),
+            ("T4_branch_threshold_sweep", 1, t4),
+            ("T5_negative_exponential_ladder", 1, t5),
+            ("T6_misaligned_alternating_tail", 1, t6)]
+
+
+def _softplus_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    def t4(t):
+        _seeded(47)
+        values = _torch.tensor([
+            7.999, 8.0, 8.001, 9.0, 12.0, 16.0,
+            19.999, 20.0, 20.001,
+        ], dtype=_torch.float32)
+        return [values.repeat(29, 31)[:, :257]]
+
+    def t5(t):
+        _seeded(53)
+        x = _torch.full((31, 257), 8.0, dtype=_torch.float32)
+        x[:, 0::4] = 0.0
+        x[:, 1::4] = 7.999
+        x[:, 2::4] = 20.0
+        x[:, -1] = 20.001
+        return [x]
+
+    def t6(t):
+        _seeded(59)
+        values = _torch.tensor([
+            -20.0, -16.0, -12.0, -9.0, -8.0, -6.0,
+            -4.0, -2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0,
+            4.0, 6.0, 7.5, 7.999,
+        ], dtype=_torch.float32)
+        return [values.repeat(37, 15)[:, :257]]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3),
+            ("T4_cutoff_neighborhood", 1, t4),
+            ("T5_misaligned_cutoff_stripes", 1, t5),
+            ("T6_exponential_regime_sweep", 1, t6)]
+
+
+def _ew_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(32, 256)]),
+            ("p_misaligned", [torch.randn(7, 257)])]
+
+
+_F = _torch.nn.functional
+_ACTIVATIONS = {
+    "tanh": dict(kb="22_Tanh.py", expr="tanhf(val)",
+                 ref=lambda x: _torch.tanh(x), suites=_tanh_suites),
+    "swish": dict(kb="25_Swish.py",
+                  expr="val * (1.0f / (1.0f + expf(-val)))",
+                  ref=lambda x: x * _torch.sigmoid(x), suites=_swish_suites),
+    "selu": dict(kb="27_SELU_.py",
+                 expr="1.0507009873554805f * (val > 0.0f ? val : "
+                      "1.6732632423543772f * (expf(val) - 1.0f))",
+                 ref=lambda x: _torch.selu(x), suites=_selu_suites),
+    "hardsigmoid": dict(kb="28_HardSigmoid.py",
+                        expr="fminf(fmaxf(val / 6.0f + 0.5f, 0.0f), 1.0f)",
+                        ref=lambda x: _F.hardsigmoid(x),
+                        suites=_hardsigmoid_suites),
+    "softplus": dict(kb="29_Softplus.py",
+                     expr="val > 20.0f ? val : log1pf(expf(val))",
+                     ref=lambda x: _F.softplus(x), suites=_softplus_suites),
+    "softsign": dict(kb="30_Softsign.py",
+                     expr="val / (1.0f + fabsf(val))",
+                     ref=lambda x: _F.softsign(x), suites=_softsign_suites),
+    "elu": dict(kb="31_ELU.py",
+                expr="val > 0.0f ? val : (expf(val) - 1.0f)",
+                ref=lambda x: _F.elu(x), suites=_elu_suites),
+    "hardtanh": dict(kb="32_HardTanh.py",
+                     expr="fminf(fmaxf(val, -1.0f), 1.0f)",
+                     ref=lambda x: _F.hardtanh(x), suites=_hardtanh_suites),
+}
+
+# ----------------------------------------------------------- matmul variants
+
+_MM_TMPL = r"""
+#include <cuda_fp16.h>
+
+#define TILE 32
+
+__global__ void {kname}(const float* A, const float* B, float* C,
+                        int M, int K, int N) {{
+    __shared__ float As[TILE][TILE];
+    __shared__ float Bs[TILE][TILE];
+    int row = blockIdx.y * TILE + threadIdx.y;
+    int col = blockIdx.x * TILE + threadIdx.x;
+    float acc = 0.0f;
+    int numTiles = (K + TILE - 1) / TILE;
+    for (int t = 0; t < numTiles; t++) {{
+        int a_k = t * TILE + threadIdx.x;
+        int b_k = t * TILE + threadIdx.y;
+        As[threadIdx.y][threadIdx.x] = {a_load};
+        Bs[threadIdx.y][threadIdx.x] = {b_load};
+        __syncthreads(); // sync-after-load
+        for (int k = 0; k < TILE; k++) {{
+            acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];
+        }}
+        __syncthreads(); // sync-after-compute
+    }}
+    if (row < M && col < N) {{ C[(long long)row * N + col] = acc; }}
+}}
+"""
+
+_A_NORMAL = "(row < M && a_k < K) ? A[(long long)row * K + a_k] : 0.0f"
+_A_TRANS = "(a_k < K && row < M) ? A[(long long)a_k * M + row] : 0.0f"
+_B_NORMAL = "(b_k < K && col < N) ? B[(long long)b_k * N + col] : 0.0f"
+_B_TRANS = "(b_k < K && col < N) ? B[(long long)col * K + b_k] : 0.0f"
+
+
+def _mm_launch(a_layout, b_layout):
+    def launch(inputs, torch):
+        A, B = inputs
+        if a_layout == "t":
+            Kd, M = A.shape
+        else:
+            M, Kd = A.shape
+        N = B.shape[0] if b_layout == "t" else B.shape[1]
+        out = torch.zeros((M, N), device=A.device, dtype=A.dtype)
+        return out, ((N + 31) // 32, (M + 31) // 32, 1), (32, 32, 1), \
+            [(ctypes.c_int, M), (ctypes.c_int, Kd), (ctypes.c_int, N)]
+    return launch
+
+
+def _mm_var_suites(m, k, n, a_layout, b_layout, symmetric=False):
+    def a_shape():
+        return (k, m) if a_layout == "t" else (m, k)
+
+    def b_shape():
+        return (n, k) if b_layout == "t" else (k, n)
+
+    def gen(fn):
+        A, B = fn(*a_shape()), fn(*b_shape())
+        if symmetric:
+            A = (A + A.T) / 2
+            B = (B + B.T) / 2
+        return [A, B]
+
+    def t0(t):
+        _seeded(1000 + t)
+        return gen(_torch.rand)
+
+    def t1(t):
+        _seeded(7)
+        return gen(_torch.randn)
+
+    def t2(t):
+        _seeded(9)
+        return gen(lambda *s: _torch.rand(*s) * 50.0)
+
+    def t3(t):
+        _seeded(11)
+        m3, k3, n3 = 515, 1027, 259
+        if symmetric:
+            m3 = k3 = n3 = 515
+        A = _torch.randn(*((k3, m3) if a_layout == "t" else (m3, k3)))
+        B = _torch.randn(*((n3, k3) if b_layout == "t" else (k3, n3)))
+        if symmetric:
+            A = (A + A.T) / 2
+            B = (B + B.T) / 2
+        return [A, B]
+
+    def t4(t):
+        _seeded(13)
+        A, B = gen(_torch.rand)
+        A += 0.0
+        if a_layout == "t":
+            A[-32:, :] = 100.0
+        else:
+            A[:, -32:] = 100.0
+        if b_layout == "t":
+            B[:, -32:] = 100.0
+        else:
+            B[-32:, :] = 100.0
+        return [A, B]
+
+    def t5(t):
+        _seeded(17)
+        m5, k5, n5 = 39, 33, 35
+        rows = _torch.arange(m5, dtype=_torch.float32)[:, None]
+        red = _torch.arange(k5, dtype=_torch.float32)[None, :]
+        cols = _torch.arange(n5, dtype=_torch.float32)[None, :]
+        A = 0.25 + rows * 0.125 + red * 0.03125
+        B = 0.5 + red.T * 0.0625 + cols * 0.015625
+        return [A, B]
+
+    def t6(t):
+        _seeded(19)
+        m6, k6, n6 = 35, 33, 39
+        rows = _torch.arange(m6, dtype=_torch.float32)[:, None]
+        red = _torch.arange(k6, dtype=_torch.float32)[None, :]
+        cols = _torch.arange(n6, dtype=_torch.float32)[None, :]
+        A = 0.125 + rows * 0.0625 + red * 0.015625
+        B = 0.375 + red.T * 0.03125 + cols * 0.125
+        return [A, B]
+
+    def t7(t):
+        _seeded(23)
+        m7, k7, n7 = 37, 33, 41
+        A = _torch.full((m7, k7), 1.0e-3)
+        B = _torch.full((k7, n7), 1.0e-3)
+        A[:, -1] = 32.0 + _torch.arange(m7, dtype=_torch.float32)
+        B[-1, :] = 48.0 + _torch.arange(n7, dtype=_torch.float32)
+        return [A, B]
+
+    def t8(t):
+        _seeded(29)
+        m8, k8, n8 = 1025, 8191, 1025
+        A = _torch.ones((m8, k8), dtype=_torch.float32)
+        B = _torch.ones((n8, k8), dtype=_torch.float32)
+        A[:, -1] = 64.0
+        B[:, -1] = 96.0
+        return [A, B]
+
+    def t9(t):
+        _seeded(31)
+        m9, k9, n9 = 33, 31, 35
+        rows = _torch.arange(m9, dtype=_torch.float32)[:, None]
+        cols = _torch.arange(n9, dtype=_torch.float32)[:, None]
+        A = 0.25 + rows * 0.03125 + _torch.arange(
+            k9, dtype=_torch.float32)[None, :] * 0.015625
+        B = 0.5 + cols * 0.0625 + _torch.arange(
+            k9, dtype=_torch.float32)[None, :] * 0.03125
+        A[:, -1] = 48.0 + rows[:, 0]
+        B[:, -1] = 64.0 + cols[:, 0]
+        return [A, B]
+
+    def t10(t):
+        _seeded(37)
+        m10, k10, n10 = 35, 31, 37
+        red = _torch.arange(k10, dtype=_torch.float32)[:, None]
+        rows = _torch.arange(m10, dtype=_torch.float32)[None, :]
+        cols = _torch.arange(n10, dtype=_torch.float32)[:, None]
+        A = 0.25 + red * 0.03125 + rows * 0.125
+        B = 0.5 + cols * 0.25 + red.T * 0.0625
+        return [A, B]
+
+    def t11(t):
+        _seeded(41)
+        m11, k11, n11 = 33, 30, 35
+        A = _torch.full((k11, m11), 1.0e-3)
+        B = _torch.full((n11, k11), 1.0e-3)
+        A[-1, :] = 64.0 + _torch.arange(m11, dtype=_torch.float32)
+        B[:, -1] = 96.0 + _torch.arange(n11, dtype=_torch.float32)
+        return [A, B]
+
+    def t12(t):
+        _seeded(43)
+        m12, k12, n12 = 47, 63, 45
+        red = _torch.arange(k12, dtype=_torch.float32)[:, None]
+        rows = _torch.arange(m12, dtype=_torch.float32)[None, :]
+        cols = _torch.arange(n12, dtype=_torch.float32)[:, None]
+        A = 0.125 + red.remainder(2) * 31.875 + rows * 0.0625
+        B = 0.25 + (cols + red.T).remainder(2) * 47.75
+        return [A, B]
+
+    return lambda: [("T0_original", 5, t0), ("T1_signed", 1, t1),
+                    ("T2_large", 1, t2), ("T3_misaligned", 1, t3),
+                    ("T4_last_tile_spike", 1, t4)] + (
+                        [("T5_rect_m_gt_n_positional", 1, t5),
+                         ("T6_rect_n_gt_m_positional", 1, t6),
+                         ("T7_partial_tile_tail_mass", 1, t7)]
+                        if symmetric else []) + (
+                        [("T8_tb_wide_stride_guard_edges", 1, t8),
+                         ("T9_tb_k31_positional_tail_spike", 1, t9)]
+                        if (a_layout, b_layout, symmetric) == ("n", "t", False)
+                        else []) + (
+                        [("T10_tab_k31_positional_boundary", 1, t10),
+                         ("T11_tab_k30_tail_mass", 1, t11),
+                         ("T12_tab_k63_alternating", 1, t12)]
+                        if (a_layout, b_layout, symmetric) == ("t", "t", False)
+                        else [])
+
+
+def _mm_probe(a_layout, b_layout, symmetric=False):
+    def probe(torch):
+        torch.manual_seed(0)
+        m, k, n = (64, 128, 96) if not symmetric else (64, 64, 64)
+        m2, k2, n2 = (67, 131, 53) if not symmetric else (67, 67, 67)
+        def mk(mm, kk, nn):
+            A = torch.randn(*((kk, mm) if a_layout == "t" else (mm, kk)))
+            B = torch.randn(*((nn, kk) if b_layout == "t" else (kk, nn)))
+            if symmetric:
+                A = (A + A.T) / 2
+                B = (B + B.T) / 2
+            return [A, B]
+        return [("p_aligned", mk(m, k, n)), ("p_misaligned", mk(m2, k2, n2))]
+    return probe
+
+
+# ----------------------------------------------------------- min reduction
+
+MIN_CUDA = r"""
+#include <cuda_fp16.h>
+#include <math_constants.h>
+
+__global__ void min_dim1_kernel(const float* x, float* out, int B, int R, int C) {
+    int c = blockIdx.x * blockDim.x + threadIdx.x;
+    int b = blockIdx.y;
+    if (c >= C) return;
+    float best = CUDART_INF_F;
+    for (int r = 0; r < R; r++) {
+        best = fminf(best, x[(long long)b * R * C + (long long)r * C + c]);
+    }
+    out[(long long)b * C + c] = best;
+}
+"""
+
+
+def _red2d_launch(inputs, torch):
+    x = inputs[0]
+    B, R, C = x.shape
+    out = torch.zeros((B, C), device=x.device, dtype=x.dtype)
+    return out, ((C + 255) // 256, B, 1), (256, 1, 1), \
+        [(ctypes.c_int, B), (ctypes.c_int, R), (ctypes.c_int, C)]
+
+
+def _red_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(128, 4096, 4095)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(128, 4096, 4095)]
+
+    def t4(t):
+        _seeded(13)
+        x = _torch.rand(128, 4096, 4095)
+        x[:, 0, :] -= 100.0
+        x[:, -1, :] -= 100.0
+        return [x]
+
+    def t5(t):
+        _seeded(17)
+        return [_torch.rand(128, 4096, 4095) + 1.0]
+
+    def t6(t):
+        _seeded(19)
+        x = _torch.full((17, 257, 259), 64.0, dtype=_torch.float32)
+        x[:, 0::2, :] = 7.0
+        x[:, 1::4, :] = 7.0
+        x[:, -1, :] = 7.0
+        return [x]
+
+    def t7(t):
+        _seeded(23)
+        x = _torch.full((19, 33, 257), 1.0, dtype=_torch.float32)
+        x[:, 0::4, :] = 0.0
+        x[:, 2::4, :] = -0.0
+        x[:, -2, :] = -0.0
+        x[:, -1, :] = 0.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T4_edge_row_dip", 1, t4), ("T5_all_positive_shifted", 1, t5),
+            ("T6_duplicate_minima_ordered", 1, t6),
+            ("T7_signed_zero_ties", 1, t7)]
+
+
+def _red_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(4, 64, 256)]),
+            ("p_misaligned", [torch.randn(4, 64, 255)])]
+
+
+# ------------------------------------------------------------ L1 / L2 norm
+
+_NORM_TMPL = r"""
+#include <cuda_fp16.h>
+
+__global__ void {kname}(const float* x, float* out, int dim) {{
+    long long row = blockIdx.x;
+    const float* xr = x + row * dim;
+    float* outr = out + row * dim;
+    __shared__ float sdata[256];
+    int tid = threadIdx.x;
+    int iters = (dim + 255) / 256;
+    float local_sum = 0.0f;
+    for (int it = 0; it < iters; it++) {{
+        int i = it * 256 + tid;
+        if (i < dim) {{ local_sum += {term}; }}
+    }}
+    sdata[tid] = local_sum;
+    __syncthreads(); // sync-sum-store
+    for (int s = 128; s > 0; s >>= 1) {{ // sum-reduce
+        if (tid < s) {{ sdata[tid] = sdata[tid] + sdata[tid + s]; }}
+        __syncthreads();
+    }}
+    float denom = {denom};
+    __syncthreads(); // sync-sum-read
+    for (int it = 0; it < iters; it++) {{
+        int i = it * 256 + tid;
+        if (i < dim) {{ outr[i] = xr[i] / denom; }}
+    }}
+}}
+"""
+
+
+def _rownorm_launch(inputs, torch):
+    x = inputs[0]
+    out = torch.zeros_like(x)
+    return out, (x.shape[0], 1, 1), (256, 1, 1), [(ctypes.c_int, x.shape[1])]
+
+
+def _rownorm_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(32768, 65535)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(32768, 65535)]
+
+    def t4(t):
+        _seeded(13)
+        x = _torch.randn(512, 65535) * 0.01
+        x[:, -1] = 1000.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T4_tail_spike", 1, t4)]
+
+
+def _rownorm_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(4, 512)]),
+            ("p_misaligned", [torch.randn(3, 259)])]
+
+
+# ------------------------------------------------------------------- register
+
+def _register():
+    for name, spec in _ACTIVATIONS.items():
+        K.PROBLEMS[name] = dict(
+            kb_file=spec["kb"],
+            cuda=_EW_TMPL.format(kname=f"{name}_kernel", expr=spec["expr"]),
+            kernel_name=f"{name}_kernel", ref=spec["ref"],
+            launch=_ew_launch, suites=spec.get("suites", _ew_suites),
+            probe=_ew_probe)
+
+    mm_variants = {
+        "matmul_tb": dict(kb="17_Matmul_with_transposed_B.py",
+                          a="n", b="t", sym=False, m=2048, k=8192, n=4096,
+                          ref=lambda A, B: _torch.matmul(A, B.T)),
+        "matmul_tab": dict(kb="18_Matmul_with_transposed_both.py",
+                           a="t", b="t", sym=False, m=2048, k=8192, n=4096,
+                           ref=lambda A, B: _torch.matmul(A.T, B.T)),
+        "matmul_sym": dict(kb="13_Matmul_for_symmetric_matrices.py",
+                           a="n", b="n", sym=True, m=4096, k=4096, n=4096,
+                           ref=lambda A, B: _torch.matmul(A, B)),
+    }
+    for name, v in mm_variants.items():
+        a_load = _A_TRANS if v["a"] == "t" else _A_NORMAL
+        b_load = _B_TRANS if v["b"] == "t" else _B_NORMAL
+        K.PROBLEMS[name] = dict(
+            kb_file=v["kb"],
+            cuda=_MM_TMPL.format(kname=f"{name}_kernel",
+                                 a_load=a_load, b_load=b_load),
+            kernel_name=f"{name}_kernel", ref=v["ref"],
+            launch=_mm_launch(v["a"], v["b"]),
+            suites=_mm_var_suites(v["m"], v["k"], v["n"], v["a"], v["b"], v["sym"]),
+            probe=_mm_probe(v["a"], v["b"], v["sym"]))
+
+    K.PROBLEMS["min"] = dict(
+        kb_file="53_Min_reduction_over_a_dimension.py", cuda=MIN_CUDA,
+        kernel_name="min_dim1_kernel",
+        ref=lambda x: _torch.min(x, dim=1)[0],
+        launch=_red2d_launch, suites=_red_suites, probe=_red_probe)
+
+    K.PROBLEMS["l1norm"] = dict(
+        kb_file="38_L1Norm_.py",
+        cuda=_NORM_TMPL.format(kname="l1norm_kernel",
+                               term="fabsf(xr[i])", denom="sdata[0] / dim"),
+        kernel_name="l1norm_kernel",
+        ref=lambda x: x / _torch.mean(_torch.abs(x), dim=1, keepdim=True),
+        launch=_rownorm_launch, suites=_rownorm_suites, probe=_rownorm_probe)
+
+    K.PROBLEMS["l2norm"] = dict(
+        kb_file="39_L2Norm_.py",
+        cuda=_NORM_TMPL.format(kname="l2norm_kernel",
+                               term="xr[i] * xr[i]", denom="sqrtf(sdata[0])"),
+        kernel_name="l2norm_kernel",
+        ref=lambda x: x / _torch.norm(x, p=2, dim=1, keepdim=True),
+        launch=_rownorm_launch, suites=_rownorm_suites, probe=_rownorm_probe)
+
+
+_register()

pipeline/problems_ext.py

@@ -0,0 +1,672 @@
+"""Extended problem registry: 9 more KernelBench level1 problems.
+
+Each entry is registry-driven (no per-problem code in screen_mutants):
+  cuda         device-only CUDA source (mutation substrate)
+  kernel_name  __global__ symbol
+  ref          torch reference callable (must match the KB Model semantics)
+  launch       (inputs, torch) -> (out, grid, block, scalar ctypes args)
+  suites       () -> [(name, n_trials, builder)]
+  probe        (torch) -> [(name, [cpu tensors])]   tiny crash-quarantine inputs
+
+Import side effect: registers everything into kernels_def.PROBLEMS.
+"""
+import ctypes
+
+import torch as _torch  # only for type hints in refs; runtime torch passed in
+
+import kernels_def as K
+
+
+def _seeded(seed):
+    _torch.manual_seed(seed)
+
+
+# --------------------------------------------------------------- elementwise
+
+def _ew_launch(inputs, torch):
+    x = inputs[0]
+    out = torch.zeros_like(x)
+    n = x.numel()
+    return out, ((n + 255) // 256, 1, 1), (256, 1, 1), [(ctypes.c_longlong, n)]
+
+
+def _ew_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(8)
+        return [_torch.randn(127, 4097)]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T2_large", 1, t2), ("T3_misaligned", 1, t3)]
+
+
+def _leakyrelu_suites():
+    suites = _ew_suites()
+
+    def t4(t):
+        _seeded(26043)
+        x = _torch.full((31, 257), 1e-4)
+        x[:, -1] = 1e3
+        x.reshape(-1)[::256] = 2e3
+        return [x]
+
+    def t5(t):
+        _seeded(26044)
+        transition = _torch.tensor([
+            -2e-6, -1e-6, -5e-7, -1e-7, 0.0,
+            1e-7, 5e-7, 1e-6, 2e-6,
+        ])
+        return [transition.repeat(29, 29)[:, :257].contiguous()]
+
+    suites.extend([
+        ("T4_misaligned_tail_spikes", 1, t4),
+        ("T5_threshold_transition_grid", 1, t5),
+    ])
+    return suites
+
+
+def _gelu_suites():
+    suites = _ew_suites()
+
+    def t4(t):
+        _seeded(26041)
+        x = _torch.full((127, 4097), 70000.0)
+        x[:, -1] = 65520.0
+        return [x]
+
+    def t5(t):
+        _seeded(26042)
+        transition = _torch.tensor([
+            -4.0, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5,
+            0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0,
+        ])
+        return [transition.repeat(17, 18)[:, :257].contiguous()]
+
+    suites.extend([
+        ("T4_misaligned_fp16_overflow", 1, t4),
+        ("T5_erf_transition_grid", 1, t5),
+    ])
+    return suites
+
+
+def _sigmoid_suites():
+    suites = _ew_suites()
+
+    def t4(t):
+        _seeded(26043)
+        x = _torch.full((255, 257), 12.0)
+        x[:, ::2] = -12.0
+        x.reshape(-1)[-1] = 0.0
+        return [x]
+
+    def t5(t):
+        _seeded(26044)
+        transition = _torch.tensor([
+            -6.0, -4.0, -2.0, -1.0, -0.5, -0.125,
+            0.0, 0.125, 0.5, 1.0, 2.0, 4.0, 6.0,
+        ])
+        return [transition.repeat(129, 20)[:, :257].contiguous()]
+
+    suites.extend([
+        ("T4_misaligned_alternating_tail", 1, t4),
+        ("T5_fp16_transition_grid", 1, t5),
+    ])
+    return suites
+
+
+def _ew_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(32, 256)]),
+            ("p_misaligned", [torch.randn(7, 257)])]
+
+
+_EW_TMPL = r"""
+#include <cuda_fp16.h>
+
+__global__ void {kname}(const float* x, float* out, long long n) {{
+    long long idx = (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) {{ float val = x[idx]; out[idx] = {expr}; }}
+}}
+"""
+
+_ELEMENTWISE = {
+    "leakyrelu": dict(
+        kb="20_LeakyReLU.py",
+        expr="val > 0.0f ? val : 0.01f * val",
+        ref=lambda x: _torch.nn.functional.leaky_relu(x, 0.01),
+        suites=_leakyrelu_suites),
+    "gelu": dict(
+        kb="26_GELU_.py",
+        expr="0.5f * val * (1.0f + erff(val * 0.70710678f))",
+        ref=lambda x: _torch.nn.functional.gelu(x), suites=_gelu_suites),
+    "sigmoid": dict(
+        kb="21_Sigmoid.py",
+        expr="1.0f / (1.0f + expf(-val))",
+        ref=lambda x: _torch.sigmoid(x), suites=_sigmoid_suites),
+}
+
+# --------------------------------------------------------------- logsoftmax
+
+LOGSOFTMAX_CUDA = r"""
+#include <cuda_fp16.h>
+#include <math_constants.h>
+
+__global__ void logsoftmax_kernel(const float* x, float* out, int dim) {
+    long long row = blockIdx.x;
+    const float* xr = x + row * dim;
+    float* outr = out + row * dim;
+    __shared__ float sdata[256];
+    int tid = threadIdx.x;
+    int iters = (dim + 255) / 256;
+
+    float local_max = -CUDART_INF_F;
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { local_max = fmaxf(local_max, xr[i]); }
+    }
+    sdata[tid] = local_max;
+    __syncthreads(); // sync-max-store
+    for (int s = 128; s > 0; s >>= 1) { // max-reduce
+        if (tid < s) { sdata[tid] = fmaxf(sdata[tid], sdata[tid + s]); }
+        __syncthreads();
+    }
+    float row_max = sdata[0];
+    __syncthreads(); // sync-max-read
+
+    float local_sum = 0.0f;
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { local_sum += expf(xr[i] - row_max); }
+    }
+    sdata[tid] = local_sum;
+    __syncthreads(); // sync-sum-store
+    for (int s = 128; s > 0; s >>= 1) { // sum-reduce
+        if (tid < s) { sdata[tid] = sdata[tid] + sdata[tid + s]; }
+        __syncthreads();
+    }
+    float log_sum = logf(sdata[0]);
+    __syncthreads(); // sync-sum-read
+
+    for (int it = 0; it < iters; it++) {
+        int i = it * 256 + tid;
+        if (i < dim) { outr[i] = xr[i] - row_max - log_sum; }
+    }
+}
+"""
+
+
+def _lsm_launch(inputs, torch):
+    x = inputs[0]
+    out = torch.zeros_like(x)
+    return out, (x.shape[0], 1, 1), (256, 1, 1), [(ctypes.c_int, x.shape[1])]
+
+
+def _lsm_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(4096, 393216)]
+
+    def t2(t):
+        _seeded(9)
+        return [_torch.randn(4096, 393216) * 100.0]
+
+    def t3(t):
+        _seeded(11)
+        x = _torch.zeros(4096, 393216)
+        cols = _torch.randint(0, 393216, (4096,))
+        x[_torch.arange(4096), cols] = 20.0
+        return [x]
+
+    def t4(t):
+        _seeded(13)
+        x = _torch.randn(64, 4099) * 0.01
+        x[:, -1] = 20.0
+        return [x]
+
+    def t5(t):
+        _seeded(17)
+        x = _torch.ones(64, 513)
+        x[:, 0] = 3000.0
+        return [x]
+
+    def t6(t):
+        _seeded(19)
+        x = _torch.ones(64, 4097)
+        x[:, 1::2] = 3000.0
+        x[:, -1] = 6000.0
+        return [x]
+
+    def t7(t):
+        _seeded(23)
+        x = _torch.ones(64, 259)
+        x[:, 258] = 70000.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T2_large", 1, t2),
+            ("T3_spiky", 1, t3), ("T4_tail_spike_misaligned", 1, t4),
+            ("T5_first_iteration_mass", 1, t5),
+            ("T6_alternating_lane_magnitude", 1, t6),
+            ("T7_fp16_overflow_misaligned", 1, t7)]
+
+
+def _lsm_probe(torch):
+    torch.manual_seed(0)
+    x = torch.randn(16, 259) * 0.01
+    x[:, -1] = 20.0
+    return [("p_aligned", [torch.rand(16, 512)]),
+            ("p_large", [torch.randn(16, 512) * 100.0]),
+            ("p_misaligned_spike", [x])]
+
+
+# --------------------------------------------------------------- matmul MK/TA
+
+MATMUL_MK_CUDA = r"""
+#include <cuda_fp16.h>
+
+#define TILE 32
+
+__global__ void matmul_mk_kernel(const float* A, const float* B, float* C,
+                                 int M, int K, int N) {
+    __shared__ float As[TILE][TILE];
+    __shared__ float Bs[TILE][TILE];
+    int row = blockIdx.y * TILE + threadIdx.y;
+    int col = blockIdx.x * TILE + threadIdx.x;
+    float acc = 0.0f;
+    int numTiles = (K + TILE - 1) / TILE;
+    for (int t = 0; t < numTiles; t++) {
+        int a_col = t * TILE + threadIdx.x;
+        int b_row = t * TILE + threadIdx.y;
+        As[threadIdx.y][threadIdx.x] = (row < M && a_col < K) ? A[(long long)row * K + a_col] : 0.0f;
+        Bs[threadIdx.y][threadIdx.x] = (b_row < K && col < N) ? B[(long long)b_row * N + col] : 0.0f;
+        __syncthreads(); // sync-after-load
+        for (int k = 0; k < TILE; k++) {
+            acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];
+        }
+        __syncthreads(); // sync-after-compute
+    }
+    if (row < M && col < N) { C[(long long)row * N + col] = acc; }
+}
+"""
+
+MATMUL_TA_CUDA = r"""
+#include <cuda_fp16.h>
+
+#define TILE 32
+
+__global__ void matmul_ta_kernel(const float* A, const float* B, float* C,
+                                 int M, int K, int N) {
+    __shared__ float As[TILE][TILE];
+    __shared__ float Bs[TILE][TILE];
+    int row = blockIdx.y * TILE + threadIdx.y;
+    int col = blockIdx.x * TILE + threadIdx.x;
+    float acc = 0.0f;
+    int numTiles = (K + TILE - 1) / TILE;
+    for (int t = 0; t < numTiles; t++) {
+        int a_k = t * TILE + threadIdx.x;
+        int b_k = t * TILE + threadIdx.y;
+        As[threadIdx.y][threadIdx.x] = (a_k < K && row < M) ? A[(long long)a_k * M + row] : 0.0f;
+        Bs[threadIdx.y][threadIdx.x] = (b_k < K && col < N) ? B[(long long)b_k * N + col] : 0.0f;
+        __syncthreads(); // sync-after-load
+        for (int k = 0; k < TILE; k++) {
+            acc += As[threadIdx.y][k] * Bs[k][threadIdx.x];
+        }
+        __syncthreads(); // sync-after-compute
+    }
+    if (row < M && col < N) { C[(long long)row * N + col] = acc; }
+}
+"""
+
+
+def _mm_launch_mk(inputs, torch):
+    A, B = inputs
+    M, Kd = A.shape
+    N = B.shape[1]
+    out = torch.zeros((M, N), device=A.device, dtype=A.dtype)
+    return out, ((N + 31) // 32, (M + 31) // 32, 1), (32, 32, 1), \
+        [(ctypes.c_int, M), (ctypes.c_int, Kd), (ctypes.c_int, N)]
+
+
+def _mm_launch_ta(inputs, torch):
+    A, B = inputs
+    Kd, M = A.shape
+    N = B.shape[1]
+    out = torch.zeros((M, N), device=A.device, dtype=A.dtype)
+    return out, ((N + 31) // 32, (M + 31) // 32, 1), (32, 32, 1), \
+        [(ctypes.c_int, M), (ctypes.c_int, Kd), (ctypes.c_int, N)]
+
+
+def _mm_suites(shapes):
+    (m, k, n), (m3, k3, n3), transposed = shapes
+
+    def a_shape(M, Kd):
+        return (Kd, M) if transposed else (M, Kd)
+
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(*a_shape(m, k)), _torch.rand(k, n)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(*a_shape(m, k)), _torch.randn(k, n)]
+
+    def t2(t):
+        # positive-only large values: kills fp16/precision mutants via overflow
+        # without triggering legitimate fp32 accumulation-order variance
+        # (signed large values false-kill correct kernels at K=8192, see sum/T2)
+        _seeded(9)
+        return [_torch.rand(*a_shape(m, k)) * 50.0, _torch.rand(k, n) * 50.0]
+
+    def t3(t):
+        _seeded(11)
+        return [_torch.randn(*a_shape(m3, k3)), _torch.randn(k3, n3)]
+
+    def t4(t):
+        _seeded(13)
+        A = _torch.rand(*a_shape(m, k))
+        B = _torch.rand(k, n)
+        if transposed:
+            A[-32:, :] = 100.0
+        else:
+            A[:, -32:] = 100.0
+        B[-32:, :] = 100.0
+        return [A, B]
+
+    suites = [("T0_original", 5, t0), ("T1_signed", 1, t1), ("T2_large", 1, t2),
+              ("T3_misaligned", 1, t3), ("T4_last_tile_spike", 1, t4)]
+    if not transposed:
+        return suites
+
+    def t5(t):
+        # Every logical dimension ends one lane before a tile boundary.  The
+        # positive ramps make accidental boundary reads distinct and visible.
+        _seeded(101)
+        M, Kd, N = 1023, 31, 1023
+        A = (_torch.arange(Kd)[:, None] + 1.0) * 0.25
+        A = A.expand(Kd, M).clone()
+        A += (_torch.arange(M)[None, :] % 17) * 0.01
+        B = (_torch.arange(Kd)[:, None] + 1.0) * 0.125
+        B = B.expand(Kd, N).clone()
+        B += (_torch.arange(N)[None, :] % 19) * 0.01
+        return [A, B]
+
+    def t6(t):
+        # A one-element K tail puts the padding guard immediately beside a
+        # dominant, same-sign term while M and N also have partial blocks.
+        _seeded(103)
+        M, Kd, N = 95, 65, 93
+        A = _torch.full((Kd, M), 1.0e-3)
+        B = _torch.full((Kd, N), 1.0e-3)
+        A[-1, :] = 200.0 + (_torch.arange(M) % 11) * 0.25
+        B[-1, :] = 150.0 + (_torch.arange(N) % 13) * 0.25
+        return [A, B]
+
+    def t7(t):
+        # K == TILE - 1 directly exercises the mutated TILE - 1 tile-count
+        # expression; alternating positive magnitudes expose stray reads.
+        _seeded(107)
+        M, Kd, N = 63, 31, 61
+        scale = _torch.where(_torch.arange(Kd) % 2 == 0, 1.0e-3, 100.0)
+        A = scale[:, None].expand(Kd, M).clone()
+        B = scale[:, None].expand(Kd, N).clone()
+        A += (_torch.arange(M)[None, :] % 7) * 0.01
+        B += (_torch.arange(N)[None, :] % 5) * 0.01
+        return [A, B]
+
+    suites.extend([("T5_boundary_positional_ramps", 1, t5),
+                   ("T6_single_tail_mass_spike", 1, t6),
+                   ("T7_tile_minus1_alternating", 1, t7)])
+    return suites
+
+
+def _mm_probe(transposed):
+    def probe(torch):
+        torch.manual_seed(0)
+        def a_shape(M, Kd):
+            return (Kd, M) if transposed else (M, Kd)
+        return [("p_aligned", [torch.rand(*a_shape(64, 128)), torch.rand(128, 96)]),
+                ("p_misaligned", [torch.randn(*a_shape(67, 131)), torch.randn(131, 53)])]
+    return probe
+
+
+# --------------------------------------------------------- mean / max over dim1
+
+MEAN_CUDA = r"""
+#include <cuda_fp16.h>
+
+__global__ void mean_dim1_kernel(const float* x, float* out, int B, int R, int C) {
+    int c = blockIdx.x * blockDim.x + threadIdx.x;
+    int b = blockIdx.y;
+    if (c >= C) return;
+    float acc = 0.0f;
+    for (int r = 0; r < R; r++) {
+        acc += x[(long long)b * R * C + (long long)r * C + c];
+    }
+    out[(long long)b * C + c] = acc / R;
+}
+"""
+
+MAX_CUDA = r"""
+#include <cuda_fp16.h>
+#include <math_constants.h>
+
+__global__ void max_dim1_kernel(const float* x, float* out, int B, int R, int C) {
+    int c = blockIdx.x * blockDim.x + threadIdx.x;
+    int b = blockIdx.y;
+    if (c >= C) return;
+    float best = -CUDART_INF_F;
+    for (int r = 0; r < R; r++) {
+        best = fmaxf(best, x[(long long)b * R * C + (long long)r * C + c]);
+    }
+    out[(long long)b * C + c] = best;
+}
+"""
+
+
+def _red2d_launch(inputs, torch):
+    x = inputs[0]
+    B, R, C = x.shape
+    out = torch.zeros((B, C), device=x.device, dtype=x.dtype)
+    return out, ((C + 255) // 256, B, 1), (256, 1, 1), \
+        [(ctypes.c_int, B), (ctypes.c_int, R), (ctypes.c_int, C)]
+
+
+def _red_suites(extra_negative):
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(128, 4096, 4095)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(128, 4096, 4095)]
+
+    def t4(t):
+        _seeded(13)
+        x = _torch.rand(128, 4096, 4095)
+        x[:, 0, :] += 100.0
+        x[:, -1, :] += 100.0
+        return [x]
+
+    suites = [("T0_original", 5, t0), ("T1_signed", 1, t1),
+              ("T4_edge_row_spike", 1, t4)]
+    if extra_negative:
+        def t5(t):
+            _seeded(17)
+            return [-_torch.rand(128, 4096, 4095) - 1.0]
+        suites.append(("T5_all_negative", 1, t5))
+
+        def t6(t):
+            _seeded(26045)
+            x = _torch.full((17, 257, 259), 32.0)
+            x[:, ::2, :] = 2048.0
+            x[:, 1::2, :] = 2048.0
+            return [x]
+
+        def t7(t):
+            _seeded(26046)
+            x = _torch.full((19, 129, 263), -64.0)
+            x[:, 0, :] = 1536.0
+            x[:, 64, :] = 1536.0
+            x[:, -1, :] = 1536.0
+            return [x]
+
+        def t8(t):
+            _seeded(26047)
+            x = _torch.full((23, 65, 257), -0.0)
+            x[:, 1::2, :] = 0.0
+            return [x]
+
+        suites.extend([
+            ("T6_alternating_duplicate_maxima", 1, t6),
+            ("T7_first_middle_last_ties", 1, t7),
+            ("T8_signed_zero_tie_order", 1, t8),
+        ])
+    return suites
+
+
+def _red_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(4, 64, 256)]),
+            ("p_misaligned", [torch.randn(4, 64, 255)])]
+
+
+# --------------------------------------------------------------------- rmsnorm
+
+RMSNORM_CUDA = r"""
+#include <cuda_fp16.h>
+
+__global__ void rmsnorm_kernel(const float* x, float* out, int B, int F, int S) {
+    int s = blockIdx.x * blockDim.x + threadIdx.x;
+    int b = blockIdx.y;
+    if (s >= S) return;
+    float sq = 0.0f;
+    for (int f = 0; f < F; f++) {
+        float v = x[(long long)b * F * S + (long long)f * S + s];
+        sq += v * v;
+    }
+    float rms = sqrtf(sq / F + 1e-5f);
+    for (int f = 0; f < F; f++) {
+        long long i = (long long)b * F * S + (long long)f * S + s;
+        out[i] = x[i] / rms;
+    }
+}
+"""
+
+
+def _rms_launch(inputs, torch):
+    x = inputs[0]
+    B, F, D1, D2 = x.shape
+    S = D1 * D2
+    out = torch.zeros_like(x)
+    return out, ((S + 255) // 256, B, 1), (256, 1, 1), \
+        [(ctypes.c_int, B), (ctypes.c_int, F), (ctypes.c_int, S)]
+
+
+def _rms_ref(x):
+    rms = _torch.sqrt(_torch.mean(x ** 2, dim=1, keepdim=True) + 1e-5)
+    return x / rms
+
+
+def _rms_suites():
+    def t0(t):
+        _seeded(1000 + t)
+        return [_torch.rand(112, 64, 512, 512)]
+
+    def t1(t):
+        _seeded(7)
+        return [_torch.randn(112, 64, 512, 512)]
+
+    def t3(t):
+        _seeded(11)
+        return [_torch.randn(7, 13, 33, 65)]
+
+    def t4(t):
+        _seeded(13)
+        x = _torch.rand(112, 64, 512, 512)
+        x[:, 0, :, :] += 50.0
+        x[:, -1, :, :] += 50.0
+        return [x]
+
+    return [("T0_original", 5, t0), ("T1_signed", 1, t1),
+            ("T3_misaligned", 1, t3), ("T4_feature_spike", 1, t4)]
+
+
+def _rms_probe(torch):
+    torch.manual_seed(0)
+    return [("p_aligned", [torch.rand(2, 8, 16, 16)]),
+            ("p_misaligned", [torch.randn(3, 7, 13, 15)])]
+
+
+# ------------------------------------------------------------------- register
+
+def _register():
+    for name, spec in _ELEMENTWISE.items():
+        K.PROBLEMS[name] = dict(
+            kb_file=spec["kb"],
+            cuda=_EW_TMPL.format(kname=f"{name}_kernel", expr=spec["expr"]),
+            kernel_name=f"{name}_kernel", ref=spec["ref"],
+            launch=_ew_launch, suites=spec.get("suites", _ew_suites), probe=_ew_probe)
+
+    K.PROBLEMS["logsoftmax"] = dict(
+        kb_file="24_LogSoftmax.py", cuda=LOGSOFTMAX_CUDA,
+        kernel_name="logsoftmax_kernel",
+        ref=lambda x: _torch.log_softmax(x, dim=1),
+        launch=_lsm_launch, suites=_lsm_suites, probe=_lsm_probe)
+
+    K.PROBLEMS["matmul_mk"] = dict(
+        kb_file="2_Standard_matrix_multiplication_.py", cuda=MATMUL_MK_CUDA,
+        kernel_name="matmul_mk_kernel",
+        ref=lambda A, B: _torch.matmul(A, B),
+        launch=_mm_launch_mk,
+        suites=lambda: _mm_suites(((2048, 8192, 4096), (515, 1027, 259), False)),
+        probe=_mm_probe(False))
+
+    K.PROBLEMS["matmul_ta"] = dict(
+        kb_file="16_Matmul_with_transposed_A.py", cuda=MATMUL_TA_CUDA,
+        kernel_name="matmul_ta_kernel",
+        ref=lambda A, B: _torch.matmul(A.T, B),
+        launch=_mm_launch_ta,
+        suites=lambda: _mm_suites(((2048, 8192, 4096), (515, 1027, 259), True)),
+        probe=_mm_probe(True))
+
+    K.PROBLEMS["mean"] = dict(
+        kb_file="48_Mean_reduction_over_a_dimension.py", cuda=MEAN_CUDA,
+        kernel_name="mean_dim1_kernel",
+        ref=lambda x: _torch.mean(x, dim=1),
+        launch=_red2d_launch, suites=lambda: _red_suites(False), probe=_red_probe)
+
+    K.PROBLEMS["max"] = dict(
+        kb_file="49_Max_reduction_over_a_dimension.py", cuda=MAX_CUDA,
+        kernel_name="max_dim1_kernel",
+        ref=lambda x: _torch.max(x, dim=1)[0],
+        launch=_red2d_launch, suites=lambda: _red_suites(True), probe=_red_probe)
+
+    K.PROBLEMS["rmsnorm"] = dict(
+        kb_file="36_RMSNorm_.py", cuda=RMSNORM_CUDA,
+        kernel_name="rmsnorm_kernel", ref=_rms_ref,
+        launch=_rms_launch, suites=_rms_suites, probe=_rms_probe)
+
+
+_register()
+
+try:
+    import problems_batch2  # noqa: F401  (registers batch-2 substrates)
+except ImportError:
+    pass
+
+try:
+    import candidates_loader as _cl
+    _cl.load_accepted()
+except Exception as _e:
+    import sys as _sys
+    print(f"[candidates] loader itself failed: {_e}", file=_sys.stderr, flush=True)

pipeline/recheck_nowitness.py

@@ -0,0 +1,220 @@
+"""Re-test no-witness mutants against the newly written killer suites.
+
+Screening recorded each mutant's class once; mutants classed `no_witness`
+survived every suite that existed AT THAT TIME. The witness hunt has since
+appended new targeted suites, so those verdicts are stale. This runner
+re-evaluates only the no-witness mutants, only on suites that are new
+relative to the recorded verdict, and rewrites the class to `high_value`
+(with the witness) when one of them kills.
+
+Also re-checks the CORRECT kernel on every new suite: a suite that rejects
+the correct implementation is invalid and is reported (its kills don't count).
+
+Journal: results/recheck_<problem>.jsonl  (resume-safe)
+Usage: python3 recheck_nowitness.py [--worker P]
+"""
+import ctypes
+import json
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import kernels_def as K            # noqa: E402
+import problems_ext                # noqa: E402,F401
+import candidates_loader           # noqa: E402
+import mutator                     # noqa: E402
+from nvrtc_tce import externc, compile_ptx, device_source  # noqa: E402
+from screen_mutants import (NvrtcKernel, compare, install_watchdog,  # noqa: E402
+                            kernel_name, pet_watchdog, ref_fn_for)
+
+candidates_loader.load_accepted()
+BASE_SUITES = {"T0_original", "T1_signed", "T2_large", "T3_misaligned"}
+SHARD_ID = int(os.environ.get("SHARD_ID", "0"))
+SHARD_N = int(os.environ.get("SHARD_N", "1"))
+
+
+def my_problems():
+    import hashlib
+    return [p for p in K.PROBLEMS
+            if int(hashlib.md5(p.encode()).hexdigest()[:8], 16) % SHARD_N == SHARD_ID]
+
+
+def nowitness_ids(problem):
+    path = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+    if not os.path.exists(path):
+        return set()
+    ids = set()
+    for line in open(path):
+        r = json.loads(line)
+        if r["type"] == "RESULT":
+            if r["cls"] == "no_witness":
+                ids.add(r["id"])
+            else:
+                ids.discard(r["id"])
+    return ids
+
+
+def worker(problem):
+    install_watchdog()
+    import torch
+    ids = nowitness_ids(problem)
+    if not ids:
+        return
+    suites = [(n, b) for n, _, b in K.PROBLEMS[problem]["suites"]()
+              if n not in BASE_SUITES]
+    if not suites:
+        return
+
+    jpath = os.path.join(RESULTS, f"recheck_{problem}.jsonl")
+    done, pending = set(), None
+    if os.path.exists(jpath):
+        for line in open(jpath):
+            r = json.loads(line)
+            if r["type"] == "RSTART":
+                pending = (r["id"], r["suite"])
+            elif r["type"] == "RCELL":
+                done.add((r["id"], r["suite"]))
+                pending = None
+    journal = open(jpath, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    if pending is not None:
+        emit(type="RCELL", id=pending[0], suite=pending[1],
+             outcome="killed", reason="crash")
+        done.add(pending)
+
+    _ms = list(mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"])))
+    _cap = int(os.environ.get("MUTANT_CAP", "0"))
+    if _cap:
+        _ms = mutator.stratified_sample(_ms, _cap)   # same sample as screening
+    mutants = {m["id"]: m for m in _ms}
+    ref_fn = ref_fn_for(problem)
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    correct_src = externc(device_source(K.PROBLEMS[problem]["cuda"]))
+    try:
+        ptx_cache = {"__correct__": compile_ptx(correct_src, "c.cu")}
+    except RuntimeError:
+        emit(type="RDONE", problem=problem, skipped="correct_compile_fail")
+        journal.close()
+        return
+
+    for sname, builder in suites:
+        # validity gate first: the suite must not reject the correct kernel
+        gpu_in = [t.cuda() for t in builder(0)]
+        with torch.no_grad():
+            ref = ref_fn(*gpu_in)      # keep on GPU: CPU round-trips dominated runtime
+        try:
+            kern = NvrtcKernel(cuda_lib, ptx_cache["__correct__"], kernel_name(problem))
+        except RuntimeError as e:
+            emit(type="VALID", suite=sname, valid=False, detail=f"load_fail {e}")
+            del gpu_in, ref
+            torch.cuda.empty_cache()
+            continue
+        pet_watchdog()
+        out = kern.launch(problem, gpu_in, torch)
+        valid = compare(ref, out, torch) == "survived"
+        kern.unload()
+        del out
+        emit(type="VALID", suite=sname, valid=valid)
+        if not valid:
+            del gpu_in, ref
+            torch.cuda.empty_cache()
+            continue
+
+        for mid in sorted(ids):
+            if (mid, sname) in done or mid not in mutants:
+                continue
+            if mid not in ptx_cache:
+                src = externc(mutants[mid]["src"])
+                try:
+                    ptx_cache[mid] = compile_ptx(src, "m.cu")
+                except RuntimeError:
+                    continue
+            emit(type="RSTART", id=mid, suite=sname)
+            try:
+                kern = NvrtcKernel(cuda_lib, ptx_cache[mid], kernel_name(problem))
+            except RuntimeError as e:
+                emit(type="RCELL", id=mid, suite=sname, outcome="load_fail",
+                     detail=str(e)[:50])
+                continue
+            try:
+                pet_watchdog()
+                out = kern.launch(problem, gpu_in, torch)
+                r = compare(ref, out, torch)
+                del out
+                kern.unload()
+            except RuntimeError as e:
+                emit(type="RCELL", id=mid, suite=sname, outcome="killed",
+                     reason="crash", detail=str(e)[:60])
+                journal.close()
+                sys.exit(3)
+            emit(type="RCELL", id=mid, suite=sname,
+                 outcome="survived" if r == "survived" else "killed")
+        del gpu_in, ref
+        torch.cuda.empty_cache()
+    emit(type="RDONE", problem=problem)
+    journal.close()
+
+
+def summary():
+    import collections
+    conv = collections.Counter()
+    invalid = []
+    for f in os.listdir(RESULTS):
+        if not f.startswith("recheck_"):
+            continue
+        p = f[8:-6]
+        killed = set()
+        for line in open(os.path.join(RESULTS, f)):
+            r = json.loads(line)
+            if r["type"] == "RCELL" and r["outcome"] == "killed":
+                killed.add(r["id"])
+            elif r["type"] == "VALID" and not r["valid"]:
+                invalid.append((p, r["suite"]))
+        conv[p] = len(killed)
+    tot_before = sum(len(nowitness_ids(p)) for p in conv)
+    print(f"no-witness mutants re-tested: {tot_before}")
+    print(f"newly killed (-> high_value): {sum(conv.values())}")
+    if tot_before:
+        print(f"conversion rate: {sum(conv.values())/tot_before:.1%}")
+    print(f"invalid suites (reject correct kernel): {len(invalid)}")
+    for p, s in invalid[:10]:
+        print(f"   {p} / {s}")
+    for p, n in conv.most_common(10):
+        print(f"   {p:32s} +{n}")
+
+
+def orchestrate():
+    for problem in my_problems():
+        if not nowitness_ids(problem):
+            continue
+        for attempt in range(40):
+            try:
+                rc = subprocess.run([sys.executable, __file__, "--worker", problem],
+                                    timeout=2400).returncode
+            except subprocess.TimeoutExpired:
+                print(f"[recheck] {problem}: TIMEOUT", flush=True)
+                rc = 0
+            if rc == 0:
+                break
+        print(f"[recheck] {problem}: done", flush=True)
+    summary()
+    print("[recheck] ALL DONE", flush=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2 and sys.argv[1] == "--worker":
+        worker(sys.argv[2])
+    elif len(sys.argv) > 1 and sys.argv[1] == "--summary":
+        summary()
+    else:
+        orchestrate()

pipeline/sanitizer_probe.py

@@ -0,0 +1,29 @@
+"""Run one mutant once on a small input (for compute-sanitizer memcheck).
+Usage: sanitizer_probe.py <problem> <mutant_id>"""
+import ctypes
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+import torch  # noqa: E402
+
+import kernels_def as K  # noqa: E402
+import problems_ext      # noqa: E402,F401
+import mutator           # noqa: E402
+from adjudicate import rand_inputs  # noqa: E402
+from nvrtc_tce import compile_ptx, device_source  # noqa: E402
+from screen_mutants import NvrtcKernel, kernel_name  # noqa: E402
+
+problem, mid = sys.argv[1], sys.argv[2]
+m = {x["id"]: x for x in
+     mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"]))}[mid]
+src = m["src"].replace("__global__ void", 'extern "C" __global__ void')
+torch.zeros(1, device="cuda")
+kern = NvrtcKernel(ctypes.CDLL("libcuda.so.1"), compile_ptx(src, "m.cu"),
+                   kernel_name(problem))
+gpu_in = [x.cuda() for x in rand_inputs(problem, 0, torch)]
+out = kern.launch(problem, gpu_in, torch)
+torch.cuda.synchronize()
+print("probe done", out.shape)

pipeline/screen_mutants.py

@@ -0,0 +1,534 @@
+"""Screening pipeline: universal-mutator mutants -> NVRTC compile -> TCE dedup
+-> GPU kill screening -> value classification.
+
+Classification per mutant:
+  compile_fail      nvrtc rejected it (discarded, that's the filter working)
+  tce_equiv_correct PTX identical to correct kernel (host-only or no-op)
+  tce_dup           PTX identical to an earlier mutant (behavioral duplicate)
+  killed_by_T0      original KernelBench inputs already catch it (low value)
+  high_value        survives T0, killed by a targeted input (witness recorded)
+  no_witness        survives everything we have (equivalent / oracle-blind)
+
+Runs entirely on the NVRTC + driver-API fast path (no torch extensions).
+Orchestrator mode (default) spawns one worker subprocess per problem and
+respawns on CUDA-poisoned exits; worker mode (--worker PROB) does the work.
+
+T0 is run with 2 seeds instead of KernelBench's 5: survival was shown to be
+deterministic w.r.t. reseeding in the validation experiment.
+"""
+import ctypes
+import json
+import os
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+RESULTS = os.path.join(HERE, "results")
+
+import kernels_def as K            # noqa: E402
+import problems_ext                # noqa: E402,F401  (registers extra problems)
+import mutator                     # noqa: E402
+from nvrtc_tce import externc, compile_ptx, device_source, normalized_hash  # noqa: E402
+
+ATOL = RTOL = 1e-2
+MUTANT_CAP = int(os.environ.get("MUTANT_CAP", "0"))  # 0 = no cap
+PROBLEM_TIMEOUT = 1800  # wall-clock cap per problem per attempt
+# Shard support: SHARD_ID/SHARD_N split problems across independent processes
+# (each on its own GPU). Journals are per-problem files, so shards never
+# contend; a crash in one shard cannot stall the others.
+SHARD_ID = int(os.environ.get("SHARD_ID", "0"))
+SHARD_N = int(os.environ.get("SHARD_N", "1"))
+
+
+STEAL = os.environ.get("STEAL", "0") == "1"
+
+
+def _has_done_marker(problem):
+    path = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+    if not os.path.exists(path):
+        return False
+    txt = open(path).read()
+    # PROBE_DONE means only the quarantine phase finished; treating it as
+    # complete made every gave-up-era problem invisible to STEAL mode
+    return '"DONE"' in txt
+
+
+def my_problems():
+    """Own shard's slice; in STEAL mode, instead take any problem that has no
+    completion marker yet (idle GPUs help finish the tail). A claim file makes
+    two stealers unlikely to pick the same problem; if they do, journals still
+    dedupe by mutant id so the work is merely repeated, never corrupted."""
+    import hashlib
+    if STEAL:
+        out = []
+        for p in K.PROBLEMS:
+            if _has_done_marker(p):
+                continue
+            claim = os.path.join(RESULTS, f".claim_{p}")
+            # a stale claim from a crashed run must not hide the problem
+            # forever: reclaim anything older than 45 minutes
+            try:
+                if time.time() - os.path.getmtime(claim) > 2700:
+                    os.unlink(claim)
+            except OSError:
+                pass
+            try:
+                fd = os.open(claim, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                os.write(fd, str(SHARD_ID).encode())
+                os.close(fd)
+                out.append(p)
+            except FileExistsError:
+                continue
+        return out
+    out = []
+    for p in K.PROBLEMS:
+        h = int(hashlib.md5(p.encode()).hexdigest()[:8], 16)
+        if h % SHARD_N == SHARD_ID:
+            out.append(p)
+    return out
+
+REF_FN = {
+    "relu":    lambda x: __import__("torch").relu(x),
+    "matmul":  lambda a, b: __import__("torch").matmul(a, b),
+    "softmax": lambda x: __import__("torch").softmax(x, dim=1),
+    "sum":     lambda x: __import__("torch").sum(x, dim=1, keepdim=True),
+}
+KERNEL_NAME = {"relu": "relu_kernel", "matmul": "matmul_kernel",
+               "softmax": "softmax_kernel", "sum": "sum_dim1_kernel"}
+
+
+def probe_suites(problem, torch):
+    """Tiny inputs for crash quarantine. First entry MUST be T0-like
+    (aligned shape, rand[0,1)) — a crash there predicts a crash on real T0.
+    Values are never compared in the probe; only crash/no-crash matters."""
+    reg = K.PROBLEMS[problem].get("probe")
+    if reg is not None:
+        return reg(torch)
+    torch.manual_seed(0)
+    if problem == "relu":
+        return [("p_aligned", [torch.rand(32, 256)]),
+                ("p_misaligned", [torch.randn(7, 257)])]
+    if problem == "matmul":
+        return [("p_aligned", [torch.rand(128, 128), torch.rand(128, 128)]),
+                ("p_misaligned", [torch.randn(67, 67), torch.randn(67, 67)])]
+    if problem == "softmax":
+        x = torch.randn(16, 259) * 0.01
+        x[:, -1] = 20.0
+        return [("p_aligned", [torch.rand(16, 512)]),
+                ("p_large", [torch.randn(16, 512) * 100.0]),
+                ("p_misaligned_spike", [x])]
+    if problem == "sum":
+        return [("p_aligned", [torch.rand(4, 64, 256)]),
+                ("p_misaligned", [torch.randn(4, 64, 255)])]
+    raise ValueError(problem)
+
+
+_WD = {"deadline": None}
+
+
+def install_watchdog(seconds=180):
+    """Thread-based watchdog. A mutated kernel can spin forever; the process
+    then blocks inside cuLaunchKernel/synchronize, which are C calls. Python
+    signal handlers CANNOT run while the main thread is inside such a call
+    (the handler is deferred until the call returns, which never happens), so
+    signal.alarm is useless here. A daemon thread works because ctypes/torch
+    release the GIL around those calls, letting the watchdog run and hard-exit.
+    The orchestrator respawns us; the dangling START/PSTART journal entry is
+    recorded as a kill, which is the correct verdict for a non-terminating
+    kernel."""
+    import threading
+    import time as _time
+
+    def _loop():
+        while True:
+            _time.sleep(5)
+            dl = _WD["deadline"]
+            if dl is not None and _time.monotonic() > dl:
+                os.write(2, b"WATCHDOG: kernel hang, aborting process\n")
+                os._exit(3)
+
+    _WD["deadline"] = None
+    t = threading.Thread(target=_loop, daemon=True)
+    t.start()
+
+
+def pet_watchdog(seconds=180):
+    import time as _time
+    _WD["deadline"] = _time.monotonic() + seconds
+
+
+def kernel_name(problem):
+    return K.PROBLEMS[problem].get("kernel_name") or KERNEL_NAME[problem]
+
+
+def ref_fn_for(problem):
+    return K.PROBLEMS[problem].get("ref") or REF_FN[problem]
+
+
+def launch_spec(problem, inputs, torch):
+    """Return (out_tensor, grid(3), block(3), scalar_args:list[(ctype, value)])."""
+    reg = K.PROBLEMS[problem].get("launch")
+    if reg is not None:
+        return reg(inputs, torch)
+    if problem == "relu":
+        x = inputs[0]
+        out = torch.zeros_like(x)
+        n = x.numel()
+        return out, ((n + 255) // 256, 1, 1), (256, 1, 1), [(ctypes.c_longlong, n)]
+    if problem == "matmul":
+        A, B = inputs
+        N = A.shape[0]
+        out = torch.zeros((N, N), device=A.device, dtype=A.dtype)
+        g = (N + 31) // 32
+        return out, (g, g, 1), (32, 32, 1), [(ctypes.c_int, N)]
+    if problem == "softmax":
+        x = inputs[0]
+        out = torch.zeros_like(x)
+        return out, (x.shape[0], 1, 1), (256, 1, 1), [(ctypes.c_int, x.shape[1])]
+    if problem == "sum":
+        x = inputs[0]
+        B, R, C = x.shape
+        out = torch.zeros((B, 1, C), device=x.device, dtype=x.dtype)
+        return out, ((C + 255) // 256, B, 1), (256, 1, 1), \
+            [(ctypes.c_int, B), (ctypes.c_int, R), (ctypes.c_int, C)]
+    raise ValueError(problem)
+
+
+class NvrtcKernel:
+    def __init__(self, cuda_lib, ptx, kname):
+        self.cuda = cuda_lib
+        self.module = ctypes.c_void_p()
+        rc = self.cuda.cuModuleLoadData(ctypes.byref(self.module), (ptx.encode() if isinstance(ptx, str) else ptx))
+        if rc != 0:
+            raise RuntimeError(f"cuModuleLoadData rc={rc}")
+        # multi-kernel substrates (level3 architectures) expose one __global__
+        # per layer, so a mutation lands in a specific layer and we can measure
+        # how far a fault propagates through depth.
+        self.funcs = {}
+        names = kname if isinstance(kname, (list, tuple)) else [kname]
+        for nm in names:
+            f = ctypes.c_void_p()
+            rc = self.cuda.cuModuleGetFunction(ctypes.byref(f), self.module,
+                                               nm.encode())
+            if rc != 0:
+                raise RuntimeError(f"cuModuleGetFunction({nm}) rc={rc}")
+            self.funcs[nm] = f
+        self.func = self.funcs[names[0]]
+
+    def _raw_launch(self, func, grid, block, tensors, scalars, torch):
+        holders = [ctypes.c_void_p(t.data_ptr()) for t in tensors]
+        for ct, v in scalars:
+            holders.append(ct(v))
+        args = (ctypes.c_void_p * len(holders))(
+            *[ctypes.cast(ctypes.byref(h), ctypes.c_void_p) for h in holders])
+        rc = self.cuda.cuLaunchKernel(func, *grid, *block, 0, None, args, None)
+        if rc != 0:
+            raise RuntimeError(f"cuLaunchKernel rc={rc}")
+
+    def launch(self, problem, inputs, torch):
+        spec = launch_spec(problem, inputs, torch)
+        if isinstance(spec, dict):          # multi-kernel pipeline
+            for step in spec["seq"]:
+                fname, grid, block, tensors, scalars = step
+                self._raw_launch(self.funcs[fname], grid, block, tensors,
+                                 scalars, torch)
+            torch.cuda.synchronize()
+            return spec["out"]
+        out, grid, block, scalars = spec
+        holders = []
+        for t in inputs:
+            holders.append(ctypes.c_void_p(t.data_ptr()))
+        holders.append(ctypes.c_void_p(out.data_ptr()))
+        for ct, v in scalars:
+            holders.append(ct(v))
+        args = (ctypes.c_void_p * len(holders))(
+            *[ctypes.cast(ctypes.byref(h), ctypes.c_void_p) for h in holders])
+        rc = self.cuda.cuLaunchKernel(self.func, *grid, *block, 0, None, args, None)
+        if rc != 0:
+            raise RuntimeError(f"cuLaunchKernel rc={rc}")
+        torch.cuda.synchronize()
+        return out
+
+    def unload(self):
+        self.cuda.cuModuleUnload(self.module)
+
+
+def compare(ref, out, torch):
+    if out.shape != ref.shape:
+        return "shape_mismatch"
+    if torch.allclose(ref, out, atol=ATOL, rtol=RTOL):
+        return "survived"
+    return "value_mismatch"
+
+
+def load_journal(journal_path):
+    """Returns (done RESULTs, probe outcomes, dangling START, dangling PSTART)."""
+    done, probes, pend_s, pend_p = {}, {}, None, None
+    if os.path.exists(journal_path):
+        for line in open(journal_path):
+            r = json.loads(line)
+            if r["type"] == "START":
+                pend_s = r
+            elif r["type"] == "RESULT":
+                done[r["id"]] = r
+                pend_s = None
+            elif r["type"] == "PSTART":
+                pend_p = r
+            elif r["type"] == "PROBE":
+                probes[r["id"]] = r["outcome"]
+                pend_p = None
+    return done, probes, pend_s, pend_p
+
+
+def compile_and_tce(problem, done, emit):
+    """Compile all pending mutants, classify compile_fail/TCE, return kept list."""
+    src_correct = externc(device_source(K.PROBLEMS[problem]["cuda"]))
+    mutants = list(mutator.generate(problem, device_source(K.PROBLEMS[problem]["cuda"])))
+    if MUTANT_CAP:
+        # multi-kernel level-3 substrates emit thousands of mutants per problem;
+        # sample per (rule, layer) so every rule family AND every network layer
+        # stays represented while the pool stays affordable
+        mutants = mutator.stratified_sample(mutants, MUTANT_CAP)
+    for m in mutants:
+        m["src"] = m["src"].replace("__global__ void", 'extern "C" __global__ void')
+    h_correct = normalized_hash(compile_ptx(src_correct, "correct.cu"))
+    seen_hash, compiled = {}, []
+    for m in mutants:
+        try:
+            ptx = compile_ptx(m["src"], "m.cu")
+        except RuntimeError:
+            if m["id"] not in done:
+                emit(type="RESULT", id=m["id"], cls="compile_fail",
+                     rule=m["rule"], category=m["category"], site=m["site"])
+            continue
+        h = normalized_hash(ptx)
+        if h == h_correct:
+            if m["id"] not in done:
+                emit(type="RESULT", id=m["id"], cls="tce_equiv_correct",
+                     rule=m["rule"], category=m["category"], site=m["site"])
+            continue
+        if h in seen_hash:
+            if m["id"] not in done:
+                emit(type="RESULT", id=m["id"], cls="tce_dup", dup_of=seen_hash[h],
+                     rule=m["rule"], category=m["category"], site=m["site"])
+            continue
+        seen_hash[h] = m["id"]
+        compiled.append((m, ptx))
+    return compiled
+
+
+def probe(problem):
+    install_watchdog()
+    """Crash quarantine pass: launch every mutant on tiny inputs only.
+    Crashers are caught here where a respawn costs seconds, not a cache rebuild."""
+    import torch
+    journal_path = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+    done, probes, _, pend_p = load_journal(journal_path)
+    journal = open(journal_path, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    if pend_p is not None:
+        emit(type="PROBE", id=pend_p["id"], outcome=f"crash:{pend_p['suite']}")
+        probes[pend_p["id"]] = "x"
+
+    compiled = compile_and_tce(problem, done, emit)
+    todo = [(m, p) for m, p in compiled if m["id"] not in done and m["id"] not in probes]
+    if not todo:
+        emit(type="PROBE_DONE", problem=problem)
+        return
+
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    gpu_suites = [(n, [t.cuda() for t in ins]) for n, ins in probe_suites(problem, torch)]
+
+    for m, ptx in todo:
+        try:
+            kern = NvrtcKernel(cuda_lib, ptx, kernel_name(problem))
+        except RuntimeError as e:
+            # module load rejected (e.g. rc=222 PTX/driver mismatch): treat as
+            # a compile failure for this mutant, never as a shard-fatal error
+            emit(type="PROBE", id=m["id"], outcome="load_fail",
+                 detail=str(e)[:60])
+            continue
+        crashed = False
+        for sname, gpu_in in gpu_suites:
+            emit(type="PSTART", id=m["id"], suite=sname)
+            try:
+                pet_watchdog()
+                out = kern.launch(problem, gpu_in, torch)
+                del out
+            except RuntimeError as e:
+                emit(type="PROBE", id=m["id"], outcome=f"crash:{sname}",
+                     detail=str(e)[:80])
+                journal.close()
+                sys.exit(3)
+        kern.unload()
+        emit(type="PROBE", id=m["id"], outcome="clean")
+    emit(type="PROBE_DONE", problem=problem)
+
+
+def worker(problem):
+    install_watchdog()
+    import torch
+    journal_path = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+    done, probes, pending, _ = load_journal(journal_path)
+    journal = open(journal_path, "a")
+
+    def emit(**rec):
+        journal.write(json.dumps(rec) + "\n")
+        journal.flush()
+        os.fsync(journal.fileno())
+
+    # previous process died mid-eval: the running suite is the killer
+    if pending is not None:
+        cls = "killed_by_T0" if pending["suite"] == "T0_original" else "high_value"
+        emit(type="RESULT", id=pending["id"], cls=cls, reason="cuda_poisoned",
+             witness=None if cls == "killed_by_T0" else pending["suite"])
+        done[pending["id"]] = True
+
+    compiled = [(m, p) for m, p in compile_and_tce(problem, done, emit)
+                if m["id"] not in done]
+    if not compiled:
+        emit(type="DONE", problem=problem)
+        return
+
+    # suites: T0 capped at 2 trials, then targeted
+    suites = [(n, min(t, 2), b) for n, t, b in K.PROBLEMS[problem]["suites"]()]
+    ref_fn = ref_fn_for(problem)
+    cache = {}
+
+    def get_pair(suite_name, builder, trial):
+        key = (suite_name, trial)
+        if key not in cache:
+            cpu_in = builder(trial)
+            gpu_in = [t.cuda() for t in cpu_in]
+            with torch.no_grad():
+                ref = ref_fn(*gpu_in)
+            cache[key] = (gpu_in, ref)
+        return cache[key]
+
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    torch.zeros(1, device="cuda")  # init context
+
+    for m, ptx in compiled:
+        outcome = probes.get(m["id"], "clean")
+        if outcome == "crash:p_aligned":
+            # crashed on a tiny T0-like input -> would crash on real T0
+            emit(type="RESULT", id=m["id"], cls="killed_by_T0", reason="probe_crash",
+                 witness=None, rule=m["rule"], category=m["category"], site=m["site"])
+            continue
+        t0_only = outcome.startswith("crash:")
+        probe_witness = outcome.split(":", 1)[1] if t0_only else None
+
+        current_suite = "T0_original"
+        emit(type="START", id=m["id"], suite=current_suite)
+        try:
+            kern = NvrtcKernel(cuda_lib, ptx, kernel_name(problem))
+        except RuntimeError as e:
+            emit(type="RESULT", id=m["id"], cls="compile_fail",
+                 rule=m["rule"], category=m["category"], site=m["site"],
+                 detail=str(e)[:60])
+            continue
+        cls, witness = None, None
+        try:
+            killed_t0 = False
+            name0, t0_trials, b0 = suites[0]
+            for trial in range(t0_trials):
+                gpu_in, ref = get_pair(name0, b0, trial)
+                pet_watchdog()
+                out = kern.launch(problem, gpu_in, torch)
+                r = compare(ref, out, torch)
+                del out
+                if r != "survived":
+                    killed_t0 = True
+                    break
+            if killed_t0:
+                cls = "killed_by_T0"
+            elif t0_only:
+                # survives T0 but a targeted probe input crashes it
+                cls, witness = "high_value", f"probe:{probe_witness}"
+            else:
+                for sname, strials, sbuilder in suites[1:]:
+                    current_suite = sname
+                    emit(type="START", id=m["id"], suite=sname)
+                    for trial in range(strials):
+                        gpu_in, ref = get_pair(sname, sbuilder, trial)
+                        pet_watchdog()
+                        out = kern.launch(problem, gpu_in, torch)
+                        r = compare(ref, out, torch)
+                        del out
+                        if r != "survived":
+                            witness = sname
+                            break
+                    if witness:
+                        break
+                cls = "high_value" if witness else "no_witness"
+            kern.unload()
+        except RuntimeError as e:
+            # CUDA launch/sync failure: the crashing suite is the kill witness.
+            # Context may be poisoned -> record and let orchestrator respawn us.
+            cls = "killed_by_T0" if current_suite == "T0_original" else "high_value"
+            emit(type="RESULT", id=m["id"], cls=cls, reason="crash",
+                 witness=None if current_suite == "T0_original" else current_suite,
+                 rule=m["rule"], category=m["category"], site=m["site"],
+                 detail=str(e)[:120])
+            journal.close()
+            sys.exit(3)
+        emit(type="RESULT", id=m["id"], cls=cls, witness=witness,
+             rule=m["rule"], category=m["category"], site=m["site"])
+
+    emit(type="DONE", problem=problem)
+
+
+def orchestrate():
+    """Registry stays resident here; each problem's probe and screening pass
+    run in forked children, so a poisoned CUDA context or a watchdog kill costs
+    a fork (microseconds) instead of an 85s registry re-import."""
+    from forkpool import run_isolated
+    for problem in my_problems():
+        # crash-quarantine churn is HEALTHY (each crashing mutant costs one
+        # respawn and journals progress); a deterministic hang outside mutant
+        # testing journals NOTHING. So give up only after several consecutive
+        # attempts with zero journal growth, not after N attempts total.
+        jpath = os.path.join(RESULTS, f"screen_{problem}.jsonl")
+
+        def jsize():
+            try:
+                return os.path.getsize(jpath)
+            except OSError:
+                return 0
+
+        def run_phase(fn, max_attempts):
+            stuck, prev = 0, jsize()
+            for attempt in range(max_attempts):
+                rc = run_isolated(fn, problem, timeout=PROBLEM_TIMEOUT)
+                if rc in (0, 124):
+                    return True
+                cur = jsize()
+                stuck = stuck + 1 if cur == prev else 0
+                prev = cur
+                if stuck >= 4:
+                    return False
+            return False
+
+        ok = run_phase(probe, 600)
+        print(f"[screen] {problem}: probe done", flush=True)
+        ok = ok and run_phase(worker, 400)
+        print(f"[screen] {problem}: "
+              f"{'done' if ok else 'GAVE UP (no journal progress)'}", flush=True)
+    print("[screen] ALL DONE", flush=True)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2 and sys.argv[1] == "--worker":
+        worker(sys.argv[2])
+    elif len(sys.argv) > 2 and sys.argv[1] == "--probe":
+        probe(sys.argv[2])
+    else:
+        orchestrate()

pipeline/suite_filter.py

@@ -0,0 +1,70 @@
+"""Blocklist of invalid test suites.
+
+A suite is INVALID if it makes the CORRECT kernel fail the benchmark's own
+check — such an input would reject valid submissions, so any mutant it
+"kills" must not be counted. The recheck stage records these as
+VALID/valid=false; this module turns those records into a blocklist that
+every downstream stage (full matrix, audit, set-cover) consults, so invalid
+suites are filtered out at load time rather than by rewriting generated code.
+
+Usage:
+    from suite_filter import valid_suites
+    for name, trials, builder in valid_suites(problem): ...
+"""
+import json
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+RESULTS = os.path.join(HERE, "results")
+BLOCKLIST = os.path.join(RESULTS, "invalid_suites.json")
+
+_cache = None
+
+
+def refresh():
+    """Rebuild the blocklist from recheck journals. Returns {problem: [suite]}."""
+    bad = {}
+    for f in os.listdir(RESULTS):
+        if not (f.startswith("recheck_") and f.endswith(".jsonl")):
+            continue
+        problem = f[len("recheck_"):-len(".jsonl")]
+        for line in open(os.path.join(RESULTS, f)):
+            try:
+                r = json.loads(line)
+            except ValueError:
+                continue
+            if r.get("type") == "VALID" and not r.get("valid"):
+                bad.setdefault(problem, [])
+                if r["suite"] not in bad[problem]:
+                    bad[problem].append(r["suite"])
+    with open(BLOCKLIST, "w") as fh:
+        json.dump(bad, fh, indent=1, sort_keys=True)
+    global _cache
+    _cache = bad
+    return bad
+
+
+def blocked(problem):
+    global _cache
+    if _cache is None:
+        if os.path.exists(BLOCKLIST):
+            _cache = json.load(open(BLOCKLIST))
+        else:
+            _cache = refresh()
+    return set(_cache.get(problem, ()))
+
+
+def valid_suites(problem):
+    """The problem's suites minus any that reject the correct implementation."""
+    import kernels_def as K
+    bad = blocked(problem)
+    return [(n, t, b) for n, t, b in K.PROBLEMS[problem]["suites"]()
+            if n not in bad]
+
+
+if __name__ == "__main__":
+    bad = refresh()
+    n = sum(len(v) for v in bad.values())
+    print(f"invalid suites: {n} across {len(bad)} problems")
+    for p, s in sorted(bad.items(), key=lambda kv: -len(kv[1]))[:10]:
+        print(f"  {p:34s} {s}")

pipeline/validate_ext.py

@@ -0,0 +1,56 @@
+"""Auto-validation gate for canonical kernels: the correct implementation must
+survive every suite (T0 capped at 2 trials) before it may serve as a mutation
+substrate. Exits nonzero on any failure so the pipeline aborts.
+
+Usage: python3 validate_ext.py [problem ...]   (default: extended problems only)
+"""
+import ctypes
+import sys
+
+import torch
+
+import kernels_def as K
+import problems_ext  # noqa: F401
+from nvrtc_tce import compile_ptx, device_source
+from screen_mutants import NvrtcKernel, compare, kernel_name, launch_spec, ref_fn_for
+
+EXT = ["leakyrelu", "gelu", "sigmoid", "logsoftmax", "matmul_mk", "matmul_ta",
+       "mean", "max", "rmsnorm"]
+
+
+def main():
+    problems = sys.argv[1:] or EXT
+    torch.zeros(1, device="cuda")
+    cuda_lib = ctypes.CDLL("libcuda.so.1")
+    failures = 0
+    for problem in problems:
+        src = device_source(K.PROBLEMS[problem]["cuda"]).replace(
+            "__global__ void", 'extern "C" __global__ void')
+        ptx = compile_ptx(src, f"{problem}.cu")
+        kern = NvrtcKernel(cuda_lib, ptx, kernel_name(problem))
+        ref_fn = ref_fn_for(problem)
+        for sname, n_trials, builder in K.PROBLEMS[problem]["suites"]():
+            for trial in range(min(n_trials, 2)):
+                inputs = builder(trial)
+                gpu_in = [t.cuda() for t in inputs]
+                with torch.no_grad():
+                    ref = ref_fn(*gpu_in)
+                out = kern.launch(problem, gpu_in, torch)
+                r = compare(ref, out, torch)
+                status = "OK " if r == "survived" else "FAIL"
+                if r != "survived":
+                    failures += 1
+                    diff = (ref - out).abs().nan_to_num(nan=float("inf")).max()
+                    print(f"[validate] {status} {problem}/{sname} t{trial}: {r} "
+                          f"max_diff={float(diff):.4g}", flush=True)
+                else:
+                    print(f"[validate] {status} {problem}/{sname} t{trial}", flush=True)
+                del gpu_in, ref, out
+                torch.cuda.empty_cache()
+        kern.unload()
+    print(f"[validate] failures: {failures}", flush=True)
+    sys.exit(1 if failures else 0)
+
+
+if __name__ == "__main__":
+    main()

rules/BRIEF.md

@@ -0,0 +1,79 @@
+# Rule-mining brief: new CUDA mutation operators
+
+## Context
+
+We run mutation testing on CUDA kernels to measure how strong a benchmark's
+correctness check is. Mutants are produced by DETERMINISTIC rewrite rules
+applied to correct kernel source (see ../mutator.py for the 35 current rules
+and the Rule dataclass). Each rule is (name, category, regex pattern,
+replacement template). Every match site yields one mutant.
+
+## What makes a rule VALUABLE (this is the objective)
+
+A mutant is "high value" when it (a) compiles, (b) SURVIVES the benchmark's
+original test inputs — which are aligned shapes, torch.rand[0,1) values,
+compared with allclose(atol=rtol=1e-2) — and (c) IS killable by some targeted
+input (misaligned shape, signed values, large magnitude, structured spikes).
+
+Measured value rates of existing rules on our pool:
+  ceil2floor 100%, const0to1 62%, sync2syncwarp 40%, loop-bound-minus1 39%,
+  loop-start-1 35%, sync-remove 36%, lt2le 21%, store-fp16 24%,
+  mul2plus 15%, mul2div 12%   <- good
+  plus2minus 3%, guard-drop-ternary 0%, expf-fast 0%, smem-index-off1 0%,
+  fmin2fmax 0%, negate-store 0%, fdividef-fast 0%   <- bad, being retired
+
+Pattern: rules that break BOUNDARY handling, SYNCHRONIZATION, or PRECISION
+produce faults invisible under aligned shapes and small positive values.
+Rules that break gross semantics (a+b -> a-b) are caught immediately by any
+input and are near-worthless.
+
+## Known expressiveness gaps (highest priority)
+
+Our regex rules CANNOT express these, yet they are the most valuable faults:
+
+1. Identity substitution: replacing a call with its own argument, e.g.
+   `fmaxf(val, 0.0f)` -> `val` (removes a ReLU; invisible on positive inputs).
+   Generalize: any activation/clamp/saturation wrapper removal.
+2. Numerical-stability removal: dropping the max-subtraction in softmax-like
+   code, dropping epsilon in a denominator, dropping Kahan compensation.
+3. Partial-tail faults: processing only a prefix of a reduction, off-by-one
+   in the LAST iteration only, dropping the remainder loop after a vectorized
+   main loop.
+4. Accumulator staging: using the shared-memory value before the barrier,
+   re-initializing an accumulator inside the loop, double-counting an element.
+5. Index arithmetic that is wrong only at edges: swapping row/col strides in
+   ONE of several index expressions, using the wrong bound variable (M vs N),
+   using blockDim where gridDim is meant.
+
+## Your task
+
+Write NEW rules into a fresh file: rules/mined_rules.py
+
+Format (import-safe, no side effects):
+
+```python
+from mutator import Rule   # dataclass(name, category, pattern, replacement, note)
+
+MINED_RULES = [
+    Rule("name", "category", r"regex", r"replacement", "one-line rationale"),
+    ...
+]
+```
+
+Requirements:
+- 25+ new rules, none duplicating an existing rule in ../mutator.py.
+- Categories: boundary | sync | precision | indexing | arithmetic | semantic.
+- Patterns must be robust regexes that match the CUDA style used in
+  ../problems_batch2.py and ../substrates/accepted/*.py (read several of them
+  — that is the corpus these rules must fire on).
+- Prefer rules targeting the five gap families above; a regex CAN express
+  identity substitution when the call and its first argument are both simple
+  (e.g. r"fmaxf\((\w+), 0\.0f\)" -> r"\1"). Write several such families.
+- Every rule must produce COMPILABLE code (mind types and parens).
+- Avoid rules whose mutants would be caught by any input (gross semantics).
+- Add a short comment block at the top summarizing your reasoning.
+
+Verify before finishing: run
+  python3 -c "import sys; sys.path.insert(0,'.'); from rules.mined_rules import MINED_RULES; print(len(MINED_RULES))"
+from the experiment directory, and also verify each pattern compiles as a
+regex. Do not modify any existing file.

rules/BRIEF3.md

@@ -0,0 +1,86 @@
+# Brief 3: fine-grained mutation rules ONLY
+
+## The single objective
+
+Write rules whose mutants SURVIVE the benchmark's original inputs. Nothing
+else matters. A rule whose mutants die on the first input is worthless — we
+already have too many of those and they are being retired.
+
+The original inputs are, for essentially every task:
+    torch.rand(...)          # uniform [0,1), all POSITIVE, small magnitude
+    aligned shapes           # every dim divisible by 32 or 256
+    compared with allclose(atol=1e-2, rtol=1e-2)   # 1% slack
+
+So a mutant survives if and only if its behavioural difference is INVISIBLE
+under that specific regime. Measured value rates from our pool prove the point:
+
+    SURVIVES (keep writing rules like these)
+      ceil2floor            100%   remainder block never exists when aligned
+      const0to1              62%   changed constant is masked by tolerance
+      sync2syncwarp          40%   race is benign when all values are similar
+      loop-bound-minus1      39%   one missing term of thousands < 1%
+      store-fp16             24%   1e-3 relative error < 1e-2 tolerance
+
+    DIES INSTANTLY (do NOT write more of these)
+      plus2minus              3%   every output element changes
+      mul2div/mul2plus       12%   same
+      fmax2fmin               0%   same
+      guard-drop-ternary      0%   crashes or changes everything
+
+## The four survival mechanisms — target these deliberately
+
+1. TOLERANCE ABSORPTION. The fault's error is real but under 1% of the output
+   magnitude. Examples: one term of a long reduction dropped or double
+   counted; a constant off in the 4th significant digit; an intermediate
+   rounded to fewer bits; a slightly different but nearly-equal formula
+   (expf(a)*expf(b) instead of expf(a+b), fma vs mul+add, x*0.5f vs x/2.0f
+   with a perturbation).
+
+2. INPUT-DOMAIN EVASION. The faulty path is never taken because the input is
+   positive, small and finite. Examples: a branch that only differs for
+   negative / >1 / very large / NaN / exactly-equal values; a clamp whose
+   bound is never reached; a sign-dependent shortcut; a sentinel that only
+   matters when all values share a sign.
+
+3. SHAPE-ALIGNMENT EVASION. The faulty code path only executes on a partial
+   block / remainder loop / edge tile, which does not exist when every
+   dimension is a multiple of the block size. Examples: remainder handling,
+   the last tile of a K-loop, an edge guard on the final row.
+
+4. BENIGN RACE. Removing or weakening synchronization only corrupts results
+   when the racing values differ substantially; under uniform [0,1) the stale
+   and fresh values are nearly equal. Examples: partial barrier, barrier moved
+   one statement, reading a shared slot one iteration early, using a
+   thread-local value where a reduced value is intended.
+
+## Constraints
+
+- Deterministic regex rewrite, single site per mutant, must COMPILE.
+- Must not be a duplicate of any rule in ../mutator.py, rules/mined_rules.py,
+  or rules/structural_rules.py (read all three).
+- Patterns must fire on the corpus: read at least 6 files from
+  substrates/accepted/ plus problems_batch2.py before writing anything.
+  A rule that never matches is worthless — prefer patterns built from syntax
+  you have actually SEEN in those files.
+- No rule that changes every output element. Before adding a rule, ask:
+  "under torch.rand input with aligned shapes, would the output differ by
+  more than 1%?" If yes, discard it.
+
+## Deliverable
+
+rules/fine_rules.py:
+
+```python
+from mutator import Rule
+FINE_RULES = [
+    Rule("name", "category", r"pattern", r"replacement",
+         "why it survives the original inputs, and what input would kill it"),
+    ...
+]
+```
+
+30+ rules, categories: boundary | sync | precision | indexing | semantic.
+Each note MUST state the survival mechanism (1-4 above) and the killer input.
+Verify: every regex compiles, the module imports, and report how many of your
+rules actually fire across the corpus (write a small throwaway check, do not
+add it to the repo).

rules/fine_rules.py

@@ -0,0 +1,144 @@
+"""Fine-grained mutations aimed at the benchmark's weak original oracle.
+
+The patterns are deliberately tied to CUDA spellings present in the accepted
+substrates or ``problems_batch2.py``.  Each substitution changes one narrow
+site and remains valid CUDA/C++.
+"""
+
+from mutator import Rule
+
+
+FINE_RULES = [
+    # Boundary faults: one tail lane or one term of a long reduction.
+    Rule("output-elements-one-extra-lane", "boundary",
+         r"if \(output_index >= output_elements\) return;",
+         r"if (output_index > output_elements) return;",
+         "Mechanism 3 (shape-alignment evasion): an exactly aligned launch has no lane at output_elements; a misaligned output plus a CUDA memory checker kills it."),
+    Rule("line-count-one-extra-lane", "boundary",
+         r"if \(line >= line_count\) return;",
+         r"if (line > line_count) return;",
+         "Mechanism 3 (shape-alignment evasion): aligned line counts launch no extra lane; a non-multiple line count with guarded allocation kills it."),
+    Rule("flat-n-one-extra-lane", "boundary",
+         r"if \(idx < n\) (\{\{?) float val = x\[idx\];",
+         r"if (idx <= n) \1 float val = x[idx];",
+         "Mechanism 3 (shape-alignment evasion): n is block-aligned in the original elementwise case; a misaligned n kills it by exposing the one-past-end access."),
+    Rule("matmul-a-last-k-drop", "boundary",
+         r"row < M && a_k < K",
+         r"row < M && a_k + 1 < K",
+         "Mechanism 1 (tolerance absorption): one of hundreds of positive dot-product terms is lost (<1%); a last-K spike kills it."),
+    Rule("matmul-a-transposed-last-k-drop", "boundary",
+         r"a_k < K && row < M",
+         r"a_k + 1 < K && row < M",
+         "Mechanism 1 (tolerance absorption): only the last term of a long dot product is removed; a dominant last A term kills it."),
+    Rule("matmul-b-last-k-drop", "boundary",
+         r"b_k < K && col < N",
+         r"b_k + 1 < K && col < N",
+         "Mechanism 1 (tolerance absorption): one reduction term among hundreds is zeroed; a last-K spike in B kills it."),
+    Rule("arg-reduction-last-row-drop", "boundary",
+         r"for \(int r = 1; r < R; r\+\+\)",
+         r"for (int r = 1; r + 1 < R; r++)",
+         "Mechanism 2 (input-domain evasion): the final row is almost never the unique random extremum; forcing the extremum into the final row kills it."),
+    Rule("min-reduction-last-row-drop", "boundary",
+         r"for \(int r = 0; r < R; r\+\+\)",
+         r"for (int r = 0; r + 1 < R; r++)",
+         "Mechanism 2 (input-domain evasion): a random final row is rarely the minimum; placing the unique minimum there kills it."),
+    Rule("cumsum-last-output-drop", "boundary",
+         r"scan_index < scan_size; scan_index\+\+",
+         r"scan_index + 1 < scan_size; scan_index++",
+         "Mechanism 1 (tolerance absorption): only the last prefix output is omitted and its missing term is tiny relative to a long positive sum; a short scan or last-position spike kills it."),
+    Rule("pool2d-last-tap-drop", "boundary",
+         r"kernel_x < 11; kernel_x\+\+",
+         r"kernel_x < 10; kernel_x++",
+         "Mechanism 1 (tolerance absorption): one of 121 comparable positive pooling terms is lost (~0.83%); a large value in the omitted tap kills it."),
+    Rule("groupnorm-sum-tail-scalar-drop", "boundary",
+         r"if \(i < group_size\) \{ local_sum \+= x\[group_start \+ i\]; \}",
+         r"if (i + 1 < group_size) { local_sum += x[group_start + i]; }",
+         "Mechanism 1 (tolerance absorption): one scalar among a huge group is absent from the mean; a dominant final scalar kills it."),
+    Rule("groupnorm-sqdev-tail-scalar-drop", "boundary",
+         r"if \(i < group_size\) \{\s*float centered = x\[group_start \+ i\] - mean;",
+         r"if (i + 1 < group_size) {\n            float centered = x[group_start + i] - mean;",
+         "Mechanism 1 (tolerance absorption): one of many variance contributions is omitted; a high-leverage final outlier kills it."),
+
+    # Synchronization faults, restricted to named barriers actually present.
+    Rule("matmul-after-load-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-load",
+         r"__syncwarp(); // sync-after-load",
+         "Mechanism 4 (benign race): warp-local progress often sees similar positive tiles; lane/warp-skewed tile values kill it."),
+    Rule("matmul-after-compute-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-compute",
+         r"__syncwarp(); // sync-after-compute",
+         "Mechanism 4 (benign race): stale and next-tile random values are statistically similar; a tile-alternating high/low input kills it."),
+    Rule("groupnorm-sum-store-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-sum-store",
+         r"__syncwarp(); // sync-after-sum-store",
+         "Mechanism 4 (benign race): similar lane partials mask cross-warp publication races; lane-chunk contrast kills it."),
+    Rule("groupnorm-sqdev-store-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-sqdev-store",
+         r"__syncwarp(); // sync-after-sqdev-store",
+         "Mechanism 4 (benign race): uniform inputs give similar squared-deviation partials; a lane-localized outlier kills it."),
+    Rule("groupnorm-final-output-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-before-output",
+         r"__syncwarp(); // sync-before-output",
+         "Mechanism 4 (benign race): the preceding reduction barrier normally makes this nearly redundant; adversarial scheduling with divergent lanes kills it."),
+    Rule("batchnorm-local-stats-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-local-statistics",
+         r"__syncwarp(); // sync-after-local-statistics",
+         "Mechanism 4 (benign race): uniform random lane statistics are close; per-lane distributions with very different means kill it."),
+    Rule("batchnorm-merge-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-after-welford-merge",
+         r"__syncwarp(); // sync-after-welford-merge",
+         "Mechanism 4 (benign race): similar Welford partials hide stale cross-warp merges; alternating lane chunks kill it."),
+    Rule("batchnorm-output-warp-barrier", "sync",
+         r"__syncthreads\(\); // sync-before-output-pass",
+         r"__syncwarp(); // sync-before-output-pass",
+         "Mechanism 4 (benign race): statistics are already reduced before this mostly redundant barrier; forced warp skew kills it."),
+
+    # Small numerical perturbations kept well inside the 1% oracle slack.
+    Rule("avgpool121-denom-perturb", "precision", r"sum / 121\.0f",
+         r"sum / 121.01f",
+         "Mechanism 1 (tolerance absorption): the relative scale error is below 0.01%; a much tighter tolerance kills it."),
+    Rule("hardsigmoid-six-denom-perturb", "precision", r"val / 6\.0f",
+         r"val / 6.001f",
+         "Mechanism 1 (tolerance absorption): the slope error is ~0.017%; a tight oracle near the linear-region edge kills it."),
+    Rule("hardsigmoid-half-ulpish-perturb", "precision", r"\+ 0\.5f, 0\.0f\)",
+         r"+ 0.5001f, 0.0f)",
+         "Mechanism 1 (tolerance absorption): a 1e-4 offset is below atol; a sub-1e-4 tolerance kills it."),
+    Rule("softplus-cutoff-tiny-shift", "precision", r"val > 20\.0f \?",
+         r"val > 19.99f ?",
+         "Mechanism 2 (input-domain evasion): original values never approach the large branch cutoff; values in [19.99,20] kill it."),
+    Rule("selu-scale-small-perturb", "precision",
+         r"1\.0507009873554805f \* \(val > 0\.0f",
+         r"1.0506009873554805f * (val > 0.0f",
+         "Mechanism 1 (tolerance absorption): the global relative error is under 0.01%; a tighter relative tolerance kills it."),
+    Rule("selu-alpha-small-perturb", "precision",
+         r"1\.6732632423543772f \* \(expf\(val\)",
+         r"1.6731632423543772f * (expf(val)",
+         "Mechanism 2 (input-domain evasion): the alpha is unused for positive originals; negative SELU inputs kill it."),
+    Rule("groupnorm-epsilon-halved", "precision", r"\+ 1\.0e-5f\)",
+         r"+ 5.0e-6f)",
+         "Mechanism 1 (tolerance absorption): ordinary random variance dwarfs epsilon; nearly constant inputs with variance below 1e-5 kill it."),
+    Rule("batchnorm-epsilon-small-bias", "precision", r"channel_variance \+ eps",
+         r"channel_variance + eps * 0.99f",
+         "Mechanism 1 (tolerance absorption): variance dominates a 1% epsilon perturbation; sub-epsilon variance kills it."),
+    Rule("matmul-acc-store-fma-nudge", "precision", r"= acc; \}",
+         r"= acc * 0.9999f; }",
+         "Mechanism 1 (tolerance absorption): a 0.01% store-scale error is hidden by rtol; a tighter relative oracle kills it."),
+
+    # Index and semantic faults which activate only on rare/domain-specific data.
+    Rule("argmax-final-row-alias", "indexing", r"best_row = \(long long\)r;",
+         r"best_row = (long long)(r == R - 1 ? r - 1 : r);",
+         "Mechanism 2 (input-domain evasion): it differs only when the unique maximum is in the final row; a final-row spike kills it."),
+    Rule("argmax-final-row-value-alias", "indexing", r"x\[base \+ \(long long\)r \* C\]",
+         r"x[base + (long long)(r == R - 1 ? r - 1 : r) * C]",
+         "Mechanism 2 (input-domain evasion): only the last candidate is misindexed and is rarely maximal; a final-row spike kills it."),
+    Rule("selu-positive-cutoff-nudge", "semantic", r"val > 0\.0f \? val :",
+         r"val > -1.0e-6f ? val :",
+         "Mechanism 2 (input-domain evasion): ordinary positive values avoid the moved cutoff; tiny negative values in [-1e-6,0] kill it."),
+    Rule("elu-positive-cutoff-nudge", "semantic",
+         r"val > 0\.0f \? val : \(expf\(val\) - 1\.0f\)",
+         r"val > -1.0e-6f ? val : (expf(val) - 1.0f)",
+         "Mechanism 2 (input-domain evasion): positive originals take the same branch; tiny negative values kill it."),
+    Rule("softsign-positive-fabs-elide", "semantic", r"1\.0f \+ fabsf\(val\)",
+         r"1.0f + val",
+         "Mechanism 2 (input-domain evasion): fabs is identical for positive originals; any negative input kills it."),
+]

rules/mined_rules.py

@@ -0,0 +1,142 @@
+"""Additional mutation rules mined from the batch-2 and accepted corpora.
+
+These rules favor faults hidden by aligned, positive, modest-sized inputs:
+activation/clamp identities, removed numerical safeguards, tail-only omissions,
+premature shared-memory reads, and plausible one-site stride/bound mistakes.
+Patterns are intentionally narrow so each independent substitution remains
+valid CUDA and avoids the gross arithmetic mutations already in ``mutator``.
+"""
+
+from mutator import Rule
+
+
+MINED_RULES = [
+    # Identity substitutions: positive inputs often make these wrappers inert.
+    Rule("relu-fmax-zero-remove", "semantic",
+         r"fmaxf\((\w+),\s*0\.0f\)", r"\1",
+         "remove a simple ReLU wrapper; differs only for negative values"),
+    Rule("relu-fmax-zero-first-remove", "semantic",
+         r"fmaxf\(0\.0f,\s*(\w+)\)", r"\1",
+         "remove commuted ReLU wrapper; positive inputs conceal the fault"),
+    Rule("upper-unit-clamp-remove", "semantic",
+         r"fminf\((\w+),\s*1\.0f\)", r"\1",
+         "drop a unit upper clamp, exposed by values above one"),
+    Rule("upper-unit-clamp-first-remove", "semantic",
+         r"fminf\(1\.0f,\s*(\w+)\)", r"\1",
+         "drop a commuted unit upper clamp"),
+    Rule("lower-negunit-clamp-remove", "semantic",
+         r"fmaxf\((\w+),\s*-1\.0f\)", r"\1",
+         "drop a lower saturation bound"),
+    Rule("nested-unit-clamp-drop-upper", "semantic",
+         r"fminf\((fmaxf\([^,()]+,\s*[-\w.]+\)),\s*1\.0f\)", r"\1",
+         "retain the lower clamp but remove the upper saturation"),
+    Rule("fabs-simple-remove", "semantic",
+         r"fabsf\((\w+(?:\[\w+\])?)\)", r"\1",
+         "absolute value is an identity on the original positive corpus"),
+
+    # Numerical stability and compensation faults.
+    Rule("rsqrt-epsilon-remove", "precision",
+         r"rsqrtf\(([^()\n;+]{1,80})\s*\+\s*eps\)", r"rsqrtf(\1)",
+         "remove the variance epsilon safeguard"),
+    Rule("sqrt-epsilon-remove", "precision",
+         r"sqrtf\(([^()\n;+]{1,80})\s*\+\s*eps\)", r"sqrtf(\1)",
+         "remove epsilon under a square root"),
+    Rule("literal-epsilon-remove", "precision",
+         r"(\w+(?:\[[^]\n]+\])?)\s*\+\s*1e-0?[5-8]f", r"\1",
+         "drop a literal small stabilizer from a simple expression"),
+    Rule("softmax-max-subtraction-remove", "precision",
+         r"expf\((\w+(?:\[[^]\n]+\])?)\s*-\s*(\w*(?:max|best)\w*)\)",
+         r"expf(\1)",
+         "remove max subtraction, causing overflow only at large magnitude"),
+    Rule("softmax-max-subtraction-fast-remove", "precision",
+         r"__expf\((\w+(?:\[[^]\n]+\])?)\s*-\s*(\w*(?:max|best)\w*)\)",
+         r"__expf(\1)",
+         "remove stabilization from a fast exponential"),
+    Rule("welford-second-delta-reuse", "precision",
+         r"float\s+delta2\s*=\s*(\w+)\s*-\s*(\w+);", r"float delta2 = delta;",
+         "replace Welford's corrected second delta with the first delta"),
+    Rule("variance-unbiased-count", "precision",
+         r"m2s\[0\]\s*/\s*\(float\)counts\[0\]",
+         r"m2s[0] / (float)(counts[0] - 1)",
+         "use sample rather than population variance"),
+    Rule("kahan-compensation-drop", "precision",
+         r"(\w+)\s*=\s*(\w+)\s*-\s*(\w*(?:comp|correction)\w*)\s*;",
+         r"\1 = \2;",
+         "remove a simple Kahan compensation subtraction"),
+
+    # Tail and last-iteration faults that aligned dimensions can conceal.
+    Rule("last-row-reduction-skip", "boundary",
+         r"for \(int (\w+) = 0; \1 < (\w+); \1\+\+\)",
+         r"for (int \1 = 0; \1 + 1 < \2; \1++)",
+         "skip only the final item of a simple reduction loop"),
+    Rule("last-row-reduction-skip-start1", "boundary",
+         r"for \(int (\w+) = 1; \1 < (\w+); \1\+\+\)",
+         r"for (int \1 = 1; \1 + 1 < \2; \1++)",
+         "omit the last item while retaining a separately seeded first item"),
+    Rule("strided-tail-drop", "boundary",
+         r"(\w+)\s*<\s*(\w+);\s*\1\s*\+=\s*blockDim\.x",
+         r"\1 + blockDim.x < \2; \1 += blockDim.x",
+         "drop the final strided chunk of a reduction or output pass"),
+    Rule("tile-last-iteration-skip", "boundary",
+         r"for \(int (\w+) = 0; \1 < (\w*[Tt]iles\w*); \1\+\+\)",
+         r"for (int \1 = 0; \1 + 1 < \2; \1++)",
+         "omit only the final matrix tile"),
+    Rule("literal-loop-last-skip", "boundary",
+         r"for \(int (\w+) = 0; \1 < (\d+); \1\+\+\)",
+         r"for (int \1 = 0; \1 + 1 < \2; \1++)",
+         "omit the last tap of a fixed-size pooling or convolution loop"),
+    Rule("tail-guard-tighten", "boundary",
+         r"if \((\w+) < (\w+)\) \{", r"if (\1 + 1 < \2) {",
+         "reject exactly the final valid scalar in a guarded tail"),
+
+    # Shared-memory staging and reduction faults.
+    Rule("shared-denom-use-local", "sync",
+         r"float denom = sdata\[0\] / dim;", r"float denom = local_sum / dim;",
+         "consume the per-thread value instead of the reduced shared value"),
+    Rule("shared-sqrt-use-local", "sync",
+         r"float denom = sqrtf\(sdata\[0\]\);", r"float denom = sqrtf(local_sum);",
+         "read the local accumulator in place of the synchronized reduction"),
+    Rule("reduction-barrier-move-before-store", "sync",
+         r"(sdata\[tid\]\s*=\s*[^;]+;)\s*\n\s*__syncthreads\(\);",
+         r"__syncthreads();\n    \1",
+         "move the barrier before the shared-memory publication"),
+    Rule("welford-count-merge-early", "sync",
+         r"counts\[tid\]\s*=\s*combined_count;", r"counts[tid + width] = combined_count;",
+         "publish a merged count to the partner lane instead of the consumer"),
+    Rule("reduction-partner-half-offset", "indexing",
+         r"sdata\[tid \+ s\]", r"sdata[tid + (s >> 1)]",
+         "read the wrong partner within one tree-reduction stage"),
+
+    # One-site dimension, stride, and flattening mistakes.
+    Rule("row-store-stride-k", "indexing",
+         r"C\[\(long long\)row \* N \+ col\]", r"C[(long long)row * K + col]",
+         "use the reduction dimension as one output row stride"),
+    Rule("a-row-stride-n", "indexing",
+         r"A\[\(long long\)row \* K \+ a_k\]", r"A[(long long)row * N + a_k]",
+         "use N rather than K for one matrix-A row stride"),
+    Rule("b-row-stride-k", "indexing",
+         r"B\[\(long long\)b_k \* N \+ col\]", r"B[(long long)b_k * K + col]",
+         "use K rather than N for one matrix-B row stride"),
+    Rule("matrix-row-bound-use-n", "boundary",
+         r"row < M", r"row < N",
+         "guard matrix rows with the column dimension"),
+    Rule("matrix-col-bound-use-m", "boundary",
+         r"col < N", r"col < M",
+         "guard matrix columns with the row dimension"),
+    Rule("height-bound-use-width", "boundary",
+         r"input_y < input_height", r"input_y < input_width",
+         "use width as the vertical edge bound"),
+    Rule("width-bound-use-height", "boundary",
+         r"input_x < input_width", r"input_x < input_height",
+         "use height as the horizontal edge bound"),
+    Rule("flatten-height-use-width", "indexing",
+         r"\* input_height \+ input_y", r"* input_width + input_y",
+         "substitute width for one height stride in a flattened index"),
+    Rule("output-position-height-first", "indexing",
+         r"position % output_width", r"position % output_height",
+         "decode a flattened x coordinate with the wrong extent"),
+    Rule("grid-x-use-block-y", "indexing",
+         r"blockIdx\.x \* blockDim\.x \+ threadIdx\.x",
+         r"blockIdx.x * blockDim.y + threadIdx.x",
+         "use the other block extent in a linear global index"),
+]

rules/structural_rules.py

@@ -0,0 +1,124 @@
+"""Structure-specific subtle-fault rules.
+
+Motivation: on elementwise / index-output kernels our generic rules degenerate
+to gross arithmetic mutations (a*b -> a+b), which any input kills. Those
+kernels DO admit realistic subtle faults — they just live in different
+syntax. Each rule below models a fault an LLM-written kernel plausibly makes,
+and each is invisible under the benchmark's default inputs (aligned shapes,
+torch.rand[0,1)) while being killable by a deliberately constructed input.
+
+Fault families:
+  A. tie-breaking in max/min/argmax (ties have measure zero under continuous
+     random input; only duplicate-valued inputs expose them)
+  B. approximation-constant perturbation (relative error ~1e-3 hides under
+     atol=1e-2 at small magnitude, grows with |x|)
+  C. branch-cutoff shifts in piecewise activations (wrong only inside the
+     moved interval)
+  D. single-element tail loss in elementwise guards (needs misaligned or
+     spiked-tail input)
+"""
+from mutator import Rule
+
+STRUCTURAL_RULES = [
+    # --- A. tie-breaking ---------------------------------------------------
+    Rule("argmax-tie-last", "semantic",
+         r"if \((\w+) > (\w+)\) \{",
+         r"if (\1 >= \2) { ",
+         "argmax keeps the LAST maximum instead of the first: differs only "
+         "when duplicate values exist (measure zero under rand)"),
+    Rule("argmin-tie-last", "semantic",
+         r"if \((\w+) < (\w+)\) \{",
+         r"if (\1 <= \2) { ",
+         "argmin keeps the last minimum instead of the first"),
+    Rule("argmax-tie-nan-form", "semantic",
+         r"if \((\w+) > (\w+) \|\| \(isnan\(",
+         r"if (\1 >= \2 || (isnan(",
+         "argmax with NaN handling: ties now keep the LAST index; only "
+         "duplicate-valued inputs differ (measure zero under rand)"),
+    Rule("argmax-nan-policy-drop", "semantic",
+         r" \|\| \(isnan\((\w+)\) && !isnan\((\w+)\)\)",
+         r"",
+         "drop the NaN-propagation branch: differs only on NaN inputs"),
+    Rule("argmax-seed-from-second", "boundary",
+         r"for \(int (\w+) = 1; \1 < (\w+); \1\+\+\)",
+         r"for (int \1 = 2; \1 < \2; \1++)",
+         "scan starts one element late: wrong only when the true extremum "
+         "sits at that position"),
+    Rule("reduce-fmax-tie-order", "semantic",
+         r"(\w+) = fmaxf\(\1, ([^;]+)\);",
+         r"\1 = (\2 > \1) ? \2 : \1;",
+         "fmaxf replaced by a strict comparison: identical except for NaN "
+         "operands, where fmaxf ignores NaN but > propagates the old value"),
+    Rule("reduce-fmin-tie-order", "semantic",
+         r"(\w+) = fminf\(\1, ([^;]+)\);",
+         r"\1 = (\2 < \1) ? \2 : \1;",
+         "fminf replaced by strict comparison: NaN semantics differ"),
+    Rule("reduce-seed-first-element", "boundary",
+         r"float (\w+) = -CUDART_INF_F;",
+         r"float \1 = 0.0f;",
+         "max-reduction seeded with 0 instead of -inf: wrong only when every "
+         "value in the row is negative"),
+    Rule("reduce-seed-first-element-min", "boundary",
+         r"float (\w+) = CUDART_INF_F;",
+         r"float \1 = 0.0f;",
+         "min-reduction seeded with 0: wrong only for all-positive rows"),
+
+    # --- B. approximation constants ---------------------------------------
+    Rule("gelu-tanh-const-perturb", "precision",
+         r"0\.044715f",
+         r"0.044615f",
+         "GELU tanh-approximation cubic coefficient off in the 4th digit"),
+    Rule("gelu-sqrt2pi-perturb", "precision",
+         r"0\.7978845608f?",
+         r"0.7968845608",
+         "sqrt(2/pi) constant mistyped: relative error ~1e-3"),
+    Rule("invsqrt2-perturb", "precision",
+         r"0\.70710678f",
+         r"0.70701678f",
+         "1/sqrt(2) mistyped in the erf-based GELU"),
+    Rule("selu-alpha-perturb", "precision",
+         r"1\.6732632423543772f",
+         r"1.6723632423543772f",
+         "SELU alpha constant digit transposition"),
+    Rule("selu-scale-perturb", "precision",
+         r"1\.0507009873554805f",
+         r"1.0057009873554805f",
+         "SELU scale constant digit transposition"),
+    Rule("erf-to-tanh-approx", "precision",
+         r"0\.5f \* (\w+) \* \(1\.0f \+ erff\((\w+) \* 0\.70710678f\)\)",
+         r"0.5f * \1 * (1.0f + tanhf(0.7978845608f * (\2 + 0.044715f * \2 * \2 * \2)))",
+         "exact erf GELU replaced by the tanh approximation (~1e-3 relative)"),
+
+    # --- C. piecewise cutoffs ---------------------------------------------
+    Rule("softplus-cutoff-shift", "precision",
+         r"(\w+) > 20\.0f \?",
+         r"\1 > 8.0f ?",
+         "softplus linear-regime threshold moved: wrong inside [8,20]"),
+    Rule("relu-threshold-shift", "semantic",
+         r"(\w+) > 0\.0f \? \1 :",
+         r"\1 > 1e-6f ? \1 :",
+         "activation threshold nudged off zero: only tiny values differ"),
+    Rule("hardsigmoid-slope-perturb", "precision",
+         r"/ 6\.0f \+ 0\.5f",
+         r"/ 6.0f + 0.4995f",
+         "hardsigmoid offset off by 5e-4: hidden by atol at small outputs"),
+    Rule("clamp-bound-perturb", "precision",
+         r"fminf\(fmaxf\((\w+), -1\.0f\), 1\.0f\)",
+         r"fminf(fmaxf(\1, -1.0f), 0.999f)",
+         "saturation bound off by 1e-3: only saturated inputs differ"),
+
+    # --- D. elementwise tail loss -----------------------------------------
+    Rule("elementwise-guard-minus1", "boundary",
+         r"if \((\w+) < (n|N|size|numel|total)\) \{",
+         r"if (\1 < \2 - 1) { ",
+         "last element of the flat range never written: needs a spiked or "
+         "misaligned tail to expose"),
+    Rule("elementwise-guard-plus1", "boundary",
+         r"if \((\w+) < (n|N|size|numel|total)\) \{",
+         r"if (\1 < \2 + 1) { ",
+         "one lane past the end writes OOB (sanitizer-visible)"),
+    Rule("grid-stride-step-double", "boundary",
+         r"idx \+= (blockDim\.x \* gridDim\.x)",
+         r"idx += 2 * \1",
+         "grid-stride loop skips every other element"),
+]

substrates/candidate_L2p10_convtranspose2d_maxpoo.py

@@ -0,0 +1,206 @@
+"""Mutation-friendly substrate for KernelBench level-2 problem 10."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void l2p10_convtranspose2d_maxpool_hardtanh_mean_tanh_kernel(
+        const float* x, const float* weight, const float* bias, float* out,
+        int batches, int input_channels, int input_height, int input_width,
+        int output_channels, int kernel_height, int kernel_width,
+        int convolution_height, int convolution_width,
+        int pooled_height, int pooled_width, long long output_elements) {
+    long long output_index =
+        (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    if (output_index >= output_elements) return;
+
+    int output_channel = (int)(output_index % output_channels);
+    int batch = (int)(output_index / output_channels);
+    float spatial_sum = 0.0f;
+
+    // Each thread computes one (batch, output-channel) result.  Recompute the
+    // four convolution values belonging to every pooling window; this is slow
+    // but keeps all five operations in one simple, race-free kernel.
+    for (int pooled_y = 0; pooled_y < pooled_height; pooled_y++) {
+        for (int pooled_x = 0; pooled_x < pooled_width; pooled_x++) {
+            float pooled_max = -3.402823466e+38F;
+
+            for (int pool_y = 0; pool_y < 2; pool_y++) {
+                int convolution_y = pooled_y * 2 + pool_y;
+                if (convolution_y >= convolution_height) continue;
+                for (int pool_x = 0; pool_x < 2; pool_x++) {
+                    int convolution_x = pooled_x * 2 + pool_x;
+                    if (convolution_x >= convolution_width) continue;
+
+                    float convolution_value = bias[output_channel];
+                    for (int input_channel = 0;
+                         input_channel < input_channels; input_channel++) {
+                        for (int kernel_y = 0; kernel_y < kernel_height;
+                             kernel_y++) {
+                            // ConvTranspose2d has stride=1 and padding=1:
+                            // output_y = input_y - 1 + kernel_y.
+                            int input_y = convolution_y + 1 - kernel_y;
+                            if (input_y < 0 || input_y >= input_height) continue;
+                            for (int kernel_x = 0; kernel_x < kernel_width;
+                                 kernel_x++) {
+                                int input_x = convolution_x + 1 - kernel_x;
+                                if (input_x < 0 || input_x >= input_width) continue;
+
+                                long long input_index =
+                                    (((long long)batch * input_channels
+                                      + input_channel) * input_height
+                                     + input_y) * input_width + input_x;
+                                // ConvTranspose2d weight layout is
+                                // (Cin, Cout/groups, Kh, Kw); groups=1.
+                                long long weight_index =
+                                    (((long long)input_channel * output_channels
+                                      + output_channel) * kernel_height
+                                     + kernel_y) * kernel_width + kernel_x;
+                                convolution_value +=
+                                    x[input_index] * weight[weight_index];
+                            }
+                        }
+                    }
+                    pooled_max = fmaxf(pooled_max, convolution_value);
+                }
+            }
+
+            float activated = fminf(fmaxf(pooled_max, -1.0f), 1.0f);
+            spatial_sum += activated;
+        }
+    }
+
+    int spatial_elements = pooled_height * pooled_width;
+    float spatial_mean = spatial_sum / (float)spatial_elements;
+    out[output_index] = tanhf(spatial_mean);
+}
+"""
+
+
+def register(K, torch, ctypes):
+    def ref(x, weight, bias):
+        # Exact get_init_inputs() values: Cin=64, Cout=64, kernel=3,
+        # stride=1, padding=1, pool kernel/stride=2, Hardtanh=[-1, 1].
+        value = torch.nn.functional.conv_transpose2d(
+            x, weight, bias=bias, stride=1, padding=1,
+            output_padding=0, groups=1, dilation=1,
+        )
+        value = torch.nn.functional.max_pool2d(
+            value, kernel_size=2, stride=2, padding=0,
+            dilation=1, ceil_mode=False,
+        )
+        value = torch.nn.functional.hardtanh(value, min_val=-1.0, max_val=1.0)
+        value = torch.mean(value, dim=(2, 3), keepdim=True)
+        return torch.tanh(value)
+
+    def launch(inputs, torch_module):
+        x, weight, bias = inputs
+        batches, input_channels, input_height, input_width = x.shape
+        (weight_input_channels, output_channels,
+         kernel_height, kernel_width) = weight.shape
+        if weight_input_channels != input_channels:
+            raise ValueError("weight input-channel dimension must match x")
+        if bias.numel() != output_channels:
+            raise ValueError("bias size must match output channels")
+
+        # ConvTranspose2d: (I-1)*stride - 2*padding + dilation*(K-1) + 1.
+        convolution_height = input_height + kernel_height - 3
+        convolution_width = input_width + kernel_width - 3
+        pooled_height = (convolution_height - 2) // 2 + 1
+        pooled_width = (convolution_width - 2) // 2 + 1
+        out = torch_module.empty(
+            (batches, output_channels, 1, 1),
+            device=x.device, dtype=x.dtype,
+        )
+        output_elements = batches * output_channels
+        args = [
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_channels),
+            (ctypes.c_int, input_height),
+            (ctypes.c_int, input_width),
+            (ctypes.c_int, output_channels),
+            (ctypes.c_int, kernel_height),
+            (ctypes.c_int, kernel_width),
+            (ctypes.c_int, convolution_height),
+            (ctypes.c_int, convolution_width),
+            (ctypes.c_int, pooled_height),
+            (ctypes.c_int, pooled_width),
+            (ctypes.c_longlong, output_elements),
+        ]
+        grid = ((output_elements + 255) // 256, 1, 1)
+        return out, grid, (256, 1, 1), args
+
+    def initialized_parameters(input_channels, output_channels,
+                               kernel_height, kernel_width):
+        # nn.ConvTranspose2d.reset_parameters uses fan_in=Cout*Kh*Kw for
+        # groups=1, then samples both weight and bias from U(-bound, bound).
+        bound = 1.0 / (output_channels * kernel_height * kernel_width) ** 0.5
+        weight = torch.empty(
+            input_channels, output_channels, kernel_height, kernel_width,
+        ).uniform_(-bound, bound)
+        bias = torch.empty(output_channels).uniform_(-bound, bound)
+        return weight, bias
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            # This first draw exactly matches get_inputs(): rand(128,64,256,256).
+            x = torch.rand(128, 64, 256, 256)
+            weight, bias = initialized_parameters(64, 64, 3, 3)
+            return [x, weight, bias]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            x = torch.randn(3, 5, 13, 17)
+            weight = torch.randn(5, 7, 3, 3) * 2.0
+            bias = torch.randn(7) * 2.0
+            return [x, weight, bias]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            x = torch.rand(5, 7, 15, 19)
+            weight, bias = initialized_parameters(7, 11, 3, 3)
+            return [x, weight, bias]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(2, 4, 11, 15)
+            x[:, :, 0, 0] = 50.0
+            x[:, :, -1, -1] = 100.0
+            weight = torch.rand(4, 6, 3, 3) * 0.05
+            weight[:, :, 1, 1] = 0.5
+            bias = torch.rand(6) * 0.05
+            return [x, weight, bias]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        aligned_weight, aligned_bias = initialized_parameters(4, 8, 3, 3)
+        aligned = [
+            torch_module.rand(1, 4, 16, 32),
+            aligned_weight,
+            aligned_bias,
+        ]
+        misaligned_weight, misaligned_bias = initialized_parameters(3, 5, 3, 3)
+        misaligned = [
+            torch_module.randn(2, 3, 7, 11),
+            misaligned_weight,
+            misaligned_bias,
+        ]
+        return [("p_aligned", aligned), ("p_misaligned", misaligned)]
+
+    K.PROBLEMS["L2p10_convtranspose2d_maxpoo"] = dict(
+        kb_file="10_ConvTranspose2d_MaxPool_Hardtanh_Mean_Tanh.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="l2p10_convtranspose2d_maxpool_hardtanh_mean_tanh_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p11_convtranspose2d_batchn.py

@@ -0,0 +1,320 @@
+"""Correct, mutation-friendly substrate for KernelBench level2 problem 11."""
+
+
+def register(K, torch, ctypes):
+    cuda_source = r"""
+#include <cuda_fp16.h>
+
+__global__ void L2p11_convtranspose2d_batchn_kernel(
+        const float* x, float* out, float* workspace,
+        const float* weight, const float* bias,
+        int batches, int input_height, int input_width,
+        int conv_height, int conv_width, int pool_height, int pool_width) {
+    int tid = threadIdx.x;
+    long long conv_spatial = (long long)conv_height * conv_width;
+    long long pool_spatial = (long long)pool_height * pool_width;
+    long long conv_elements = (long long)batches * 128 * conv_spatial;
+    long long pool_elements = (long long)batches * 128 * pool_spatial;
+
+    // ConvTranspose2d: Cin=64, Cout=128, K=5, stride=1, padding=1,
+    // output_padding=0, groups=1, dilation=1, and bias=True.
+    for (long long linear = tid; linear < conv_elements; linear += blockDim.x) {
+        long long position = linear;
+        int ox = (int)(position % conv_width);
+        position /= conv_width;
+        int oy = (int)(position % conv_height);
+        position /= conv_height;
+        int oc = (int)(position % 128);
+        int n = (int)(position / 128);
+
+        float sum = bias[oc];
+        for (int ic = 0; ic < 64; ic++) {
+            for (int ky = 0; ky < 5; ky++) {
+                int iy = oy + 1 - ky;
+                if (iy < 0 || iy >= input_height) continue;
+                for (int kx = 0; kx < 5; kx++) {
+                    int ix = ox + 1 - kx;
+                    if (ix < 0 || ix >= input_width) continue;
+                    long long xi = (((long long)n * 64 + ic) * input_height
+                                    + iy) * input_width + ix;
+                    // ConvTranspose2d weights are [Cin, Cout, Kh, Kw].
+                    long long wi = (((long long)ic * 128 + oc) * 5 + ky) * 5 + kx;
+                    sum += x[xi] * weight[wi];
+                }
+            }
+        }
+        workspace[linear] = sum;
+    }
+    __syncthreads(); // sync-after-convolution
+
+    // BatchNorm2d in training mode: statistics span N,H,W independently for
+    // each channel, and the forward variance is the biased population value.
+    __shared__ float reduce_sum[256];
+    __shared__ float reduce_sq[256];
+    for (int c = 0; c < 128; c++) {
+        float local_sum = 0.0f;
+        float local_sq = 0.0f;
+        long long samples = (long long)batches * conv_spatial;
+        for (long long sample = tid; sample < samples; sample += blockDim.x) {
+            long long n = sample / conv_spatial;
+            long long s = sample - n * conv_spatial;
+            float value = workspace[(n * 128 + c) * conv_spatial + s];
+            local_sum += value;
+            local_sq += value * value;
+        }
+        reduce_sum[tid] = local_sum;
+        reduce_sq[tid] = local_sq;
+        __syncthreads(); // sync-after-batchnorm-partials
+        for (int width = 128; width > 0; width >>= 1) {
+            if (tid < width) {
+                reduce_sum[tid] += reduce_sum[tid + width];
+                reduce_sq[tid] += reduce_sq[tid + width];
+            }
+            __syncthreads(); // sync-during-batchnorm-reduction
+        }
+        float mean = reduce_sum[0] / (float)samples;
+        float variance = reduce_sq[0] / (float)samples - mean * mean;
+        variance = fmaxf(variance, 0.0f);
+        float inv_std = rsqrtf(variance + 1.0e-5f);
+        for (long long sample = tid; sample < samples; sample += blockDim.x) {
+            long long n = sample / conv_spatial;
+            long long s = sample - n * conv_spatial;
+            long long index = (n * 128 + c) * conv_spatial + s;
+            workspace[index] = tanhf((workspace[index] - mean) * inv_std);
+        }
+        __syncthreads(); // sync-after-batchnorm-and-tanh
+    }
+
+    // MaxPool2d defaults: kernel=2, stride=2, padding=0, dilation=1,
+    // ceil_mode=False.  conv_height and conv_width are even here.
+    for (long long linear = tid; linear < pool_elements; linear += blockDim.x) {
+        long long position = linear;
+        int px = (int)(position % pool_width);
+        position /= pool_width;
+        int py = (int)(position % pool_height);
+        position /= pool_height;
+        int c = (int)(position % 128);
+        int n = (int)(position / 128);
+        long long base = ((long long)n * 128 + c) * conv_spatial
+                         + (long long)(2 * py) * conv_width + 2 * px;
+        float best = workspace[base];
+        best = fmaxf(best, workspace[base + 1]);
+        best = fmaxf(best, workspace[base + conv_width]);
+        best = fmaxf(best, workspace[base + conv_width + 1]);
+        out[linear] = best;
+    }
+    __syncthreads(); // sync-after-maxpool
+
+    // GroupNorm: 8 groups, hence 16 channels per group.  Statistics are per
+    // sample and group, with biased variance and affine defaults gamma=1,beta=0.
+    for (int ng = 0; ng < batches * 8; ng++) {
+        int n = ng / 8;
+        int group = ng - n * 8;
+        long long group_samples = 16 * pool_spatial;
+        float local_sum = 0.0f;
+        float local_sq = 0.0f;
+        for (long long i = tid; i < group_samples; i += blockDim.x) {
+            int channel_in_group = (int)(i / pool_spatial);
+            long long s = i - (long long)channel_in_group * pool_spatial;
+            int c = group * 16 + channel_in_group;
+            float value = out[((long long)n * 128 + c) * pool_spatial + s];
+            local_sum += value;
+            local_sq += value * value;
+        }
+        reduce_sum[tid] = local_sum;
+        reduce_sq[tid] = local_sq;
+        __syncthreads(); // sync-after-groupnorm-partials
+        for (int width = 128; width > 0; width >>= 1) {
+            if (tid < width) {
+                reduce_sum[tid] += reduce_sum[tid + width];
+                reduce_sq[tid] += reduce_sq[tid + width];
+            }
+            __syncthreads(); // sync-during-groupnorm-reduction
+        }
+        float mean = reduce_sum[0] / (float)group_samples;
+        float variance = reduce_sq[0] / (float)group_samples - mean * mean;
+        variance = fmaxf(variance, 0.0f);
+        float inv_std = rsqrtf(variance + 1.0e-5f);
+        for (long long i = tid; i < group_samples; i += blockDim.x) {
+            int channel_in_group = (int)(i / pool_spatial);
+            long long s = i - (long long)channel_in_group * pool_spatial;
+            int c = group * 16 + channel_in_group;
+            long long index = ((long long)n * 128 + c) * pool_spatial + s;
+            out[index] = (out[index] - mean) * inv_std;
+        }
+        __syncthreads(); // sync-after-groupnorm-output
+    }
+}
+"""
+
+    # get_init_inputs() fixes (64,128,5,1,1,8,8).  The `groups` argument is
+    # not passed to ConvTranspose2d in the KB model and therefore does not
+    # affect it. Freeze the ordinary default ConvTranspose2d initialization.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        layer = torch.nn.ConvTranspose2d(64, 128, 5, stride=1, padding=1)
+        frozen_weight = layer.weight.detach().cpu().contiguous()
+        frozen_bias = layer.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        pair = device_parameters.get(key)
+        if pair is None:
+            pair = (frozen_weight.to(device=x.device, dtype=x.dtype),
+                    frozen_bias.to(device=x.device, dtype=x.dtype))
+            device_parameters[key] = pair
+        return pair
+
+    def ref(x):
+        weight, bias = parameters_for(x)
+        value = torch.nn.functional.conv_transpose2d(
+            x, weight, bias=bias, stride=1, padding=1,
+            output_padding=0, groups=1, dilation=1)
+        value = torch.nn.functional.batch_norm(
+            value, running_mean=None, running_var=None,
+            weight=value.new_ones((128,)), bias=value.new_zeros((128,)),
+            training=True, momentum=0.1, eps=1e-5)
+        value = torch.tanh(value)
+        value = torch.nn.functional.max_pool2d(
+            value, kernel_size=2, stride=2, padding=0, dilation=1,
+            ceil_mode=False)
+        return torch.nn.functional.group_norm(
+            value, num_groups=8, weight=value.new_ones((128,)),
+            bias=value.new_zeros((128,)), eps=1e-5)
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        batches, channels, input_height, input_width = x.shape
+        if channels != 64:
+            raise ValueError("level2 problem 11 requires 64 input channels")
+        conv_height = input_height + 2
+        conv_width = input_width + 2
+        pool_height = conv_height // 2
+        pool_width = conv_width // 2
+        workspace = torch_module.empty(
+            (batches, 128, conv_height, conv_width),
+            device=x.device, dtype=x.dtype)
+        out = torch_module.empty(
+            (batches, 128, pool_height, pool_width),
+            device=x.device, dtype=x.dtype)
+        # Keep allocations and frozen parameters alive through asynchronous use.
+        weight, bias = parameters_for(x)
+        out._substrate_keepalive = (workspace, weight, bias)
+        args = [
+            (ctypes.c_void_p, workspace.data_ptr()),
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, bias.data_ptr()),
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_height),
+            (ctypes.c_int, input_width),
+            (ctypes.c_int, conv_height),
+            (ctypes.c_int, conv_width),
+            (ctypes.c_int, pool_height),
+            (ctypes.c_int, pool_width),
+        ]
+        return out, (1, 1, 1), (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(512, 64, 32, 32)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(3, 64, 9, 13)]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(5, 64, 11, 15)]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(2, 64, 10, 14)
+            x[:, :, 0, 0] = 25.0
+            x[:, :, -1, -1] = 50.0
+            return [x]
+
+        def t4_zero_variance_ties(trial):
+            torch.manual_seed(5000 + trial)
+            return [torch.zeros(7, 64, 7, 9)]
+
+        def t5_lane_alternating_magnitude(trial):
+            torch.manual_seed(6000 + trial)
+            x = torch.empty(5, 64, 13, 17)
+            positions = torch.arange(x.numel(), dtype=x.dtype).reshape_as(x)
+            x.copy_(torch.where((positions.to(torch.int64) & 1) == 0,
+                                torch.full_like(x, 1.0e-4),
+                                torch.full_like(x, 300.0)))
+            return [x]
+
+        def t6_positive_positional_spikes(trial):
+            torch.manual_seed(7000 + trial)
+            y = torch.arange(15, dtype=torch.float32).view(1, 1, 15, 1)
+            xcoord = torch.arange(19, dtype=torch.float32).view(1, 1, 1, 19)
+            channel = torch.arange(64, dtype=torch.float32).view(1, 64, 1, 1)
+            x = 100.0 + 3.0 * y + 5.0 * xcoord + (channel % 7) * 11.0
+            x = x.expand(4, -1, -1, -1).clone()
+            x[:, :, ::4, 1::5] = 1200.0
+            return [x]
+
+        def t7_positive_near_constant_quantization(trial):
+            torch.manual_seed(8000 + trial)
+            y = torch.arange(10, dtype=torch.float32).view(1, 1, 10, 1)
+            xcoord = torch.arange(14, dtype=torch.float32).view(1, 1, 1, 14)
+            channel = torch.arange(64, dtype=torch.float32).view(1, 64, 1, 1)
+            batch = torch.arange(3, dtype=torch.float32).view(3, 1, 1, 1)
+            x = (192.0 + 0.03125 * ((3.0 * y + 5.0 * xcoord
+                                    + channel + 7.0 * batch) % 17.0))
+            return [x.contiguous()]
+
+        def t8_batch_lane_stripes(trial):
+            torch.manual_seed(9000 + trial)
+            batch = torch.arange(129, dtype=torch.int64).view(129, 1, 1, 1)
+            channel = torch.arange(64, dtype=torch.int64).view(1, 64, 1, 1)
+            y = torch.arange(2, dtype=torch.int64).view(1, 1, 2, 1)
+            xcoord = torch.arange(2, dtype=torch.int64).view(1, 1, 1, 2)
+            stripe = (batch + channel + 2 * y + xcoord) & 1
+            x = torch.where(stripe == 0,
+                            torch.full(stripe.shape, 1.0e-3),
+                            torch.full(stripe.shape, 900.0))
+            return [x]
+
+        def t9_tied_pool_spikes(trial):
+            torch.manual_seed(10000 + trial)
+            x = torch.full((4, 64, 6, 10), 0.125)
+            x[:, ::2, ::2, ::2] = 700.0
+            x[:, 1::2, 1::2, 1::2] = 700.0
+            x[:, :, 2:4, 4:6] = 1400.0
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+            ("T4_zero_variance_ties", 1, t4_zero_variance_ties),
+            ("T5_lane_alternating_magnitude", 1, t5_lane_alternating_magnitude),
+            ("T6_positive_positional_spikes", 1, t6_positive_positional_spikes),
+            ("T7_positive_near_constant_quantization", 1, t7_positive_near_constant_quantization),
+            ("T8_batch_lane_stripes", 1, t8_batch_lane_stripes),
+            ("T9_tied_pool_spikes", 1, t9_tied_pool_spikes),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(2, 64, 14, 14)]),
+            ("p_misaligned", [torch_module.randn(1, 64, 7, 11)]),
+        ]
+
+    K.PROBLEMS["L2p11_convtranspose2d_batchn"] = dict(
+        kb_file="11_ConvTranspose2d_BatchNorm_Tanh_MaxPool_GroupNorm.py",
+        cuda=cuda_source,
+        kernel_name="L2p11_convtranspose2d_batchn_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p12_gemm_multiply_leakyrel.py

@@ -0,0 +1,159 @@
+"""Correct, mutation-friendly substrate for KernelBench level2 problem 12."""
+
+
+def register(K, torch, ctypes):
+    cuda_source = r"""
+#include <cuda_fp16.h>
+
+__global__ void gemm_multiply_leakyrelu_kernel(
+        const float* x, float* out, const float* weight, const float* bias,
+        int rows, int input_features, int output_features,
+        float multiplier, float negative_slope) {
+    long long output_index =
+        (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    long long output_elements = (long long)rows * output_features;
+    if (output_index >= output_elements) return;
+
+    int row = (int)(output_index / output_features);
+    int output_feature = (int)(output_index % output_features);
+
+    // nn.Linear computes x @ weight.T + bias.  Keeping the dot product
+    // explicit makes indexing, accumulation, bias, and activation mutations
+    // independently visible.
+    float accumulator = 0.0f;
+    for (int input_feature = 0;
+         input_feature < input_features;
+         input_feature++) {
+        long long input_index =
+            (long long)row * input_features + input_feature;
+        long long weight_index =
+            (long long)output_feature * input_features + input_feature;
+        accumulator += x[input_index] * weight[weight_index];
+    }
+
+    float gemm_value = accumulator + bias[output_feature];
+    float multiplied_value = gemm_value * multiplier;
+    float activated_value = multiplied_value >= 0.0f
+        ? multiplied_value
+        : multiplied_value * negative_slope;
+    out[output_index] = activated_value;
+}
+"""
+
+    input_features = 8192
+    output_features = 8192
+    multiplier = 2.0
+    negative_slope = 0.1
+
+    # The KernelBench module owns randomly initialized Linear parameters.
+    # Freeze one normal reset_parameters result, while preserving the caller's
+    # RNG state, then use the identical parameters in both implementations.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        linear = torch.nn.Linear(input_features, output_features, bias=True)
+        frozen_weight = linear.weight.detach().cpu().contiguous()
+        frozen_bias = linear.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        parameters = device_parameters.get(key)
+        if parameters is None:
+            parameters = (
+                frozen_weight.to(device=x.device, dtype=x.dtype),
+                frozen_bias.to(device=x.device, dtype=x.dtype),
+            )
+            device_parameters[key] = parameters
+        return parameters
+
+    def ref(x):
+        weight, bias = parameters_for(x)
+        value = torch.nn.functional.linear(x, weight, bias)
+        value = value * multiplier
+        return torch.nn.functional.leaky_relu(
+            value, negative_slope=negative_slope
+        )
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        if x.ndim != 2 or x.shape[1] != input_features:
+            raise ValueError(
+                "expected a 2D input whose second dimension is 8192"
+            )
+
+        rows = x.shape[0]
+        weight, bias = parameters_for(x)
+        out = torch_module.empty(
+            (rows, output_features), device=x.device, dtype=x.dtype
+        )
+        output_elements = out.numel()
+        args = [
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, bias.data_ptr()),
+            (ctypes.c_int, rows),
+            (ctypes.c_int, input_features),
+            (ctypes.c_int, output_features),
+            (ctypes.c_float, multiplier),
+            (ctypes.c_float, negative_slope),
+        ]
+        grid = ((output_elements + 255) // 256, 1, 1)
+        return out, grid, (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(1024, 8192)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(17, 8192) * 0.05]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(13, 8192)]
+
+        def t3_positive_tail_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(9, 8192)
+            x[:, -1] = 100.0
+            x[-1, -32:] = 50.0
+            return [x]
+
+        def t4_positive_first_feature_overflow(trial):
+            torch.manual_seed(5000 + trial)
+            x = torch.zeros(1, 8192)
+            x[:, 0] = 2.0e7
+            return [x]
+
+        def t5_positive_last_feature_overflow(trial):
+            torch.manual_seed(6000 + trial)
+            x = torch.zeros(3, 8192)
+            x[:, -1] = 2.0e7
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_tail_spikes", 1, t3_positive_tail_spikes),
+            ("T4_positive_first_feature_overflow", 1, t4_positive_first_feature_overflow),
+            ("T5_positive_last_feature_overflow", 1, t5_positive_last_feature_overflow),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(16, 8192)]),
+            ("p_misaligned", [torch_module.randn(3, 8192) * 0.05]),
+        ]
+
+    K.PROBLEMS["L2p12_gemm_multiply_leakyrel"] = dict(
+        kb_file="12_Gemm_Multiply_LeakyReLU.py",
+        cuda=cuda_source,
+        kernel_name="gemm_multiply_leakyrelu_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p13_convtranspose3d_mean_a.py

@@ -0,0 +1,260 @@
+"""Mutation-friendly substrate for KernelBench level2 problem 13."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+#include <math_constants.h>
+
+__global__ void l2p13_convtranspose3d_mean_a_kernel(
+        const float* x, float* out, const float* weight,
+        const float* convolution_bias, const float* added_bias,
+        int batches, int input_depth, int height, int width,
+        long long spatial_rows) {
+    long long row = (long long)blockIdx.x;
+    int output_channel = threadIdx.x;
+    if (row >= spatial_rows || output_channel >= 64) return;
+
+    long long position = row;
+    int output_x = (int)(position % width);
+    position /= width;
+    int output_y = (int)(position % height);
+    int batch = (int)(position / height);
+
+    // One block owns all 64 channels at one (batch, y, x) location.  Each
+    // thread first computes the depth-mean of its transposed-convolution
+    // channel.  For stride=1 and padding=1, iz contributes to oz=iz-1+kz.
+    float depth_sum = 0.0f;
+    for (int output_z = 0; output_z < input_depth; output_z++) {
+        float convolution_sum = 0.0f;
+        for (int input_channel = 0; input_channel < 16; input_channel++) {
+            for (int kernel_z = 0; kernel_z < 3; kernel_z++) {
+                int input_z = output_z + 1 - kernel_z;
+                if (input_z < 0 || input_z >= input_depth) continue;
+                for (int kernel_y = 0; kernel_y < 3; kernel_y++) {
+                    int input_y = output_y + 1 - kernel_y;
+                    if (input_y < 0 || input_y >= height) continue;
+                    for (int kernel_x = 0; kernel_x < 3; kernel_x++) {
+                        int input_x = output_x + 1 - kernel_x;
+                        if (input_x < 0 || input_x >= width) continue;
+                        long long input_index =
+                            ((((long long)batch * 16 + input_channel)
+                               * input_depth + input_z) * height + input_y)
+                             * width + input_x;
+                        // ConvTranspose3d weights use [Cin, Cout, Kd, Kh, Kw].
+                        long long weight_index =
+                            (((((long long)input_channel * 64 + output_channel)
+                                * 3 + kernel_z) * 3 + kernel_y) * 3 + kernel_x);
+                        convolution_sum += x[input_index] * weight[weight_index];
+                    }
+                }
+            }
+        }
+        depth_sum += convolution_sum + convolution_bias[output_channel];
+    }
+
+    __shared__ float logits[64];
+    __shared__ float probabilities[64];
+    __shared__ float channel_max;
+    __shared__ float exponential_sum;
+    logits[output_channel] = depth_sum / (float)input_depth
+                           + added_bias[output_channel];
+    __syncthreads(); // sync-after-logits
+
+    if (output_channel == 0) {
+        float maximum = -CUDART_INF_F;
+        for (int channel = 0; channel < 64; channel++) {
+            maximum = fmaxf(maximum, logits[channel]);
+        }
+        channel_max = maximum;
+    }
+    __syncthreads(); // sync-after-maximum
+
+    probabilities[output_channel] = expf(logits[output_channel] - channel_max);
+    __syncthreads(); // sync-after-exponentials
+
+    if (output_channel == 0) {
+        float sum = 0.0f;
+        for (int channel = 0; channel < 64; channel++) {
+            sum += probabilities[channel];
+        }
+        exponential_sum = sum;
+    }
+    __syncthreads(); // sync-after-sum
+
+    float probability = probabilities[output_channel] / exponential_sum;
+    // Rewrite row-major [B,H,W,C] indexing into contiguous [B,C,1,H,W].
+    long long plane = (long long)height * width;
+    long long output_spatial = row % plane;
+    long long output_batch = row / plane;
+    long long output_index =
+        (output_batch * 64 + output_channel) * plane + output_spatial;
+    out[output_index] = tanhf(probability) * 2.0f;
+}
+"""
+
+
+def register(K, torch, ctypes):
+    # Match construction order exactly: ConvTranspose3d initializes its weight
+    # and bias first, then Model initializes its separate broadcast bias.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        convolution = torch.nn.ConvTranspose3d(
+            16, 64, 3, stride=1, padding=1
+        )
+        frozen_weight = convolution.weight.detach().cpu().contiguous()
+        frozen_convolution_bias = convolution.bias.detach().cpu().contiguous()
+        frozen_added_bias = torch.randn(1, 64, 1, 1, 1).cpu().contiguous()
+
+    parameter_cache = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        parameters = parameter_cache.get(key)
+        if parameters is None:
+            parameters = (
+                frozen_weight.to(device=x.device, dtype=x.dtype),
+                frozen_convolution_bias.to(device=x.device, dtype=x.dtype),
+                frozen_added_bias.to(device=x.device, dtype=x.dtype),
+            )
+            parameter_cache[key] = parameters
+        return parameters
+
+    def ref(x):
+        weight, convolution_bias, added_bias = parameters_for(x)
+        value = torch.nn.functional.conv_transpose3d(
+            x, weight, bias=convolution_bias, stride=1, padding=1,
+            output_padding=0, groups=1, dilation=1,
+        )
+        value = value.mean(dim=2, keepdim=True)
+        value = value + added_bias
+        value = torch.softmax(value, dim=1)
+        value = torch.tanh(value)
+        return value * 2.0
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        batches, input_channels, input_depth, height, width = x.shape
+        if input_channels != 16:
+            raise ValueError("level2 problem 13 requires exactly 16 input channels")
+        if input_depth < 1:
+            raise ValueError("level2 problem 13 requires nonempty depth")
+
+        out = torch_module.empty(
+            (batches, 64, 1, height, width), device=x.device, dtype=x.dtype
+        )
+        weight, convolution_bias, added_bias = parameters_for(x)
+        spatial_rows = batches * height * width
+        args = [
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, convolution_bias.data_ptr()),
+            (ctypes.c_void_p, added_bias.data_ptr()),
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_depth),
+            (ctypes.c_int, height),
+            (ctypes.c_int, width),
+            (ctypes.c_longlong, spatial_rows),
+        ]
+        return out, (spatial_rows, 1, 1), (64, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(16, 16, 32, 128, 128)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(2, 16, 5, 7, 9)]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(3, 16, 6, 10, 13)]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(1, 16, 7, 9, 11)
+            x[:, :, 0, 0, 0] = 25.0
+            x[:, :, 3, 4, 5] = 50.0
+            x[:, :, -1, -1, -1] = 100.0
+            return [x]
+
+        def t4_reduction_endpoint_mass(trial):
+            torch.manual_seed(5000 + trial)
+            x = torch.full((1, 16, 2, 3, 5), 1.0e-3)
+            x[:, 0, 0, :, :] = 1200.0
+            x[:, -1, -1, :, :] = 2400.0
+            return [x]
+
+        def endpoint_channel_input(target, seed):
+            # With a single voxel only the centre kernel coefficient is used.
+            # A nonnegative direction away from the other channels makes the
+            # selected endpoint channel dominate without cancellation-prone
+            # signed, high-magnitude inputs.
+            torch.manual_seed(seed)
+            centre = frozen_weight[:, :, 1, 1, 1]
+            direction = (centre[:, target] - centre.mean(dim=1)).clamp_min(0)
+            direction = direction + torch.rand(16) * 1.0e-6
+            return [direction.mul(100000.0).reshape(1, 16, 1, 1, 1)]
+
+        def t5_channel0_crosswarp_extreme(trial):
+            return endpoint_channel_input(0, 6000 + trial)
+
+        def t6_channel63_crosswarp_extreme(trial):
+            return endpoint_channel_input(63, 7000 + trial)
+
+        def t7_spatial_kernel_endpoint_mass(trial):
+            torch.manual_seed(8000 + trial)
+            x = torch.full((1, 16, 3, 3, 3), 1.0e-3)
+            # Opposite corners exercise both the first and last iterations of
+            # each 3-tap spatial kernel loop at boundary output positions.
+            x[:, :, 0, 0, 0] = 3000.0
+            x[:, :, -1, -1, -1] = 1500.0
+            return [x]
+
+        def t8_depth_endpoint_planes(trial):
+            torch.manual_seed(9000 + trial)
+            x = torch.full((1, 16, 3, 2, 3), 1.0e-3)
+            # Unequal endpoint planes make dropping either an output-depth or
+            # kernel-depth endpoint change the mean substantially.
+            x[:, :, 0, :, :] = 3000.0
+            x[:, :, -1, :, :] = 750.0
+            return [x]
+
+        def t9_alternating_lane_contrast(trial):
+            torch.manual_seed(10000 + trial)
+            x = torch.full((1, 16, 1, 3, 5), 1.0e-3)
+            # High/low input-channel neighbours create sharply different
+            # partial sums while remaining same-sign for stable accumulation.
+            x[:, 0::2, :, :, :] = 3000.0
+            x[:, 1::2, :, :, :] = 1.0e-4
+            x[:, :, :, 0::2, 0::2] *= 0.25
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+            ("T4_reduction_endpoint_mass", 1, t4_reduction_endpoint_mass),
+            ("T5_channel0_crosswarp_extreme", 1, t5_channel0_crosswarp_extreme),
+            ("T6_channel63_crosswarp_extreme", 1, t6_channel63_crosswarp_extreme),
+            ("T7_spatial_kernel_endpoint_mass", 1, t7_spatial_kernel_endpoint_mass),
+            ("T8_depth_endpoint_planes", 1, t8_depth_endpoint_planes),
+            ("T9_alternating_lane_contrast", 1, t9_alternating_lane_contrast),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(1, 16, 4, 8, 8)]),
+            ("p_misaligned", [torch_module.randn(2, 16, 5, 7, 9)]),
+        ]
+
+    K.PROBLEMS["L2p13_convtranspose3d_mean_a"] = dict(
+        kb_file="13_ConvTranspose3d_Mean_Add_Softmax_Tanh_Scaling.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="l2p13_convtranspose3d_mean_a_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p14_gemm_divide_sum_scalin.py

@@ -0,0 +1,156 @@
+"""Mutation-friendly substrate for KernelBench level2 problem 14."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void gemm_divide_sum_scaling_kernel(
+        const float* x, float* out, const float* weight,
+        int batch_size, int input_size, int hidden_size) {
+    int batch = blockIdx.x;
+    int tid = threadIdx.x;
+    if (batch >= batch_size) return;
+
+    // Each thread computes complete GEMM entries for a strided subset of
+    // hidden columns. Keeping the inner-product loop explicit provides clear
+    // mutation sites for both bounds and the two matrix strides.
+    float thread_sum = 0.0f;
+    for (int hidden = tid; hidden < hidden_size; hidden += blockDim.x) {
+        float gemm_value = 0.0f;
+        for (int inner = 0; inner < input_size; inner++) {
+            long long x_index = (long long)batch * input_size + inner;
+            long long weight_index =
+                (long long)hidden * input_size + inner;
+            gemm_value += x[x_index] * weight[weight_index];
+        }
+        float divided_value = gemm_value / 2.0f;
+        thread_sum += divided_value;
+    }
+
+    __shared__ float partial_sums[256];
+    partial_sums[tid] = thread_sum;
+    __syncthreads(); // sync-after-partial-store
+
+    for (int width = 128; width > 0; width >>= 1) {
+        if (tid < width) {
+            partial_sums[tid] =
+                partial_sums[tid] + partial_sums[tid + width];
+        }
+        __syncthreads(); // sync-after-reduction-step
+    }
+
+    if (tid == 0) {
+        out[batch] = partial_sums[0] * 1.5f;
+    }
+}
+"""
+
+
+def register(K, torch, ctypes):
+    # Model.__init__ calls torch.randn(8192, 8192) exactly once. Freeze an
+    # ordinary seed-0 realization so the implicit parameter is identical in
+    # the reference and device paths without perturbing suite RNG state.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        frozen_weight = torch.randn(8192, 8192).contiguous()
+
+    device_weights = {}
+
+    def weight_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        weight = device_weights.get(key)
+        if weight is None:
+            weight = frozen_weight.to(device=x.device, dtype=x.dtype)
+            device_weights[key] = weight
+        return weight
+
+    def ref(x):
+        # Forward is matmul, true division, sum over hidden dim with keepdim,
+        # then multiplication by get_init_inputs()' scaling_factor=1.5.
+        value = torch.matmul(x, weight_for(x).T)
+        value = value / 2
+        value = torch.sum(value, dim=1, keepdim=True)
+        return value * 1.5
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        if x.ndim != 2 or x.shape[1] != 8192:
+            raise ValueError("this substrate requires input shape (batch, 8192)")
+
+        batch_size, input_size = x.shape
+        hidden_size = 8192
+        out = torch_module.empty(
+            (batch_size, 1), device=x.device, dtype=x.dtype)
+        args = [
+            (ctypes.c_void_p, weight_for(x).data_ptr()),
+            (ctypes.c_int, batch_size),
+            (ctypes.c_int, input_size),
+            (ctypes.c_int, hidden_size),
+        ]
+        return out, (batch_size, 1, 1), (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(1024, 8192)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(9, 8192) * 0.1]
+
+        def t2_misaligned_batch(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(37, 8192)]
+
+        def t3_positive_tail_spike(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(5, 8192)
+            x[:, -1] = 100.0
+            return [x]
+
+        def t4_positive_structured_overflow(trial):
+            torch.manual_seed(5000 + trial)
+            position = torch.linspace(0.0, 1.0, 8192)
+            x = torch.stack([
+                torch.full((8192,), 32.0),
+                16.0 + 32.0 * position,
+                torch.where(
+                    torch.arange(8192) % 2 == 0,
+                    torch.tensor(8.0),
+                    torch.tensor(56.0)),
+            ])
+            return [x]
+
+        def t5_positive_periodic_spikes(trial):
+            torch.manual_seed(6000 + trial)
+            x = torch.full((7, 8192), 64.0)
+            x[:, ::257] = 2048.0
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned_batch", 1, t2_misaligned_batch),
+            ("T3_positive_tail_spike", 1, t3_positive_tail_spike),
+            ("T4_positive_structured_overflow", 1,
+             t4_positive_structured_overflow),
+            ("T5_positive_periodic_spikes", 1,
+             t5_positive_periodic_spikes),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(16, 8192)]),
+            ("p_misaligned", [torch_module.randn(7, 8192) * 0.1]),
+        ]
+
+    K.PROBLEMS["L2p14_gemm_divide_sum_scalin"] = dict(
+        kb_file="14_Gemm_Divide_Sum_Scaling.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="gemm_divide_sum_scaling_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p15_convtranspose3d_batchn.py

@@ -0,0 +1,298 @@
+"""Mutation-friendly substrate for KernelBench level 2 problem 15."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void L2p15_convtranspose3d_batchn_kernel(
+        const float* x, float* out, const float* weight, const float* bias,
+        int batches, int input_depth, int input_height, int input_width,
+        int output_depth, int output_height, int output_width) {
+    int output_channel = blockIdx.x;
+    int tid = threadIdx.x;
+    long long input_spatial =
+        (long long)input_depth * input_height * input_width;
+    long long output_spatial =
+        (long long)output_depth * output_height * output_width;
+    long long channel_elements = (long long)batches * output_spatial;
+    long long passes = (channel_elements + 255) / 256;
+    __shared__ float partial[256];
+
+    // First materialize ConvTranspose3d.  Its weight layout is
+    // [input_channel, output_channel, kz, ky, kx].
+    float local_sum = 0.0f;
+    for (long long pass = 0; pass < passes; pass++) {
+        long long channel_index = pass * 256 + tid;
+        if (channel_index < channel_elements) {
+            int batch = (int)(channel_index / output_spatial);
+            long long spatial_index = channel_index % output_spatial;
+            int output_x = (int)(spatial_index % output_width);
+            spatial_index /= output_width;
+            int output_y = (int)(spatial_index % output_height);
+            int output_z = (int)(spatial_index / output_height);
+
+            float value = bias[output_channel];
+            for (int input_channel = 0; input_channel < 16; input_channel++) {
+                for (int kernel_z = 0; kernel_z < 3; kernel_z++) {
+                    int z_numerator = output_z + 1 - kernel_z;
+                    if (z_numerator < 0 || (z_numerator & 1)) continue;
+                    int input_z = z_numerator / 2;
+                    if (input_z >= input_depth) continue;
+                    for (int kernel_y = 0; kernel_y < 3; kernel_y++) {
+                        int y_numerator = output_y + 1 - kernel_y;
+                        if (y_numerator < 0 || (y_numerator & 1)) continue;
+                        int input_y = y_numerator / 2;
+                        if (input_y >= input_height) continue;
+                        for (int kernel_x = 0; kernel_x < 3; kernel_x++) {
+                            int x_numerator = output_x + 1 - kernel_x;
+                            if (x_numerator < 0 || (x_numerator & 1)) continue;
+                            int input_x = x_numerator / 2;
+                            if (input_x >= input_width) continue;
+
+                            long long input_index =
+                                (long long)batch * 16 * input_spatial
+                                + (long long)input_channel * input_spatial
+                                + ((long long)input_z * input_height + input_y)
+                                  * input_width + input_x;
+                            long long weight_index =
+                                (((((long long)input_channel * 32
+                                    + output_channel) * 3 + kernel_z) * 3
+                                    + kernel_y) * 3 + kernel_x);
+                            value += x[input_index] * weight[weight_index];
+                        }
+                    }
+                }
+            }
+            long long output_index =
+                (long long)batch * 32 * output_spatial
+                + (long long)output_channel * output_spatial
+                + channel_index % output_spatial;
+            out[output_index] = value;
+            local_sum += value;
+        }
+    }
+    partial[tid] = local_sum;
+    __syncthreads(); // sync-after-global-sum-store
+    for (int offset = 128; offset > 0; offset >>= 1) {
+        if (tid < offset) { partial[tid] += partial[tid + offset]; }
+        __syncthreads(); // sync-during-global-sum-reduction
+    }
+    float global_mean = partial[0] / (float)channel_elements;
+
+    // BatchNorm3d uses the biased, population variance for its output.
+    float local_square_deviation = 0.0f;
+    for (long long pass = 0; pass < passes; pass++) {
+        long long channel_index = pass * 256 + tid;
+        if (channel_index < channel_elements) {
+            int batch = (int)(channel_index / output_spatial);
+            long long spatial_index = channel_index % output_spatial;
+            long long output_index =
+                (long long)batch * 32 * output_spatial
+                + (long long)output_channel * output_spatial + spatial_index;
+            float centered = out[output_index] - global_mean;
+            local_square_deviation += centered * centered;
+        }
+    }
+    partial[tid] = local_square_deviation;
+    __syncthreads(); // sync-after-variance-store
+    for (int offset = 128; offset > 0; offset >>= 1) {
+        if (tid < offset) { partial[tid] += partial[tid + offset]; }
+        __syncthreads(); // sync-during-variance-reduction
+    }
+    float inverse_std =
+        rsqrtf(partial[0] / (float)channel_elements + 1.0e-5f);
+    __syncthreads(); // sync-before-sample-loop
+
+    // Subtracting each sample's spatial mean after BatchNorm cancels the
+    // convolution bias, BN beta, and global BN mean.  Default BN gamma is 1.
+    long long sample_passes = (output_spatial + 255) / 256;
+    for (int batch = 0; batch < batches; batch++) {
+        float local_sample_sum = 0.0f;
+        long long sample_base =
+            (long long)batch * 32 * output_spatial
+            + (long long)output_channel * output_spatial;
+        for (long long pass = 0; pass < sample_passes; pass++) {
+            long long spatial_index = pass * 256 + tid;
+            if (spatial_index < output_spatial) {
+                local_sample_sum += out[sample_base + spatial_index];
+            }
+        }
+        partial[tid] = local_sample_sum;
+        __syncthreads(); // sync-after-sample-sum-store
+        for (int offset = 128; offset > 0; offset >>= 1) {
+            if (tid < offset) { partial[tid] += partial[tid + offset]; }
+            __syncthreads(); // sync-during-sample-sum-reduction
+        }
+        float sample_mean = partial[0] / (float)output_spatial;
+        __syncthreads(); // sync-before-sample-write
+        for (long long pass = 0; pass < sample_passes; pass++) {
+            long long spatial_index = pass * 256 + tid;
+            if (spatial_index < output_spatial) {
+                float value = out[sample_base + spatial_index];
+                out[sample_base + spatial_index] =
+                    (value - sample_mean) * inverse_std;
+            }
+        }
+        __syncthreads(); // sync-after-sample-write
+    }
+}
+"""
+
+
+def register(K, torch, ctypes):
+    """Register the device-only kernel and deterministic input families."""
+
+    # get_init_inputs() is [16, 32, 3, 2, 1], with bias retaining its
+    # constructor default True.  Freeze one ordinary default initialization
+    # for the reference and CUDA paths while preserving the caller's CPU RNG.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        module = torch.nn.ConvTranspose3d(
+            16, 32, 3, stride=2, padding=1, bias=True)
+        frozen_weight = module.weight.detach().cpu().contiguous()
+        frozen_bias = module.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        values = device_parameters.get(key)
+        if values is None:
+            values = (
+                frozen_weight.to(device=x.device, dtype=x.dtype),
+                frozen_bias.to(device=x.device, dtype=x.dtype),
+            )
+            device_parameters[key] = values
+        return values
+
+    def ref(x):
+        weight, bias = parameters_for(x)
+        value = torch.nn.functional.conv_transpose3d(
+            x, weight, bias=bias, stride=2, padding=1,
+            output_padding=0, groups=1, dilation=1)
+        value = torch.nn.functional.batch_norm(
+            value, running_mean=None, running_var=None,
+            weight=None, bias=None, training=True,
+            momentum=0.1, eps=1.0e-5)
+        return value - torch.mean(value, dim=(2, 3, 4), keepdim=True)
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        batches, input_channels, input_depth, input_height, input_width = x.shape
+        if input_channels != 16:
+            raise ValueError("level 2 problem 15 requires 16 input channels")
+        output_depth = 2 * input_depth - 1
+        output_height = 2 * input_height - 1
+        output_width = 2 * input_width - 1
+        out = torch_module.empty(
+            (batches, 32, output_depth, output_height, output_width),
+            device=x.device, dtype=x.dtype)
+        weight, bias = parameters_for(x)
+        args = [
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, bias.data_ptr()),
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_depth),
+            (ctypes.c_int, input_height),
+            (ctypes.c_int, input_width),
+            (ctypes.c_int, output_depth),
+            (ctypes.c_int, output_height),
+            (ctypes.c_int, output_width),
+        ]
+        return out, (32, 1, 1), (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(16, 16, 16, 32, 32)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(2, 16, 5, 7, 9)]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(3, 16, 4, 6, 11)]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(2, 16, 5, 7, 9)
+            x[:, :, 0, 0, 0] = 20.0
+            x[:, :, -1, -1, -1] = 40.0
+            return [x]
+
+        def t4_zero_variance_eps(trial):
+            torch.manual_seed(5000 + trial)
+            return [torch.zeros(2, 16, 3, 5, 7)]
+
+        def t5_positive_alternating_lanes(trial):
+            torch.manual_seed(6000 + trial)
+            x = torch.full((3, 16, 5, 8, 9), 1.0e-3)
+            x.view(-1)[1::2] = 3000.0
+            return [x]
+
+        def t6_batch_tail_spikes(trial):
+            torch.manual_seed(7000 + trial)
+            x = torch.full((5, 16, 4, 6, 11), 1.0e-3)
+            x[1::2] = 2000.0
+            x[:, :, -1, -1, -1] = 3000.0
+            return [x]
+
+        def t7_small_misaligned_boundary_spikes(trial):
+            torch.manual_seed(8000 + trial)
+            x = torch.full((7, 16, 2, 3, 5), 2.0e-2)
+            x[:, :, 0, 0, 0] = 400.0
+            x[:, :, -1, -1, -1] = 2400.0
+            x[-1, :, :, :, -1] = 3000.0
+            return [x]
+
+        def t8_positive_spatial_checkerboard(trial):
+            torch.manual_seed(9000 + trial)
+            x = torch.full((3, 16, 4, 5, 10), 1.0e-3)
+            x[:, :, :, :, 1::2] = 1800.0
+            x[:, 1::2, 1::2, ::2, :] = 3000.0
+            return [x]
+
+        def t9_batch_channel_positional_ramp(trial):
+            torch.manual_seed(10000 + trial)
+            x = torch.full((5, 16, 3, 4, 7), 1.0e-2)
+            batch = torch.arange(5, dtype=x.dtype).view(5, 1, 1, 1, 1)
+            channel = torch.arange(16, dtype=x.dtype).view(1, 16, 1, 1, 1)
+            width = torch.arange(7, dtype=x.dtype).view(1, 1, 1, 1, 7)
+            x += 120.0 * batch + 35.0 * channel + 210.0 * width
+            x[:, :, -1, -1, -1] = 3000.0
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+            ("T4_zero_variance_eps", 1, t4_zero_variance_eps),
+            ("T5_positive_alternating_lanes", 1,
+             t5_positive_alternating_lanes),
+            ("T6_batch_tail_spikes", 1, t6_batch_tail_spikes),
+            ("T7_small_misaligned_boundary_spikes", 1,
+             t7_small_misaligned_boundary_spikes),
+            ("T8_positive_spatial_checkerboard", 1,
+             t8_positive_spatial_checkerboard),
+            ("T9_batch_channel_positional_ramp", 1,
+             t9_batch_channel_positional_ramp),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(1, 16, 4, 8, 8)]),
+            ("p_misaligned", [torch_module.randn(2, 16, 3, 5, 7)]),
+        ]
+
+    K.PROBLEMS["L2p15_convtranspose3d_batchn"] = dict(
+        kb_file="15_ConvTranspose3d_BatchNorm_Subtract.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="L2p15_convtranspose3d_batchn_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p16_convtranspose2d_mish_a.py

@@ -0,0 +1,196 @@
+"""Mutation-friendly substrate for KernelBench level-2 problem 16."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void L2p16_convtranspose2d_mish_add_kernel(
+        const float* x, float* out, const float* weight, const float* bias,
+        int batches, int input_height, int input_width,
+        int output_height, int output_width, long long output_elements) {
+    long long output_index =
+        (long long)blockIdx.x * blockDim.x + threadIdx.x;
+    if (output_index >= output_elements) return;
+
+    long long position = output_index;
+    int output_x = (int)(position % output_width);
+    position /= output_width;
+    int output_y = (int)(position % output_height);
+    position /= output_height;
+    int output_channel = (int)(position % 64);
+    int batch = (int)(position / 64);
+
+    // ConvTranspose2d parameters baked in from get_init_inputs(): kernel 3,
+    // stride 2, padding 1, output_padding 1, with the default bias enabled.
+    float accumulator = bias[output_channel];
+    for (int input_channel = 0; input_channel < 64; input_channel++) {
+        for (int kernel_y = 0; kernel_y < 3; kernel_y++) {
+            int input_y_numerator = output_y + 1 - kernel_y;
+            if (input_y_numerator % 2 != 0) continue;
+            int input_y = input_y_numerator / 2;
+            if (input_y < 0 || input_y >= input_height) continue;
+
+            for (int kernel_x = 0; kernel_x < 3; kernel_x++) {
+                int input_x_numerator = output_x + 1 - kernel_x;
+                if (input_x_numerator % 2 != 0) continue;
+                int input_x = input_x_numerator / 2;
+                if (input_x < 0 || input_x >= input_width) continue;
+
+                long long input_index =
+                    (((long long)batch * 64 + input_channel) * input_height
+                      + input_y) * input_width + input_x;
+                // ConvTranspose2d weights are (Cin, Cout, Kh, Kw).
+                long long weight_index =
+                    (((long long)input_channel * 64 + output_channel) * 3
+                      + kernel_y) * 3 + kernel_x;
+                accumulator += x[input_index] * weight[weight_index];
+            }
+        }
+    }
+
+    // Mish(x) = x*tanh(softplus(x)); PyTorch's default softplus threshold is
+    // 20.  Then add 0.5, clamp to [-1, 1], and multiply by 2.
+    float softplus = accumulator > 20.0f
+        ? accumulator : log1pf(expf(accumulator));
+    float mish = accumulator * tanhf(softplus);
+    float added = mish + 0.5f;
+    float clamped = fminf(fmaxf(added, -1.0f), 1.0f);
+    out[output_index] = clamped * 2.0f;
+}
+"""
+
+
+def register(K, torch, ctypes):
+    # Model parameters are state rather than get_inputs() values.  Freeze one
+    # ordinary default initialization and share it between ref and CUDA while
+    # preserving the caller's RNG state.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        layer = torch.nn.ConvTranspose2d(
+            64, 64, 3, stride=2, padding=1, output_padding=1
+        )
+        frozen_weight = layer.weight.detach().cpu().contiguous()
+        frozen_bias = layer.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        parameters = device_parameters.get(key)
+        if parameters is None:
+            parameters = (
+                frozen_weight.to(device=x.device, dtype=x.dtype),
+                frozen_bias.to(device=x.device, dtype=x.dtype),
+            )
+            device_parameters[key] = parameters
+        return parameters
+
+    def ref(x):
+        weight, bias = parameters_for(x)
+        value = torch.nn.functional.conv_transpose2d(
+            x, weight, bias=bias, stride=2, padding=1, output_padding=1
+        )
+        value = torch.nn.functional.mish(value)
+        value = value + 0.5
+        value = torch.nn.functional.hardtanh(value, min_val=-1, max_val=1)
+        return value * 2
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        batches, input_channels, input_height, input_width = x.shape
+        if input_channels != 64:
+            raise ValueError("level-2 problem 16 requires 64 input channels")
+
+        output_height = (input_height - 1) * 2 - 2 + 3 + 1
+        output_width = (input_width - 1) * 2 - 2 + 3 + 1
+        out = torch_module.empty(
+            (batches, 64, output_height, output_width),
+            device=x.device, dtype=x.dtype,
+        )
+        weight, bias = parameters_for(x)
+        output_elements = out.numel()
+        args = [
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, bias.data_ptr()),
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_height),
+            (ctypes.c_int, input_width),
+            (ctypes.c_int, output_height),
+            (ctypes.c_int, output_width),
+            (ctypes.c_longlong, output_elements),
+        ]
+        grid = ((output_elements + 255) // 256, 1, 1)
+        return out, grid, (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(128, 64, 128, 128)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(3, 64, 11, 17)]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(2, 64, 13, 19)]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(2, 64, 12, 18)
+            x[:, :, 0, 0] = 10.0
+            x[:, :, -1, -1] = 20.0
+            x[:, :, 5, 9] = 5.0
+            return [x]
+
+        def t4_positive_multiscale_grid(trial):
+            torch.manual_seed(5000 + trial)
+            channel_scale = torch.logspace(-2, 2, 64).view(1, 64, 1, 1)
+            rows = torch.linspace(0.25, 1.75, 15).view(1, 1, 15, 1)
+            cols = torch.linspace(1.75, 0.25, 21).view(1, 1, 1, 21)
+            x = (0.75 + 0.5 * torch.rand(1, 64, 15, 21))
+            return [x * channel_scale * rows * cols]
+
+        def t5_positive_alternating_regimes(trial):
+            torch.manual_seed(6000 + trial)
+            x = 0.02 + 0.01 * torch.rand(1, 64, 17, 23)
+            x[:, 0::2, 0::2, 0::2] = 24.0
+            x[:, 1::2, 1::2, 1::2] = 96.0
+            x[:, :, -1, -1] = torch.linspace(0.01, 128.0, 64)
+            return [x]
+
+        def t6_positive_sparse_saturation(trial):
+            torch.manual_seed(7000 + trial)
+            x = torch.full((1, 64, 19, 25), 1e-3)
+            x[:, :, 0, 0] = 192.0
+            x[:, :, -1, -1] = 256.0
+            x[:, 0::3, 9, 12] = 384.0
+            x[:, 1::3, 4::5, 6::7] = 64.0
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+            ("T4_positive_multiscale_grid", 1, t4_positive_multiscale_grid),
+            ("T5_positive_alternating_regimes", 1, t5_positive_alternating_regimes),
+            ("T6_positive_sparse_saturation", 1, t6_positive_sparse_saturation),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(1, 64, 16, 32)]),
+            ("p_misaligned", [torch_module.randn(2, 64, 7, 11)]),
+        ]
+
+    K.PROBLEMS["L2p16_convtranspose2d_mish_a"] = dict(
+        kb_file="16_ConvTranspose2d_Mish_Add_Hardtanh_Scaling.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="L2p16_convtranspose2d_mish_add_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p17_conv2d_instancenorm_di.py

@@ -0,0 +1,215 @@
+"""Mutation-friendly substrate for KernelBench level-2 problem 17."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void L2p17_conv2d_instancenorm_divide_kernel(
+        const float* x, float* out, const float* weight, const float* bias,
+        int batches, int input_height, int input_width,
+        int output_height, int output_width) {
+    int tid = threadIdx.x;
+    int instance_channel = blockIdx.x;
+    int output_channel = instance_channel % 128;
+    int batch = instance_channel / 128;
+    if (batch >= batches) return;
+
+    long long output_spatial = (long long)output_height * output_width;
+    long long output_base =
+        ((long long)batch * 128 + output_channel) * output_spatial;
+    __shared__ float partial[256];
+
+    // Conv2d defaults baked in from get_init_inputs(): stride=1, padding=0,
+    // dilation=1, groups=1, and bias=True.  Weights are [Cout,Cin,Kh,Kw].
+    float local_sum = 0.0f;
+    for (long long spatial = tid; spatial < output_spatial;
+         spatial += blockDim.x) {
+        int output_y = (int)(spatial / output_width);
+        int output_x = (int)(spatial - (long long)output_y * output_width);
+        float value = bias[output_channel];
+        for (int input_channel = 0; input_channel < 64; input_channel++) {
+            for (int kernel_y = 0; kernel_y < 3; kernel_y++) {
+                int input_y = output_y + kernel_y;
+                for (int kernel_x = 0; kernel_x < 3; kernel_x++) {
+                    int input_x = output_x + kernel_x;
+                    long long input_index =
+                        (((long long)batch * 64 + input_channel) * input_height
+                          + input_y) * input_width + input_x;
+                    long long weight_index =
+                        (((long long)output_channel * 64 + input_channel) * 3
+                          + kernel_y) * 3 + kernel_x;
+                    value += x[input_index] * weight[weight_index];
+                }
+            }
+        }
+        out[output_base + spatial] = value;
+        local_sum += value;
+    }
+
+    partial[tid] = local_sum;
+    __syncthreads(); // sync-after-mean-partials
+    for (int width = 128; width > 0; width >>= 1) {
+        if (tid < width) { partial[tid] += partial[tid + width]; }
+        __syncthreads(); // sync-during-mean-reduction
+    }
+    float mean = partial[0] / (float)output_spatial;
+    __syncthreads(); // sync-after-mean-read
+
+    // InstanceNorm2d uses the biased population variance over H and W,
+    // independently for every (batch, channel) pair.
+    float local_squared_deviation = 0.0f;
+    for (long long spatial = tid; spatial < output_spatial;
+         spatial += blockDim.x) {
+        float centered = out[output_base + spatial] - mean;
+        local_squared_deviation += centered * centered;
+    }
+    partial[tid] = local_squared_deviation;
+    __syncthreads(); // sync-after-variance-partials
+    for (int width = 128; width > 0; width >>= 1) {
+        if (tid < width) { partial[tid] += partial[tid + width]; }
+        __syncthreads(); // sync-during-variance-reduction
+    }
+    float variance = partial[0] / (float)output_spatial;
+    float inverse_standard_deviation = rsqrtf(variance + 1.0e-5f);
+
+    for (long long spatial = tid; spatial < output_spatial;
+         spatial += blockDim.x) {
+        float normalized =
+            (out[output_base + spatial] - mean) * inverse_standard_deviation;
+        out[output_base + spatial] = normalized / 2.0f;
+    }
+}
+"""
+
+
+def register(K, torch, ctypes):
+    # The convolution parameters are model state, not get_inputs() values.
+    # Freeze one ordinary default initialization without disturbing caller RNG,
+    # and use the identical tensors in the reference and raw CUDA kernel.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        convolution = torch.nn.Conv2d(64, 128, 3)
+        frozen_weight = convolution.weight.detach().cpu().contiguous()
+        frozen_bias = convolution.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        parameters = device_parameters.get(key)
+        if parameters is None:
+            parameters = (
+                frozen_weight.to(device=x.device, dtype=x.dtype),
+                frozen_bias.to(device=x.device, dtype=x.dtype),
+            )
+            device_parameters[key] = parameters
+        return parameters
+
+    def ref(x):
+        weight, bias = parameters_for(x)
+        value = torch.nn.functional.conv2d(
+            x, weight, bias=bias, stride=1, padding=0,
+            dilation=1, groups=1,
+        )
+        value = torch.nn.functional.instance_norm(
+            value, running_mean=None, running_var=None,
+            weight=None, bias=None, use_input_stats=True,
+            momentum=0.1, eps=1.0e-5,
+        )
+        return value / 2.0
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        batches, input_channels, input_height, input_width = x.shape
+        if input_channels != 64:
+            raise ValueError("level-2 problem 17 requires 64 input channels")
+        if input_height < 3 or input_width < 3:
+            raise ValueError("the 3x3 convolution requires spatial dimensions >= 3")
+
+        output_height = input_height - 2
+        output_width = input_width - 2
+        out = torch_module.empty(
+            (batches, 128, output_height, output_width),
+            device=x.device, dtype=x.dtype,
+        )
+        weight, bias = parameters_for(x)
+        out._substrate_keepalive = (weight, bias)
+        args = [
+            (ctypes.c_void_p, weight.data_ptr()),
+            (ctypes.c_void_p, bias.data_ptr()),
+            (ctypes.c_int, batches),
+            (ctypes.c_int, input_height),
+            (ctypes.c_int, input_width),
+            (ctypes.c_int, output_height),
+            (ctypes.c_int, output_width),
+        ]
+        return out, (batches * 128, 1, 1), (256, 1, 1), args
+
+    def suites():
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(128, 64, 128, 128)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(3, 64, 11, 17)]
+
+        def t2_misaligned(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(2, 64, 13, 19)]
+
+        def t3_positive_spikes(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(2, 64, 12, 18)
+            x[:, :, 0, 0] = 10.0
+            x[:, :, -1, -1] = 20.0
+            x[:, :, 5, 9] = 5.0
+            return [x]
+
+        def t4_zero_variance_constant(trial):
+            torch.manual_seed(5000 + trial)
+            return [torch.full((1, 64, 7, 11), 3.0)]
+
+        def t5_fp16_overflow_constant(trial):
+            torch.manual_seed(6000 + trial)
+            return [torch.full((1, 64, 18, 18), 100000.0)]
+
+        def t6_misaligned_alternating_spikes(trial):
+            torch.manual_seed(7000 + trial)
+            height, width = 19, 21
+            spatial = torch.arange(height * width).reshape(height, width)
+            pattern = torch.where(
+                spatial.remainder(2) == 0,
+                torch.tensor(1.0e-3),
+                torch.tensor(3000.0),
+            )
+            pattern[0, 0] = 6000.0
+            pattern[-1, -1] = 9000.0
+            return [pattern.expand(2, 64, height, width).clone()]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned", 1, t2_misaligned),
+            ("T3_positive_spikes", 1, t3_positive_spikes),
+            ("T4_zero_variance_constant", 1, t4_zero_variance_constant),
+            ("T5_fp16_overflow_constant", 1, t5_fp16_overflow_constant),
+            ("T6_misaligned_alternating_spikes", 1, t6_misaligned_alternating_spikes),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(1, 64, 16, 16)]),
+            ("p_misaligned", [torch_module.randn(2, 64, 7, 11)]),
+        ]
+
+    K.PROBLEMS["L2p17_conv2d_instancenorm_di"] = dict(
+        kb_file="17_Conv2d_InstanceNorm_Divide.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="L2p17_conv2d_instancenorm_divide_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )

substrates/candidate_L2p18_matmul_sum_max_avgpool.py

@@ -0,0 +1,170 @@
+"""Mutation-friendly substrate for KernelBench level2 problem 18."""
+
+
+CUDA_SOURCE = r"""
+#include <cuda_fp16.h>
+
+__global__ void matmul_sum_max_avgpool_kernel(
+        const float* x, float* out, const float* column_sums,
+        const float* bias_sum, int batch_size, int input_features) {
+    int batch = blockIdx.x;
+    int tid = threadIdx.x;
+    if (batch >= batch_size) return;
+
+    // Summing every output of nn.Linear gives
+    //   sum_k x[k] * sum_j weight[j, k] + sum_j bias[j].
+    // Each thread scans a distinct strided subset of input features.
+    float local_sum = 0.0f;
+    for (int input_feature = tid;
+         input_feature < input_features;
+         input_feature += blockDim.x) {
+        long long input_index =
+            (long long)batch * input_features + input_feature;
+        local_sum += x[input_index] * column_sums[input_feature];
+    }
+
+    __shared__ float partial_sums[256];
+    partial_sums[tid] = local_sum;
+    __syncthreads(); // sync-after-partial-store
+
+    for (int width = 128; width > 0; width >>= 1) {
+        if (tid < width) {
+            partial_sums[tid] =
+                partial_sums[tid] + partial_sums[tid + width];
+        }
+        __syncthreads(); // sync-after-reduction-step
+    }
+
+    if (tid == 0) {
+        float linear_sum = partial_sums[0] + bias_sum[0];
+
+        // The remaining reductions all operate on a dimension of length one:
+        // max, mean, and logsumexp(singleton) each preserve linear_sum.
+        float maximum = linear_sum;
+        float average = maximum;
+        float first_logsumexp = average;
+        float second_logsumexp = first_logsumexp;
+        out[batch] = second_logsumexp;
+    }
+}
+"""
+
+
+def register(K, torch, ctypes):
+    input_features = 8192
+    output_features = 8192
+
+    # KernelBench constructs nn.Linear(8192, 8192) with its ordinary default
+    # initialization. Freeze one reproducible realization without changing the
+    # suite builder's RNG stream, and share it between ref and launch.
+    with torch.random.fork_rng(devices=[]):
+        torch.manual_seed(0)
+        linear = torch.nn.Linear(input_features, output_features, bias=True)
+        frozen_weight = linear.weight.detach().cpu().contiguous()
+        frozen_bias = linear.bias.detach().cpu().contiguous()
+
+    device_parameters = {}
+
+    def parameters_for(x):
+        key = (x.device.type, x.device.index, x.dtype)
+        parameters = device_parameters.get(key)
+        if parameters is None:
+            weight = frozen_weight.to(device=x.device, dtype=x.dtype)
+            bias = frozen_bias.to(device=x.device, dtype=x.dtype)
+            column_sums = weight.sum(dim=0).contiguous()
+            bias_sum = bias.sum().reshape(1).contiguous()
+            parameters = (weight, bias, column_sums, bias_sum)
+            device_parameters[key] = parameters
+        return parameters
+
+    def ref(x):
+        weight, bias, _, _ = parameters_for(x)
+        value = torch.nn.functional.linear(x, weight, bias)
+        value = torch.sum(value, dim=1, keepdim=True)
+        value = torch.max(value, dim=1, keepdim=True)[0]
+        value = torch.mean(value, dim=1, keepdim=True)
+        value = torch.logsumexp(value, dim=1, keepdim=True)
+        value = torch.logsumexp(value, dim=1, keepdim=True)
+        return value
+
+    def launch(inputs, torch_module):
+        x = inputs[0]
+        if x.ndim != 2 or x.shape[1] != input_features:
+            raise ValueError("expected input shape (batch_size, 8192)")
+
+        batch_size = x.shape[0]
+        _, _, column_sums, bias_sum = parameters_for(x)
+        out = torch_module.empty(
+            (batch_size, 1), device=x.device, dtype=x.dtype
+        )
+        args = [
+            (ctypes.c_void_p, column_sums.data_ptr()),
+            (ctypes.c_void_p, bias_sum.data_ptr()),
+            (ctypes.c_int, batch_size),
+            (ctypes.c_int, input_features),
+        ]
+        return out, (batch_size, 1, 1), (256, 1, 1), args
+
+    def suites():
+        frozen_column_sums = frozen_weight.sum(dim=0)
+        strongest_positive = int(torch.argmax(frozen_column_sums).item())
+        positive_columns = frozen_column_sums > 0
+
+        def t0_original(trial):
+            torch.manual_seed(1000 + trial)
+            return [torch.rand(1024, 8192)]
+
+        def t1_signed(trial):
+            torch.manual_seed(2000 + trial)
+            return [torch.randn(11, 8192) * 0.05]
+
+        def t2_misaligned_batch(trial):
+            torch.manual_seed(3000 + trial)
+            return [torch.rand(37, 8192)]
+
+        def t3_positive_tail_spike(trial):
+            torch.manual_seed(4000 + trial)
+            x = torch.rand(7, 8192)
+            x[:, -1] = 50.0
+            x[-1, -31:] = 25.0
+            return [x]
+
+        def t4_positive_single_column_overflow(trial):
+            torch.manual_seed(5000 + trial)
+            x = torch.zeros(3, 8192)
+            x[:, strongest_positive] = 50000.0
+            return [x]
+
+        def t5_positive_coefficient_pattern(trial):
+            torch.manual_seed(6000 + trial)
+            x = torch.full((5, 8192), 1.0e-3)
+            x[:, positive_columns] = 128.0
+            return [x]
+
+        return [
+            ("T0_original", 5, t0_original),
+            ("T1_signed", 1, t1_signed),
+            ("T2_misaligned_batch", 1, t2_misaligned_batch),
+            ("T3_positive_tail_spike", 1, t3_positive_tail_spike),
+            ("T4_positive_single_column_overflow", 1,
+             t4_positive_single_column_overflow),
+            ("T5_positive_coefficient_pattern", 1,
+             t5_positive_coefficient_pattern),
+        ]
+
+    def probe(torch_module):
+        torch_module.manual_seed(0)
+        return [
+            ("p_aligned", [torch_module.rand(16, 8192)]),
+            ("p_misaligned", [torch_module.randn(3, 8192) * 0.05]),
+        ]
+
+    K.PROBLEMS["L2p18_matmul_sum_max_avgpool"] = dict(
+        kb_file="18_Matmul_Sum_Max_AvgPool_LogSumExp_LogSumExp.py",
+        cuda=CUDA_SOURCE,
+        kernel_name="matmul_sum_max_avgpool_kernel",
+        ref=ref,
+        launch=launch,
+        suites=suites,
+        probe=probe,
+    )