"""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"),
]