Return nan from deflated_sharpe_ratio for returns with no dispersion

An equity curve growing at a constant rate has no Sharpe ratio, but it does not
reach the deflation arithmetic as a nan. The standard deviation of its returns
is floating-point residue rather than an exact zero, so it divides out to a
Sharpe of ~1e13 -- finite, and therefore past the existing check. Deflating that
returned 1.0: certainty of a real edge, from the one input that carries no
information about one.

These returns are ratios of floats, so the residue is of the order of an ulp of
1.0 rather than of the returns' own magnitude. Measured at 0.44-0.61 eps across
constant rates from -1% to +5% and lengths 50-3000, against 4e7 eps for a real
series with sigma=1e-8, so one eps separates them with seven orders of magnitude
to spare. The test was run against the unfixed function and fails there, so it
tests the guard rather than accompanying it.

Author: ipezygj

backtesting/lib.py

@@ -264,6 +264,18 @@ def deflated_sharpe_ratio(stats: pd.Series,
     if not sr or np.isnan(sr) or n_periods < 2:
         return np.nan
 
+    # A return series with no dispersion has no Sharpe ratio, but it does not arrive
+    # here as a nan: an equity curve growing at a constant rate yields returns whose
+    # standard deviation is floating-point residue rather than an exact zero, so it
+    # divides out to a Sharpe of ~1e13 -- finite, and therefore past the check above.
+    # Deflating that returned 1.0, i.e. certainty of a real edge, for the one input
+    # carrying no information about one. These returns are ratios of floats, so the
+    # residue is of the order of an ulp of 1.0: measured at 0.44-0.61 eps for constant
+    # rates from -1% to +5% and lengths 50-3000, against 4e7 eps for a real series with
+    # sigma=1e-8. One eps separates them with seven orders of magnitude to spare.
+    if not returns.std(ddof=1) > np.finfo(float).eps * max(1.0, returns.abs().max()):
+        return np.nan
+
     # Expected maximum Sharpe ratio of `n_trials` skill-less trials
     # (Bailey & López de Prado 2014, eq. for E[max SR_n] under the null)
     norm = NormalDist()

backtesting/test/_test.py

@@ -1010,6 +1010,28 @@ def test_deflated_sharpe_ratio(self):
         with self.assertWarnsRegex(UserWarning, 'not Sharpe ratios'):
             deflated_sharpe_ratio(stats, heatmap.rename('SQN'))
 
+    def test_deflated_sharpe_ratio_zero_dispersion(self):
+        # An equity curve growing at a constant rate has no dispersion, so no Sharpe
+        # ratio and no deflated one. Its standard deviation is floating-point residue
+        # rather than an exact zero, so the ratio comes out finite (~1e16) and reaches
+        # the deflation arithmetic, which answered 1.0 -- certainty of an edge, from
+        # the one input that cannot show one.
+        index = pd.date_range('2020-01-01', periods=250, freq='D')
+        for rate in (1.001, 1.0):
+            equity = pd.Series(np.full(250, 1e4) * rate ** np.arange(250), index=index)
+            stats = pd.Series({'Sharpe Ratio': 3.0,
+                               '_equity_curve': pd.DataFrame({'Equity': equity})})
+            self.assertTrue(np.isnan(deflated_sharpe_ratio(stats, [.5, 1., 1.5, 2.])))
+
+        # The guard is relative to the scale of the data: a real but very quiet
+        # series still gets a number.
+        quiet = pd.Series(
+            1e4 * np.cumprod(1 + np.random.default_rng(1).normal(0, 1e-8, 250)),
+            index=index)
+        stats = pd.Series({'Sharpe Ratio': 3.0,
+                           '_equity_curve': pd.DataFrame({'Equity': quiet})})
+        self.assertTrue(0 <= deflated_sharpe_ratio(stats, [.5, 1., 1.5, 2.]) <= 1)
+
     def test_compute_stats(self):
         stats = Backtest(GOOG, SmaCross).run()
         only_long_trades = stats._trades[stats._trades.Size > 0]