graph: snap sub-tolerance lower>upper crossings in AffineBound.to_interval

A sound affine bound has lower <= upper for every component, so a crossing is fp
accumulation noise on a near-degenerate (point-valued) component — e.g. a token
embedding column at exactly 0.5 whose lower-bound eval lands ~1 ULP above 0.5.
The strict Range(lo, hi) check then raised during value_type propagation through
a select (surfaced building the Phase-H R_CheckPlane token, kind=1). Snap the
crossing when the gap is within fp tolerance; a gross crossing still falls
through to the strict Range check as a genuine-bug signal. Regression test in
tests/graph/test_affine_bounds.py::TestToIntervalFpCrossing.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: physicsrob

tests/graph/test_affine_bounds.py

@@ -906,3 +906,37 @@ def test_value_type_reflects_claimed_range(self):
             r = asserted.value_type.value_range
             assert r.lo == pytest.approx(-3.0)
             assert r.hi == pytest.approx(7.0)
+
+
+class TestToIntervalFpCrossing:
+    """``to_interval`` snaps a sub-tolerance lower>upper crossing — fp
+    accumulation noise on a point-valued component — instead of raising; a gross
+    crossing still raises. Regression: a token embedding column at exactly 0.5
+    had its lower bound eval land ~1 ULP above 0.5, tripping the strict ``Range``
+    check during ``value_type`` propagation through a ``select``."""
+
+    @staticmethod
+    def _point_bound(lo_b: float, hi_b: float) -> AffineBound:
+        # x-free (n_cols=0) component with lower offset lo_b, upper offset hi_b.
+        return AffineBound(
+            A_lo=torch.zeros(1, 0, dtype=torch.float64),
+            A_hi=torch.zeros(1, 0, dtype=torch.float64),
+            b_lo=torch.tensor([lo_b], dtype=torch.float64),
+            b_hi=torch.tensor([hi_b], dtype=torch.float64),
+            columns={},
+            input_ranges={},
+        )
+
+    def test_sub_tolerance_crossing_snaps(self):
+        ab = self._point_bound(0.5 + 7.45e-9, 0.5)
+        intervals = ab.to_interval()
+        assert len(intervals) == 1
+        assert intervals[0].lo == intervals[0].hi == 0.5
+        # to_scalar_range goes through the same path.
+        r = ab.to_scalar_range()
+        assert r.lo == pytest.approx(0.5) and r.hi == pytest.approx(0.5)
+
+    def test_gross_crossing_still_raises(self):
+        ab = self._point_bound(1.0, 0.5)
+        with pytest.raises(ValueError):
+            ab.to_interval()

torchwright/graph/affine_bound.py

@@ -160,6 +160,15 @@ def to_interval(self) -> list[Range]:
                 f"NaN in upper bound at component {i}; likely a 0*inf case "
                 f"not caught by the eval guard"
             )
+            if lo > hi:
+                # A sound affine bound has lower <= upper for every component;
+                # a crossing is fp accumulation noise on a near-degenerate
+                # (point-valued) component, e.g. an embedding column at exactly
+                # 0.5 whose lower eval lands 1 ULP above 0.5. Snap when the gap
+                # is within fp tolerance; a gross crossing falls through to the
+                # strict ``Range`` check below as a genuine-bug signal.
+                if lo - hi <= 1e-6 * (1.0 + max(abs(lo), abs(hi))):
+                    lo = hi
             ranges.append(Range(lo, hi))
         return ranges