Address PR #169 review round 4: non-finite IF propagation and docstring fix

Non-finite influence function values (from extreme propensity scores or
near-singular design) now warn and set SE to NaN instead of silently
zeroing. Updated triple_difference() docstring to document robust as
no-op, matching class docstring.

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

Author: igerber

diff_diff/triple_diff.py

@@ -807,6 +807,7 @@ def _estimate_ddd_decomposition(
         pscore_stats = None
         all_pscores = {}  # Collect pscores for diagnostics
         overlap_issues = []  # Collect overlap diagnostics across comparisons
+        any_nonfinite_if = False
 
         with np.errstate(divide="ignore", invalid="ignore", over="ignore"):
             for j in [3, 2, 1]:
@@ -907,8 +908,10 @@ def _estimate_ddd_decomposition(
                     hessian, est_method, n_sub,
                 )
 
-                # Replace any NaN in influence function with 0
-                inf_j = np.where(np.isfinite(inf_j), inf_j, 0.0)
+                # Track non-finite IF values (flag for NaN SE later)
+                if not np.all(np.isfinite(inf_j)):
+                    any_nonfinite_if = True
+                    inf_j = np.where(np.isfinite(inf_j), inf_j, 0.0)
 
                 # Pad influence function to full length
                 inf_full = np.zeros(n)
@@ -963,6 +966,17 @@ def _estimate_ddd_decomposition(
         else:
             se = float(np.std(inf_func, ddof=1) / np.sqrt(n))
 
+        # Non-finite IF values make SE undefined
+        if any_nonfinite_if:
+            warnings.warn(
+                "Non-finite values in influence function (likely due to "
+                "extreme propensity scores or near-singular design). "
+                "SE set to NaN.",
+                UserWarning,
+                stacklevel=3,
+            )
+            se = np.nan
+
         # Propensity score stats (for IPW/DR with covariates)
         if has_covariates and est_method != "reg" and all_pscores:
             all_ps = np.concatenate(list(all_pscores.values()))
@@ -1533,7 +1547,10 @@ def triple_difference(
         Estimation method: "dr" (doubly robust), "reg" (regression),
         or "ipw" (inverse probability weighting).
     robust : bool, default=True
-        Whether to use robust standard errors.
+        Whether to use heteroskedasticity-robust standard errors.
+        Note: influence function-based SEs are inherently robust to
+        heteroskedasticity, so this parameter has no effect. Retained
+        for API compatibility.
     cluster : str, optional
         Column name for cluster-robust standard errors.
     alpha : float, default=0.05

docs/methodology/REGISTRY.md

@@ -829,6 +829,9 @@ has no additional effect.
   sets hessian=None (skipping PS correction in influence function), emits UserWarning
 - Collinear covariates: detected via pivoted QR in `solve_ols()`, action controlled by
   `rank_deficient_action` ("warn", "error", "silent")
+- Non-finite influence function values (e.g., from extreme propensity scores in IPW/DR
+  or near-singular design): warns and sets SE to NaN, propagated to t_stat/p_value/CI
+  via safe_inference()
 - NaN inference for undefined statistics:
   - t_stat: Uses NaN (not 0.0) when SE is non-finite or zero
   - p_value and CI: Also NaN when t_stat is NaN

tests/test_methodology_triple_diff.py

@@ -1334,6 +1334,42 @@ def _failing_lr(*args, **kwargs):
         assert np.isfinite(result.att)
         assert np.isfinite(result.se) and result.se > 0
 
+    @pytest.mark.parametrize("method", ["ipw", "dr"])
+    def test_nonfinite_if_propagates_nan_se(self, monkeypatch, method):
+        """Non-finite IF values produce NaN SE and NaN inference fields."""
+        data = generate_ddd_data(n_per_cell=50, seed=42, add_covariates=True)
+
+        import diff_diff.triple_diff as td_module
+
+        original_did_rc = td_module.TripleDifference._compute_did_rc
+
+        def _did_rc_with_nan(self_inner, *args, **kwargs):
+            att, inf = original_did_rc(self_inner, *args, **kwargs)
+            inf[0] = np.inf  # Inject non-finite value
+            return att, inf
+
+        monkeypatch.setattr(
+            td_module.TripleDifference, "_compute_did_rc", _did_rc_with_nan,
+        )
+
+        ddd = TripleDifference(estimation_method=method)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            result = ddd.fit(data, outcome="outcome", group="group",
+                             partition="partition", time="time",
+                             covariates=["age"])
+        nonfinite_warnings = [
+            x for x in w if "non-finite" in str(x.message).lower()
+        ]
+        assert len(nonfinite_warnings) > 0, "Expected non-finite IF warning"
+        assert np.isnan(result.se), "SE should be NaN when IF has non-finite values"
+        assert_nan_inference({
+            "se": result.se,
+            "t_stat": result.t_stat,
+            "p_value": result.p_value,
+            "conf_int": result.conf_int,
+        })
+
     def test_r_squared_respects_rank_deficient_action(self):
         """r_squared computation uses estimator's rank_deficient_action, not hardcoded 'silent'."""
         data = generate_ddd_data(n_per_cell=50, seed=42, add_covariates=True)