anti-hack rewards: gate simplicity on match>=.10, format on sim success, +match_dense +correctness_bonus, drop progress

physix/server/environment.py

@@ -193,6 +193,7 @@ class PhysiXEnvironment(Environment[PhysiXAction, PhysiXObservation, PhysiXState
             _log.debug("simulate_hypothesis failed: %s", exc)
             breakdown = compute_reward(
                 parse_succeeded=True,
+                simulation_succeeded=False,
                 r_match=0.0,
                 operator_count=parsed.operator_count,
                 previous_r_match=self._state.last_r_match,
@@ -220,6 +221,7 @@ class PhysiXEnvironment(Environment[PhysiXAction, PhysiXObservation, PhysiXState
 
         breakdown = compute_reward(
             parse_succeeded=True,
+            simulation_succeeded=True,
             r_match=r_match,
             operator_count=parsed.operator_count,
             previous_r_match=self._state.last_r_match,

physix/training/loop.py

@@ -377,17 +377,48 @@ def _build_and_format_dataset(
 
 
 def _select_reward_funcs(ablation: Optional[Ablation]) -> list[object]:
-    """Return the list of reward functions, dropping one for ablation runs."""
+    """Return the GRPO reward function set.
+
+    Default set (5 functions, summed by GRPOTrainer into the advantage):
+
+    - ``reward_match``         — raw R² (linear).
+    - ``reward_match_dense``   — sqrt(R²); dense low-value gradient.
+    - ``reward_correctness``   — binary cliff at R² ≥ 0.70.
+    - ``reward_simplicity``    — gated on R² ≥ 0.10 (anti-hack).
+    - ``reward_format``        — 1.0 only if parsed AND simulated.
+
+    Why this composition: empirically (RCA from W&B run 5kuqns9x) the
+    previous ``{match, progress, simplicity, format}`` mix had a
+    progress-equals-match duplicate (single-turn ``previous_r_match=0``)
+    AND let the model farm format+simplicity by emitting trivial
+    parseable equations. The new set both removes the duplicate and
+    triple-weights correctness via three different correctness-shaped
+    signals (match, match_dense, correctness_bonus) so that physical
+    accuracy dominates the GRPO advantage.
+
+    Ablations strip one signal at a time (used by the experiment matrix,
+    not by the main runs).
+    """
     scorer = Scorer()
     funcs = make_reward_funcs(scorer)
+    full = [
+        funcs["match"],
+        funcs["match_dense"],
+        funcs["correctness"],
+        funcs["simplicity"],
+        funcs["format"],
+    ]
     if ablation is None:
-        return [funcs["match"], funcs["progress"], funcs["simplicity"], funcs["format"]]
-    if ablation == "no_progress":
-        return [funcs["match"], funcs["simplicity"], funcs["format"]]
+        return full
     if ablation == "no_simplicity":
-        return [funcs["match"], funcs["progress"], funcs["format"]]
+        return [funcs["match"], funcs["match_dense"], funcs["correctness"], funcs["format"]]
     if ablation == "no_format":
-        return [funcs["match"], funcs["progress"], funcs["simplicity"]]
+        return [funcs["match"], funcs["match_dense"], funcs["correctness"], funcs["simplicity"]]
+    if ablation == "no_progress":
+        # Backward-compat alias: ``progress`` no longer exists, the new
+        # reward set already excludes it. Treat ``no_progress`` as the
+        # full default set so old job configs still work without surprise.
+        return full
     raise ValueError(
         f"Unknown ablation {ablation!r}. Choose from "
         "no_progress | no_simplicity | no_format | None."

physix/training/reward_fns.py

@@ -1,9 +1,9 @@
 """TRL-compatible reward functions for GRPO training.
 
 Responsibility: expose a stateless reward function for each independent
-reward component, plus an aggregated total. Internally each component delegates
-to a shared :class:`Scorer` so a single completion is parsed and simulated
-exactly once per training step regardless of how many components TRL queries.
+reward signal. Internally each component delegates to a shared
+:class:`Scorer` so a single completion is parsed and simulated exactly
+once per training step regardless of how many reward functions query it.
 
 The TRL signature for a reward function is::
 
@@ -12,6 +12,22 @@ The TRL signature for a reward function is::
 where ``prompts`` and ``completions`` are batched lists. Extra columns from
 the training dataset arrive as keyword arguments — we expect the columns
 listed in :class:`SystemContext` to be present.
+
+Reward set design (anti-hack, RCA from W&B run 5kuqns9x):
+
+- ``reward_match``        — raw R² on the trajectory (linear).
+- ``reward_match_dense``  — sqrt(R²); denser gradient at low values.
+- ``reward_correctness``  — binary cliff at R² ≥ 0.70; pushes past plateau.
+- ``reward_simplicity``   — gated on R² ≥ 0.10 (no free reward for trivial
+                            equations).
+- ``reward_format``       — 1.0 only if the equation parsed *and*
+                            simulated. No partial credit for parseable
+                            but uncomputable garbage.
+
+The legacy ``reward_progress`` is intentionally absent. In single-turn
+GRPO every dataset row carries ``previous_r_match=0``, which made
+``progress = max(0, match - 0) = match`` for every rollout — a perfect
+duplicate of ``reward_match`` that diluted advantage estimation.
 """
 
 from __future__ import annotations
@@ -20,16 +36,15 @@ from collections.abc import Callable, Sequence
 from typing import Any
 
 from physix.training.scorer import Scorer, SystemContext
+from physix.verifier.reward import correctness_bonus, match_dense
 
 
 RewardFunction = Callable[..., list[float]]
 
 
-# The four independent reward components passed to GRPOTrainer.
-# NOTE: "total" is intentionally excluded — GRPOTrainer *sums* the outputs
-# of all reward functions into a single advantage signal, so passing a
-# pre-computed total would double-count every component.
-_COMPONENT_NAMES: tuple[str, ...] = ("match", "progress", "simplicity", "format")
+#: Components that read directly from the :class:`RewardBreakdown` produced
+#: by :class:`Scorer.score`. ``progress`` is omitted (see module docstring).
+_BREAKDOWN_COMPONENTS: tuple[str, ...] = ("match", "simplicity", "format")
 
 
 def make_reward_funcs(
@@ -41,17 +56,25 @@ def make_reward_funcs(
     logs them individually to W&B under
     ``train/rewards/reward_<component>/mean``.
 
-    The scorer is shared across all four functions; calling
-    ``scorer.reset()`` between steps avoids unbounded cache growth and
-    ensures each completion is parsed + simulated exactly once per step
-    regardless of how many reward functions query it.
+    The scorer is shared across all functions; calling ``scorer.reset()``
+    between steps avoids unbounded cache growth and ensures each
+    completion is parsed + simulated exactly once per step regardless of
+    how many reward functions query it.
+
+    Returns a dict whose keys are:
+
+    - ``match`` / ``simplicity`` / ``format`` — direct reads from the
+      :class:`RewardBreakdown`. ``simplicity`` is internally gated on
+      match ≥ 0.10 and ``format`` on simulation success.
+    - ``match_dense`` — ``sqrt(match)`` for denser low-value gradient.
+    - ``correctness`` — binary 1.0 above an R² threshold (``0.70``).
 
-    Returns:
-        ``{"match": fn, "progress": fn, "simplicity": fn, "format": fn}``
+    All functions share the scorer cache, so they cost one parse +
+    simulate per completion combined, not five.
     """
     shared = scorer if scorer is not None else Scorer()
 
-    def _make(component: str) -> RewardFunction:
+    def _make_breakdown_reader(component: str) -> RewardFunction:
         def _reward_fn(
             prompts: Sequence[Any],
             completions: Sequence[str],
@@ -73,7 +96,44 @@ def make_reward_funcs(
         _reward_fn.__name__ = f"reward_{component}"
         return _reward_fn
 
-    return {name: _make(name) for name in _COMPONENT_NAMES}
+    def _reward_match_dense(
+        prompts: Sequence[Any],
+        completions: Sequence[str],
+        **kwargs: Any,
+    ) -> list[float]:
+        del prompts
+        shared.reset()
+        contexts = _hydrate_contexts(len(completions), kwargs)
+        out: list[float] = []
+        for i, completion in enumerate(completions):
+            b = shared.score(completion=completion, context=contexts[i], cache_key=i)
+            out.append(match_dense(b.match))
+        return out
+
+    _reward_match_dense.__name__ = "reward_match_dense"
+
+    def _reward_correctness(
+        prompts: Sequence[Any],
+        completions: Sequence[str],
+        **kwargs: Any,
+    ) -> list[float]:
+        del prompts
+        shared.reset()
+        contexts = _hydrate_contexts(len(completions), kwargs)
+        out: list[float] = []
+        for i, completion in enumerate(completions):
+            b = shared.score(completion=completion, context=contexts[i], cache_key=i)
+            out.append(correctness_bonus(b.match))
+        return out
+
+    _reward_correctness.__name__ = "reward_correctness"
+
+    funcs: dict[str, RewardFunction] = {
+        name: _make_breakdown_reader(name) for name in _BREAKDOWN_COMPONENTS
+    }
+    funcs["match_dense"] = _reward_match_dense
+    funcs["correctness"] = _reward_correctness
+    return funcs
 
 
 def _hydrate_contexts(batch_size: int, kwargs: dict[str, Any]) -> list[SystemContext]:

physix/training/scorer.py

@@ -162,8 +162,14 @@ class Scorer:
                 timestamps=context.timestamps,
             )
         except SimulationError:
+            # Equation parsed but the simulator could not produce a usable
+            # trajectory (NaN/inf, stiff blow-up, dimension mismatch, …).
+            # We mark ``simulation_succeeded=False`` so ``compute_reward``
+            # zeros out *every* component including ``format`` — otherwise
+            # the model gets paid for "looks valid but doesn't work".
             return compute_reward(
                 parse_succeeded=True,
+                simulation_succeeded=False,
                 r_match=0.0,
                 operator_count=parsed.operator_count,
                 previous_r_match=context.previous_r_match,
@@ -176,6 +182,7 @@ class Scorer:
         )
         return compute_reward(
             parse_succeeded=True,
+            simulation_succeeded=True,
             r_match=r_match,
             operator_count=parsed.operator_count,
             previous_r_match=context.previous_r_match,

physix/verifier/reward.py

@@ -1,20 +1,44 @@
-"""Compose the four-component reward.
+"""Compose the multi-component reward (anti-hack design).
 
 Responsibility:
 
 - Take pre-computed ``r_match`` (from :mod:`physix.verifier.metrics`),
   ``operator_count`` (from :mod:`physix.verifier.parser`), the previous turn's
-  total reward (from env state), and a "did parse?" flag (true iff
-  :func:`parse_equation` succeeded).
-- Return a :class:`RewardBreakdown` with all four components and the weighted
-  total.
-
-This module owns no NumPy/SciPy dependencies. It only knows about scalars and
-the four reward names.
+  match (for env-driven progress; unused in single-turn GRPO), and flags
+  for whether parsing and simulation succeeded.
+- Return a :class:`RewardBreakdown` with all components plus the legacy
+  weighted total.
+
+Anti-hack invariants (RCA from W&B run 5kuqns9x):
+
+1. **`format` requires simulation success, not just parse success.** A
+   syntactically valid equation that crashes the simulator is a failure,
+   not a half-success. Otherwise the model learns to emit nonsense that
+   is "almost runnable" and farm format reward.
+2. **`simplicity` is gated on `r_match >= MATCH_GATE`.** An empty/trivial
+   equation (e.g. ``dx/dt = 0``) parses, simulates, and earns
+   ``simplicity=1`` for being short — but produces a trajectory wildly
+   off the truth. We must not pay reward for "elegant nonsense". The
+   gate forces the model to be at least somewhat physically right
+   before it is allowed to bank simplicity.
+3. **`correctness_bonus` is a binary cliff at high R².** Provides a
+   strong terminal signal once the model is genuinely close to the
+   true equation — pushes past the plateau of "decent but not right".
+4. **`match_dense = sqrt(r_match)`** gives non-trivial gradient at low
+   R² values where raw ``r_match`` is near zero and gradient-starved.
+
+The legacy 4-tuple (match/progress/simplicity/format) remains in the
+breakdown for backward compatibility with the demo/UI/eval code; the
+GRPO trainer subscribes only to the components it cares about via
+``make_reward_funcs`` in ``physix.training.reward_fns``.
+
+This module owns no NumPy/SciPy dependencies. It only knows about scalars.
 """
 
 from __future__ import annotations
 
+import math
+
 from physix.models import REWARD_WEIGHTS, RewardBreakdown
 
 
@@ -23,6 +47,18 @@ from physix.models import REWARD_WEIGHTS, RewardBreakdown
 #: operator scores ~1.0.
 SIMPLICITY_OPERATOR_CAP: int = 12
 
+#: Minimum ``r_match`` required to earn any simplicity reward. Below this
+#: threshold the equation is judged as "wrong physics" regardless of how
+#: short it is, so simplicity collapses to 0. Eliminates the "output
+#: ``dx/dt = 0`` for free reward" exploit.
+MATCH_GATE_FOR_SIMPLICITY: float = 0.10
+
+#: ``r_match`` threshold above which the binary correctness_bonus fires.
+#: Calibrated against typical R² distributions from the verifier — 0.70
+#: requires the agent to capture the dominant dynamics, not just the
+#: initial condition or a constant approximation.
+CORRECTNESS_BONUS_THRESHOLD: float = 0.70
+
 
 def compute_reward(
     *,
@@ -30,25 +66,38 @@ def compute_reward(
     r_match: float,
     operator_count: int,
     previous_r_match: float,
+    simulation_succeeded: bool = True,
 ) -> RewardBreakdown:
-    """Compose the four-component reward for one turn.
+    """Compose the reward components for one turn.
 
-    A parse failure short-circuits to a zero-everything-but-format breakdown:
-    we still surface a non-trivial signal so the agent can learn that
-    parse-failures are bad without all rewards collapsing to NaN.
-    """
-    r_format = 1.0 if parse_succeeded else 0.0
+    Failure modes (return all-zero except where noted):
 
-    if not parse_succeeded:
+    - Parse failure: everything 0. The agent emitted unparseable output.
+    - Simulation failure: everything 0. The equation parsed but produced
+      a non-runnable system (NaN/inf, integration blowup, etc.).
+    - Trivial-but-runnable output (``r_match < MATCH_GATE_FOR_SIMPLICITY``):
+      ``format=1`` (we acknowledge it parsed and ran), but ``simplicity=0``.
+    """
+    if not parse_succeeded or not simulation_succeeded:
+        # Hard zero. No partial credit for parseable-but-broken or
+        # parseable-but-uncomputable output. (Empirically, leaving any
+        # partial credit here produces immediate reward hacking.)
         return RewardBreakdown(
             match=0.0,
             progress=0.0,
             simplicity=0.0,
-            format=r_format,
-            total=_weighted_total(match=0.0, progress=0.0, simplicity=0.0, format=r_format),
+            format=0.0,
+            total=0.0,
         )
 
-    r_simplicity = _simplicity_score(operator_count)
+    # Past this point: the equation parsed AND simulated. ``r_match`` is
+    # a legitimate signal of physical correctness.
+    r_format = 1.0
+    r_simplicity = (
+        _simplicity_score(operator_count)
+        if r_match >= MATCH_GATE_FOR_SIMPLICITY
+        else 0.0
+    )
     r_progress = _progress_score(r_match=r_match, previous_r_match=previous_r_match)
 
     total = _weighted_total(
@@ -67,6 +116,25 @@ def compute_reward(
     )
 
 
+def correctness_bonus(r_match: float) -> float:
+    """Binary cliff: 1.0 iff ``r_match >= CORRECTNESS_BONUS_THRESHOLD``."""
+    return 1.0 if r_match >= CORRECTNESS_BONUS_THRESHOLD else 0.0
+
+
+def match_dense(r_match: float) -> float:
+    """Square-root-shaped match reward.
+
+    ``sqrt(R²)`` magnifies small but non-zero matches — the model gets a
+    meaningful gradient even when raw ``r_match`` is 0.05 or 0.10
+    (near-zero linear value but ``sqrt(0.10) ≈ 0.32``). Saturates at 1.0.
+    """
+    if r_match <= 0.0:
+        return 0.0
+    if r_match >= 1.0:
+        return 1.0
+    return float(math.sqrt(r_match))
+
+
 def _simplicity_score(operator_count: int) -> float:
     """Map raw operator count to a [0, 1] score where smaller is better."""
     if operator_count <= 0:
@@ -77,18 +145,7 @@ def _simplicity_score(operator_count: int) -> float:
 
 
 def _progress_score(*, r_match: float, previous_r_match: float) -> float:
-    """Score for improving the physics fit over the previous turn.
-
-    Compares ``r_match`` (R² of the current hypothesis) against
-    ``previous_r_match`` (R² of the last hypothesis that actually parsed).
-
-    Critically, we compare match-against-match, not match-against-total.
-    The old code used ``previous_total``, which includes simplicity and format
-    bonuses — a model that parsed cleanly on turn 1 (earning total=0.30 from
-    format+simplicity alone, match=0) would never see ``r_progress > 0`` on
-    turn 2 even if its match improved from 0 → 0.25, because 0.25 < 0.30.
-    That incorrectly killed the improvement signal.
-    """
+    """Score for improving the physics fit over the previous turn (env only)."""
     delta = r_match - previous_r_match
     if delta <= 0.0:
         return 0.0