Scale the zero-dispersion floor with the sample size

The first guard compared the standard deviation against eps x scale, which is the
residue of a single rounding rather than of the whole sum. Measured over constant
series spanning values 1e-7..1e3 and lengths 3..10000, the residue reaches
1.96 eps x scale, so the original threshold still let a flat series through at
other lengths: it was calibrated on one series and tested on that same series.

n eps x scale keeps a margin of at least 3.9x at every length measured, and a
real series with sigma=1e-12 sits more than ten orders of magnitude above it, so
nothing legitimate is caught. The test now sweeps values x lengths rather than
asserting one point, and was run against the unfixed function, where it fails.

Author: ipezygj

openbb_platform/extensions/quantitative/openbb_quantitative/helpers.py

@@ -119,7 +119,7 @@ def deflated_sharpe_stats(
         variance.
     """
     # pylint: disable=import-outside-toplevel
-    from numpy import asarray, e as np_e, sqrt
+    from numpy import asarray, e as np_e, finfo, sqrt
     from scipy.stats import norm
 
     if trials < 1:
@@ -130,7 +130,18 @@ def deflated_sharpe_stats(
         raise ValueError("need at least 3 observations")
     mu = returns.mean() - rfr
     sd = returns.std()  # population, consistent with the reference implementation
-    if sd == 0:
+    # `sd == 0` is exact and a constant series does not reach it: its standard
+    # deviation is floating-point residue rather than a true zero, so a flat 0.1%
+    # series has sd ~1e-19 and divides out to a Sharpe of ~1e16 -- finite, and past
+    # every isfinite guard after this one. Deflating that returned 1.0, i.e. certainty
+    # of a real edge, for the one input carrying no information about one. Compare
+    # against the resolution of a float at the scale of the data instead, so a
+    # genuinely low-volatility series still gets a number.
+    # The residue grows with the number of terms summed, so the floor is n eps rather
+    # than eps: measured at most 1.96 eps x scale over constant series spanning values
+    # 1e-7..1e3 and lengths 3..10000, while a real series with sigma=1e-12 sits more
+    # than ten orders of magnitude above n eps x scale.
+    if not sd > n * finfo(float).eps * abs(returns).max():
         raise ValueError("zero-variance returns")
     sr = mu / sd
     skew_ = (((returns - returns.mean()) / sd) ** 3).mean()

openbb_platform/extensions/quantitative/tests/test_deflated_sharpe.py

@@ -56,3 +56,25 @@ def test_invalid_inputs_raise():
         deflated_sharpe_stats(RETURNS.head(2), trials=10)
     with pytest.raises(ValueError):
         deflated_sharpe_stats(pd.Series([0.01] * 10), trials=10)
+
+
+def test_zero_dispersion_raises_across_values_and_lengths():
+    """A constant series carries no information about an edge, at any scale.
+
+    `sd == 0` is exact and a constant series does not reach it: its standard
+    deviation is floating-point residue rather than a true zero, so the ratio came
+    out finite (~1e16) and reached the deflation arithmetic, which answered 1.0.
+    The residue depends on both the value and the length, so this is checked over a
+    grid: a guard calibrated on a single series passes while still leaking elsewhere.
+    """
+    for value in (1e-7, 1e-4, 0.001, 0.01, 1.0, 100.0):
+        for n in (3, 10, 250, 5000):
+            with pytest.raises(ValueError, match="zero-variance"):
+                deflated_sharpe_stats(pd.Series([value] * n), trials=4)
+
+    # The guard is relative to the scale of the data: a real but very quiet series
+    # still gets a number.
+    import numpy as np
+
+    quiet = pd.Series(np.random.default_rng(1).normal(0, 1e-8, 250))
+    assert 0 <= deflated_sharpe_stats(quiet, trials=4)["deflated_sharpe_ratio"] <= 1