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
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, x0.5f vs x/2.0f with a perturbation).
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.
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.
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:
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).