| # 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). |
|
|
