fix(continuous-did): paper-faithful backward-to-zero discrete ACRT (fixes CI P1)

CI review flagged that a single positive dose (J=1) returned ACRT=0, which
contradicts the documented binary identity ACRT=ATT and the paper's Eq. 4.1
d_0=0 discrete setup. The prior forward-difference at the lowest dose was a
deviation; switch to the paper's backward difference on the grid {0, d_1, ...,
d_J} (d_0=0, ATT(0)=0), so ACRT(d_1) = ATT(d_1)/d_1 and a binary D in {0,1}
gives ACRT=ATT. Only the lowest dose's row changes; the j>=2 adjacent backward
differences are unchanged.

Consequence (correct): reg/dr share ACRT(d_j) for j>=2 (the constant DR
augmentation cancels in adjacent differences) but differ at ACRT(d_1) by
eta_cont/d_1 -- d_1 references the fixed baseline ATT(0)=0, which the
augmentation does not shift. The dr influence function now carries the
augmentation variance at d_1 (analytical ACRT(d_1) SE matches the multiplier
bootstrap); applied only on the discrete path, so the validated B-spline
covariate IF is byte-identical. The all-same-dose "ACRT will be 0" warning is
suppressed on the discrete path (single-dose ACRT = ATT(d_1)/d_1 != 0).

Updates REGISTRY Note #5/#6 + Key Equations, continuous-did.md 5.1, CHANGELOG,
llms-full.txt, docstring; adds binary-single-dose and dr-ACRT-analytical-vs-
bootstrap tests; updates the ACRT-boundary / reg-dr / DGP-recovery tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LHDijzf8zHXk5T8ahS2mKi

Author: igerber

CHANGELOG.md

@@ -11,9 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **`ContinuousDiD` discrete-treatment saturated regression** (`treatment_type="discrete"`) for
   multi-valued / discrete dose (CGBS 2024 Eq. 4.1). Each distinct dose level gets its own effect
   coefficient — `ATT(d_j) = mean_{D=d_j}(ΔY) − control` (a per-level 2×2 DiD) — instead of a B-spline
-  curve; `ACRT(d_j)` is a finite difference (forward at the lowest level, backward elsewhere). The
-  saturated fit is an exact basis swap, so analytical, multiplier-bootstrap, covariate (`reg`/`dr`),
-  and survey inference all compose and reduce analytically to the per-level 2×2 DiD standard error.
+  curve; `ACRT(d_j)` is the paper's backward finite difference on the grid `{0, d_1, …, d_J}`
+  (`ACRT(d_1) = ATT(d_1)/d_1`, so a binary `D ∈ {0,1}` gives `ACRT = ATT`). The saturated fit is an
+  exact basis swap, so analytical, multiplier-bootstrap, covariate (`reg`/`dr`), and survey inference
+  all compose and reduce analytically to the per-level 2×2 DiD standard error.
   Multi-cohort fits with heterogeneous dose support across cohorts raise `NotImplementedError`
   (support-aware aggregation deferred); an off-support `dvals` value raises `ValueError`. The default
   `treatment_type="continuous"` (B-spline) path is unchanged.

diff_diff/continuous_did.py

@@ -111,9 +111,11 @@ class ContinuousDiD:
         ``"discrete"`` (saturated per-dose-level regression, CGBS 2024 Eq. 4.1).
         On the discrete path each distinct dose level gets its own effect
         coefficient — ``ATT(d_j) = mean_{D=d_j}(ΔY) − control`` (a per-level 2×2
-        DiD) — and ``ACRT(d_j)`` is a finite difference (forward at the lowest
-        level, backward elsewhere). It composes with ``covariates`` and
-        ``survey_design`` and reduces to the per-level 2×2 DiD standard error.
+        DiD) — and ``ACRT(d_j)`` is the paper's backward finite difference on the
+        grid ``{0, d_1, ..., d_J}`` (``ACRT(d_1) = ATT(d_1)/d_1``, so a binary
+        dose ``D in {0, 1}`` gives ``ACRT = ATT``). It composes with
+        ``covariates`` and ``survey_design`` and reduces to the per-level 2×2 DiD
+        standard error.
         Multi-cohort fits must share the same dose support across cohorts (else
         ``NotImplementedError``); an off-support ``dvals`` value raises
         ``ValueError``.
@@ -1285,15 +1287,31 @@ def _covariate_cell_influence(
         if_acrt_d = np.vstack([acrt_d_if_t, acrt_d_if_c])
 
         if self.estimation_method == "dr":
-            # dr shares the reg curve shape (ACRT identical); att_glob / ATT(d)
-            # differ by the augmentation eta_cont. Ground att_glob's IF in the
-            # validated DRDID doubly-robust IF and shift ATT(d) uniformly by the
-            # augmentation IF (= reg att_glob IF - dr att_glob IF). ACRT untouched.
+            # The DR augmentation eta_cont shifts att_glob / ATT(d) by a constant;
+            # ground att_glob's IF in the validated DRDID doubly-robust IF and
+            # shift ATT(d) uniformly by the augmentation IF (= reg att_glob IF -
+            # dr att_glob IF). eta_cont perturbs beta by a constant direction
+            # `bread @ psi_bar` (= e_intercept for the B-spline basis, ones(J)
+            # for the saturated basis), so its effect on the curve is
+            # Psi_eval/dPsi_eval applied to that direction. For ATT that is the
+            # uniform shift below. For ACRT it is dPsi_eval @ (bread @ psi_bar):
+            # zero for the B-spline path (intercept derivative is 0) and for the
+            # discrete j>=2 rows (backward differences sum to 0), but NONZERO at
+            # the lowest discrete dose, whose backward-to-zero row references the
+            # fixed baseline ATT(0)=0. There, ACRT(d_1) = ATT(d_1)/d_1 genuinely
+            # depends on the DR level, so its IF must carry the augmentation
+            # variance. Applied only on the discrete path to keep the validated
+            # B-spline covariate IF byte-identical.
             n_total = cov_adj["n_total"]
             dr_att_glob_if = cov_adj["dr_inf"] / n_total  # (n_total,)
             if_eta = if_att_glob - dr_att_glob_if  # augmentation IF, per unit
             if_att_d = if_att_d - if_eta[:, np.newaxis]
             if_att_glob = dr_att_glob_if
+            if self.treatment_type == "discrete":
+                const_dir = bread @ Psi.mean(axis=0)  # (K,), = ones(J) here
+                acrt_shift = dPsi_eval @ const_dir  # (n_grid,), = L @ 1
+                if_acrt_d = if_acrt_d - if_eta[:, np.newaxis] * acrt_shift[np.newaxis, :]
+                if_acrt_glob = if_acrt_glob - if_eta * float(dpsi_bar @ const_dir)
 
         return {
             "cell_indices": np.concatenate([treated_indices, control_indices]),
@@ -1481,8 +1499,12 @@ def _deriv(z: np.ndarray) -> np.ndarray:
                     "level from the dose grid."
                 )
 
-        # Check for all-same dose
-        if np.all(treated_doses == treated_doses[0]):
+        # Check for all-same dose. On the continuous (B-spline) path this
+        # collapses the basis so ACRT(d) = 0 everywhere. On the discrete path a
+        # single dose level (J=1) is a valid single-dose fit with
+        # ACRT(d_1) = ATT(d_1)/d_1 (backward difference to the zero-dose
+        # baseline), so the "ACRT will be 0" warning does not apply there.
+        if self.treatment_type != "discrete" and np.all(treated_doses == treated_doses[0]):
             warnings.warn(
                 f"All treated doses identical in (g={g}, t={t}). " "ACRT(d) will be 0 everywhere.",
                 UserWarning,

diff_diff/continuous_did_bspline.py

@@ -325,15 +325,19 @@ def saturated_derivative_design_matrix(x, levels, tol=SATURATED_TOL):
     """
     Finite-difference derivative rows for the saturated (discrete) basis.
 
-    ACRT for a discrete dose is a finite difference of the level effects
-    (CGBS 2024): ``ACRT(d_j) = [ATT(d_j) - ATT(d_{j-1})] / (d_j - d_{j-1})``
-    for ``j >= 2`` (backward), with a **forward** difference at the lowest
-    level ``d_1`` (``[ATT(d_2) - ATT(d_1)] / (d_2 - d_1)``) so the ACRT curve
-    shares the ATT grid and ``ACRT^glob`` stays well-defined. This is a linear
-    operator ``L`` on ``beta`` (each row sums to 0, so a constant level/control
-    shift cancels), and ``acrt = L @ beta``. Returns the ``L`` row for each
-    ``x_i`` at its dose level. With ``J = 1`` (single dose) every row is 0
-    (``ACRT = 0``). Analogous to :func:`bspline_derivative_design_matrix`.
+    ACRT for a discrete dose is the paper's backward difference of the level
+    effects (CGBS 2024 §3.2 / §4.1) on the grid ``{d_0 = 0, d_1, ..., d_J}``,
+    where ``d_0 = 0`` is the omitted (untreated) category with ``ATT(0) = 0``:
+    ``ACRT(d_j) = [ATT(d_j) - ATT(d_{j-1})] / (d_j - d_{j-1})``. At the lowest
+    positive level this references the zero-dose baseline,
+    ``ACRT(d_1) = [ATT(d_1) - 0] / (d_1 - 0) = ATT(d_1) / d_1`` — so a single
+    positive dose (``J = 1``, e.g. binary ``D in {0, 1}``) gives
+    ``ACRT(d_1) = ATT(d_1) / d_1`` and, for ``d_1 = 1``, the documented binary
+    identity ``ACRT = ATT``. This is a linear operator ``L`` on ``beta``, and
+    ``acrt = L @ beta``. Only the lowest level's row references ``d_0 = 0`` (so
+    that row does NOT sum to 0); the ``j >= 2`` rows are ordinary adjacent
+    backward differences (rows sum to 0). Returns the ``L`` row for each ``x_i``
+    at its dose level. Analogous to :func:`bspline_derivative_design_matrix`.
 
     Parameters
     ----------
@@ -353,14 +357,12 @@ def saturated_derivative_design_matrix(x, levels, tol=SATURATED_TOL):
     idx = _match_levels(x, levels, tol)
     J = len(levels)
     L = np.zeros((J, J))
-    # Row 0: forward difference at the lowest level; rows j>=1: backward.
+    # Row 0 (lowest positive dose d_1): backward difference to the zero-dose
+    # baseline d_0 = 0, ATT(0) = 0 -> ACRT(d_1) = ATT(d_1) / d_1. Rows j >= 1:
+    # ordinary adjacent backward differences between positive doses.
     for j in range(J):
-        if J == 1:
-            break  # single dose level: derivative is 0 everywhere
         if j == 0:
-            h = levels[1] - levels[0]
-            L[0, 0] = -1.0 / h
-            L[0, 1] = 1.0 / h
+            L[0, 0] = 1.0 / levels[0]
         else:
             h = levels[j] - levels[j - 1]
             L[j, j - 1] = -1.0 / h

diff_diff/guides/llms-full.txt

@@ -715,10 +715,10 @@ reg_did_panel/drdid_panel. `covariates=` + `survey_design=` is not yet supported
 
 `treatment_type="discrete"` fits a **saturated regression** for a multi-valued dose: one indicator per
 distinct dose level, so `ATT(d_j) = mean_{D=d_j}(ΔY) − control` (a per-level 2×2 DiD) and `ACRT(d_j)`
-is a finite difference (forward at the lowest level, backward elsewhere). It reuses the full inference
-stack (analytical / bootstrap / covariate / survey) and reduces to the per-level 2×2 DiD SE. Multi-
-cohort fits need a shared dose support across cohorts (else `NotImplementedError`); an off-support
-`dvals` value raises `ValueError`.
+is the paper's backward finite difference on `{0, d_1, …, d_J}` (`ACRT(d_1) = ATT(d_1)/d_1`, so binary
+`D ∈ {0,1}` gives `ACRT = ATT`). It reuses the full inference stack (analytical / bootstrap /
+covariate / survey) and reduces to the per-level 2×2 DiD SE. Multi-cohort fits need a shared dose
+support across cohorts (else `NotImplementedError`); an off-support `dvals` value raises `ValueError`.
 
 **Alias:** `CDiD`