fix(gfql/cypher): round() review hardening — ulp-correct kernel, negative-precision decline, CI polars lane

Adversarial review of the round() conformance fix (4 IMPORTANT findings):
- I2/S2: replace floor(x+0.5) with a floor+frac kernel on both engines — the
  +0.5 addition itself rounds up when x sits 1 ulp below a tie (JDK-6430675),
  e.g. round(0.49999999999999994) must be 0.0 and round(0.0499…96, 1) -> 0.0
  (pandas previously disagreed with polars/neo4j here). Also: scaled-overflow
  identity (round(1e300, 20) = 1e300, not inf), -0.0 normalized (+0.0).
- I1: negative precision now declines honestly on both engines (neo4j raises;
  polars previously crashed with a raw OverflowError, pandas silently computed).
- I3: the polars-parametrized cypher test_lowering cases never ran in CI (core
  lane has no polars; polars lane's file list excluded the file) — added
  cypher/test_lowering.py -k polars to bin/test-polars.sh + the ci.yml coverage
  step (--cov-append).
- I4: setup.py polars extra floor >= 1.5 (round(mode=) kwarg requirement).

+ulp/inf/negative-precision tests (engine-parametrized, importorskip-guarded).
1620 tests pass; ruff + mypy clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: lmeyerov

graphistry/compute/gfql/lazy/engine/polars/row_pipeline.py

@@ -139,14 +139,19 @@ def _lower_function(node: Any, columns: Sequence[str]) -> Optional[Any]:
             if not isinstance(lit, int) or isinstance(lit, bool):
                 return None  # non-literal precision -> defer (honest NIE)
             ndigits = lit
+        if ndigits < 0:
+            return None  # neo4j raises on negative precision; decline (honest NIE)
         # neo4j tie-breaking (matches the pandas engine): precision 0 -> ties toward
-        # +inf (floor(x+0.5)); precision > 0 -> ties away from zero (HALF_UP).
-        # polars' .round default (half-to-even) would be a wrong answer vs the spec.
-        # Use the native mode= for p>0 (bit-exact; a manual scale/divide formula picks
-        # up 1-ulp noise from polars' reassociating optimizer).
+        # +inf; precision > 0 -> ties away from zero (HALF_UP). polars' .round default
+        # (half-to-even) would be a wrong answer vs the spec. p=0 uses a floor+frac
+        # kernel (NOT floor(x+0.5): the +0.5 rounds when x is 1 ulp below a tie —
+        # round(0.49999999999999994) must be 0.0). p>0 uses the native mode= (bit-exact;
+        # a manual scale/divide formula picks up 1-ulp noise from polars' reassociating
+        # optimizer). Requires polars >= 1.5 for the mode kwarg (see setup.py extra).
         x = args[0].cast(pl.Float64)
         if ndigits == 0:
-            return (x + 0.5).floor()
+            fl = x.floor()
+            return fl + ((x - fl) >= 0.5).cast(pl.Float64)  # ties toward +inf
         return x.round(ndigits, mode="half_away_from_zero")
     if name in {"tolower", "toupper", "lower", "upper"} and len(args) == 1:
         # toLower/toUpper + GQL-conformance aliases lower/upper (as neo4j accepts both).

graphistry/compute/gfql/row/pipeline.py

@@ -1366,8 +1366,14 @@ def _gfql_eval_expr_ast(self, table_df: Any, node: Any) -> Tuple[bool, Any]:
                 # rounds ties toward +inf (round(-1.5) = -1.0); precision > 0 rounds ties
                 # away from zero (HALF_UP: round(-1.55, 1) = -1.6). numpy/pandas .round is
                 # half-to-even (round(2.5) -> 2.0) — a wrong answer vs the neo4j spec.
+                # Uses a floor+frac kernel, NOT floor(x+0.5): the +0.5 addition itself
+                # rounds up when x sits 1 ulp below a tie (JDK-6430675 class), e.g.
+                # round(0.49999999999999994) must be 0.0, round(0.0499…96, 1) → 0.0.
                 inner = values[0]
                 ndigits = int(values[1]) if len(values) == 2 else 0
+                if ndigits < 0:
+                    # neo4j raises on negative precision; decline (no silent wrong value).
+                    return False, None
                 if hasattr(inner, "astype"):
                     null_mask = self._gfql_null_mask(table_df, inner)
                     f = inner.astype(float)
@@ -1379,20 +1385,35 @@ def _floor_series(s: Any) -> Any:
                         return np.floor(s)
 
                     if ndigits == 0:
-                        out = _floor_series(f + 0.5)
+                        fl = _floor_series(f)
+                        out = fl + ((f - fl) >= 0.5).astype(float)  # ties toward +inf
                     else:
                         scale = 10.0 ** ndigits
                         shifted = f * scale
+                        a = shifted.abs()
+                        fl = _floor_series(a)
+                        mag = fl + ((a - fl) >= 0.5).astype(float)  # ties away from zero
                         sig = (shifted > 0).astype(float) - (shifted < 0).astype(float)
-                        out = _floor_series(shifted.abs() + 0.5) * sig / scale
+                        out = mag * sig / scale + 0.0  # +0.0 normalizes -0.0
+                        # scaled overflow (|x·10^p| = inf): rounding is the identity
+                        out = out.where(a != float("inf"), f)
                     return True, out.where(~null_mask, pd.NA)
                 if is_null_scalar(inner):
                     return True, None
                 x = float(inner)
+                if not math.isfinite(x):
+                    return True, x
                 if ndigits == 0:
-                    return True, float(math.floor(x + 0.5))
+                    fl0 = math.floor(x)
+                    return True, float(fl0 + (1 if (x - fl0) >= 0.5 else 0))
                 scale = 10.0 ** ndigits
-                return True, math.copysign(math.floor(abs(x * scale) + 0.5), x) / scale
+                shifted_x = x * scale
+                if not math.isfinite(shifted_x):
+                    return True, x  # scaled overflow -> identity
+                a2 = abs(shifted_x)
+                fl2 = math.floor(a2)
+                mag2 = fl2 + (1 if (a2 - fl2) >= 0.5 else 0)
+                return True, math.copysign(mag2, shifted_x) / scale + 0.0
 
             # neo4j/openCypher toLower/toUpper (the idiomatic case-insensitive-match helper),
             # plus the GQL-conformance aliases lower/upper (ISO GQL §20.24; neo4j accepts both).

graphistry/tests/compute/gfql/cypher/test_lowering.py

@@ -3028,6 +3028,28 @@ def vals(nodes: pd.DataFrame, expr: str) -> list:
     prec = pd.DataFrame({"id": [0, 1], "x": [1.25, -1.55]})
     assert vals(prec, "round(n.x, 1)") == [pytest.approx(1.3), pytest.approx(-1.6)]  # away from zero
 
+    # 1-ulp-below-a-tie (JDK-6430675 class): a floor(x+0.5) kernel wrongly rounds UP;
+    # the correct answer (Java Math.round post-fix, BigDecimal, polars native) is down.
+    ulp = pd.DataFrame({"id": [0, 1], "x": [0.49999999999999994, 0.049999999999999996]})
+    assert vals(ulp, "round(n.x)") == [0.0, 0.0]
+    assert vals(ulp, "round(n.x, 1)") == [pytest.approx(0.5), pytest.approx(0.0)]
+    # infinity passes through (rounding is the identity; no overflow to inf/crash)
+    inf = pd.DataFrame({"id": [0, 1], "x": [float("inf"), 1e300]})
+    assert vals(inf, "round(n.x)") == [float("inf"), 1e300]
+    assert vals(inf, "round(n.x, 2)") == [float("inf"), 1e300]
+
+
+@pytest.mark.parametrize("engine", ["pandas", "polars"])
+def test_round_negative_precision_declines(engine: str) -> None:
+    """neo4j raises on negative round() precision; we decline honestly (error, never a
+    silent value — and never a raw polars OverflowError crash)."""
+    if engine == "polars":
+        pytest.importorskip("polars")
+    g = _mk_graph(pd.DataFrame({"id": [0], "x": [25.0]}), pd.DataFrame({"s": [], "d": []}))
+    with pytest.raises(Exception) as exc_info:
+        g.gfql("MATCH (n) RETURN round(n.x, -1) AS v, n.id AS id", engine=engine)
+    assert "OverflowError" not in type(exc_info.value).__name__
+
 
 @pytest.mark.parametrize("engine", ["pandas", "polars"])
 @pytest.mark.parametrize(

setup.py

@@ -57,7 +57,7 @@ def unique_flatten_dict(d):
     'jupyter': ['ipython'],
     'spanner': ['google-cloud-spanner'],
     'kusto': ['azure-kusto-data', 'azure-identity'],
-    'polars': ['polars'],
+    'polars': ['polars>=1.5'],
 }
 
 base_extras_heavy = {