Address PR #364 AI review R4: footer covers joiners/leavers/path_effects

P2: the bootstrap footer in summary() previously keyed "produced
non-finite SE on every target" only off overall_se and
event_study_effects, missing joiners_se / leavers_se / path_effects.
Because by_path zeros switcher-side contributions outside the
selected path while keeping controls intact, a per-path bootstrap
target can remain finite even when the overall/event-study target
degenerates (e.g., on a reversible panel where the mix of joiners +
leavers produces a zero centered IF). Without the broader predicate
the footer would falsely claim blanket failure while a finite
per-path SE sits in the rendered output below.

Fix: add joiners_has_finite_bootstrap_se,
leavers_has_finite_bootstrap_se, and
path_effects_has_finite_bootstrap_se guards, and a new mixed-validity
branch between the "used for event-study horizon inference" branch
and the blanket-failure branch:

  "Note: bootstrap (N iterations) produced non-finite SE on the
   overall/event-study target; {joiners, leavers, per-path} bootstrap
   inference is populated."

Regression test
test_summary_footer_mixed_validity_surfaces_live_targets forces
overall_se / event_study_effects to NaN post-fit on a healthy bootstrap
fit (keeping path_effects finite), then asserts (a) the footer does
not claim blanket failure, (b) does not claim
"multiplier-bootstrap percentile inference" when overall is NaN, and
(c) mentions "per-path" + "bootstrap inference is populated".

Full dCDH regression: 215 pass. TestByPathBootstrap: 14 pass under
-m slow.

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

Author: igerber

diff_diff/chaisemartin_dhaultfoeuille_results.py

@@ -710,14 +710,45 @@ def summary(self, alpha: Optional[float] = None) -> str:
         # least one horizon has a finite SE before claiming bootstrap was
         # "used for event-study horizon inference" — otherwise every
         # bootstrap inference field is NaN and we fall through to the
-        # "bootstrap attempted but invalid" note.
+        # "bootstrap attempted but invalid" note. The `any_finite_*`
+        # predicate below expands the check to cover joiners / leavers /
+        # path_effects too: by_path zeros switcher contributions for non-
+        # path groups while keeping controls intact, so a per-path
+        # bootstrap target can produce a finite SE even when the overall
+        # / event-study bootstrap is degenerate (e.g., a reversible panel
+        # where the overall mix of joiners + leavers produces a zero
+        # centered IF while individual paths do not). Without this
+        # broader predicate, the footer would falsely claim "produced
+        # non-finite SE on every target" while a finite per-path
+        # bootstrap SE sits in the rendered output below.
         event_study_has_finite_bootstrap_se = (
             self.event_study_effects is not None
             and any(
                 np.isfinite(entry.get("se", np.nan))
                 for entry in self.event_study_effects.values()
             )
         )
+        joiners_has_finite_bootstrap_se = (
+            self.joiners_se is not None and np.isfinite(self.joiners_se)
+        )
+        leavers_has_finite_bootstrap_se = (
+            self.leavers_se is not None and np.isfinite(self.leavers_se)
+        )
+        path_effects_has_finite_bootstrap_se = (
+            self.path_effects is not None
+            and any(
+                np.isfinite(h.get("se", np.nan))
+                for entry in self.path_effects.values()
+                for h in entry.get("horizons", {}).values()
+            )
+        )
+        any_finite_bootstrap_inference = (
+            np.isfinite(self.overall_se)
+            or event_study_has_finite_bootstrap_se
+            or joiners_has_finite_bootstrap_se
+            or leavers_has_finite_bootstrap_se
+            or path_effects_has_finite_bootstrap_se
+        )
         if self.bootstrap_results is not None and np.isfinite(self.overall_se) and not is_delta:
             lines.append("Note: p-value and CI are multiplier-bootstrap percentile inference")
             lines.append(
@@ -738,6 +769,23 @@ def summary(self, alpha: Optional[float] = None) -> str:
                 f"Note: bootstrap ({self.bootstrap_results.n_bootstrap} iterations) "
                 f"used for event-study horizon inference."
             )
+        elif self.bootstrap_results is not None and any_finite_bootstrap_inference:
+            # Overall / event-study degenerated but joiners / leavers /
+            # path_effects still have finite bootstrap SE. Point the reader
+            # at the targets that succeeded rather than claiming a blanket
+            # failure.
+            live_targets = []
+            if joiners_has_finite_bootstrap_se:
+                live_targets.append("joiners")
+            if leavers_has_finite_bootstrap_se:
+                live_targets.append("leavers")
+            if path_effects_has_finite_bootstrap_se:
+                live_targets.append("per-path")
+            lines.append(
+                f"Note: bootstrap ({self.bootstrap_results.n_bootstrap} iterations) "
+                f"produced non-finite SE on the overall/event-study target; "
+                f"{', '.join(live_targets)} bootstrap inference is populated."
+            )
         elif self.bootstrap_results is not None:
             lines.append(
                 f"Note: bootstrap ({self.bootstrap_results.n_bootstrap} iterations) "

tests/test_chaisemartin_dhaultfoeuille.py

@@ -4593,6 +4593,73 @@ def test_overflow_warning_fires_exactly_once_under_bootstrap(self):
             f"Messages: {[str(w.message) for w in overflow_warnings]}"
         )
 
+    def test_summary_footer_mixed_validity_surfaces_live_targets(self):
+        """
+        Mixed-validity case: overall_se / event_study_ses degenerate to
+        NaN while joiners_se / leavers_se / path_effects horizons retain
+        finite bootstrap inference. ``by_path`` zeros switcher-side
+        contributions outside the selected path while keeping the control
+        pool intact, so path-level bootstrap targets can stay finite even
+        when the overall/event-study IF degenerates on a reversible
+        panel. The footer must point the reader at the live targets
+        rather than falsely claiming "non-finite SE on every target."
+
+        Uses a healthy bootstrap fit and post-hoc mutates overall_se /
+        event_study_effects to NaN, pinning the footer logic in
+        isolation from the (hard-to-engineer) natural reversible DGP
+        that produces this exact mixed-validity state.
+        """
+        data = _by_path_three_path_data()
+        _est, res = self._fit_with_bootstrap(
+            data, by_path=3, L_max=3, n_bootstrap=200, seed=42,
+        )
+        # Sanity: healthy fit has finite overall and path SEs.
+        assert np.isfinite(res.overall_se)
+        assert res.path_effects is not None
+        any_finite_path = any(
+            np.isfinite(h["se"])
+            for e in res.path_effects.values()
+            for h in e["horizons"].values()
+        )
+        assert any_finite_path
+
+        # Force overall + event_study to NaN while leaving path_effects
+        # untouched — simulates the reversible-panel scenario where the
+        # overall IF is identically zero but the by_path subset IF is
+        # not.
+        res.overall_se = float("nan")
+        res.overall_t_stat = float("nan")
+        res.overall_p_value = float("nan")
+        res.overall_conf_int = (float("nan"), float("nan"))
+        if res.event_study_effects is not None:
+            for entry in res.event_study_effects.values():
+                entry["se"] = float("nan")
+                entry["t_stat"] = float("nan")
+                entry["p_value"] = float("nan")
+                entry["conf_int"] = (float("nan"), float("nan"))
+
+        summary_text = res.summary()
+        # Must NOT claim "non-finite SE on every target"
+        assert "produced non-finite SE on every target" not in summary_text, (
+            "Footer falsely claims all-target failure while path_effects "
+            "still has finite bootstrap SE. Summary tail:\n"
+            f"{summary_text[-400:]}"
+        )
+        # Must NOT claim "multiplier-bootstrap percentile inference"
+        # (overall_se is NaN so the headline inference is not bootstrap
+        # percentile).
+        assert "multiplier-bootstrap percentile inference" not in summary_text
+        # Must mention "per-path bootstrap inference is populated"
+        assert (
+            "per-path" in summary_text
+            and "bootstrap inference is populated" in summary_text
+        ), (
+            "Footer must surface which targets retain finite bootstrap "
+            "inference when overall/event-study degenerates. Summary "
+            "tail:\n"
+            f"{summary_text[-400:]}"
+        )
+
     def test_nan_contract_extends_to_overall_and_event_study_horizons(self):
         """
         The bootstrap-contract NaN-on-invalid rule applies to every