hapc 2.0.2__tar.gz → 2.1.0__tar.gz

{hapc-2.0.2/python/hapc.egg-info → hapc-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hapc
-Version: 2.0.2
+Version: 2.1.0
 Summary: Highly Adaptive Principal Components
 Home-page: https://github.com/meixide/hapc
 Author: Carlos García Meixide

{hapc-2.0.2 → hapc-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hapc"
-version = "2.0.2"
+version = "2.1.0"
 description = "Highly Adaptive Principal Components"
 readme = "README.md"
 requires-python = ">=3.8"

{hapc-2.0.2 → hapc-2.1.0}/python/hapc/__init__.py

@@ -19,7 +19,7 @@ Lower-level building blocks:
 - :func:`ate_hapc` — ATE estimate + Wald CI via HAPC + outcome undersmoothing.
 """
 
-__version__ = "2.0.2"
+__version__ = "2.1.0"
 
 from .core import (
     DesignOutput,

{hapc-2.0.2 → hapc-2.1.0}/python/hapc/ate.py

@@ -16,9 +16,9 @@ Provides :func:`ate_hapc`, a high-level convenience wrapper that:
    which ``|mean(EIF)| ≤ σ / (√n · log n)``.  This is the **undersmoothed**
    outcome model.  If no λ in the grid meets the threshold, the smallest λ
    is used.
-5. Returns the plug-in ATE point estimate at the undersmoothed model and a
-   ``(1 - alpha)`` Wald confidence interval based on the σ of the EIF at
-   that undersmoothed model.
+5. Returns a **doubly robust** ATE point estimate at the undersmoothed outcome
+   model and a ``(1 - alpha)`` Wald confidence interval from the EIF evaluated
+   at that estimate (see Notes).
 
 The function does not implement sample splitting / cross-fitting:
 nuisances are fit on the full sample and the EIF is evaluated on the same
@@ -47,8 +47,9 @@ class ATEResult(NamedTuple):
     Attributes
     ----------
     estimate : float
-        Plug-in ATE at the undersmoothed outcome model:
-        ``mean(μ̂_1(W) - μ̂_0(W))``.
+        Doubly robust (AIPW-style) ATE at the undersmoothed outcome model:
+        ``mean(A/π̂·(Y-μ̂₁)+μ̂₁ - (1-A)/(1-π̂)·(Y-μ̂₀) - μ̂₀)``, matching the
+        efficient influence function used for the Wald interval (see Notes).
     lower : float
         Lower endpoint of the ``(1 - alpha)`` Wald confidence interval.
     upper : float
@@ -228,15 +229,25 @@ def ate_hapc(X: np.ndarray, Y: np.ndarray, A: np.ndarray,
        specified).
     2. Fix the propensity at its CV-best λ; refit on the full sample to
        obtain ``π̂(W_i) = P(A=1 | W_i)``.
-    3. At the CV-best outcome λ, compute the ATE EIF
-       ``φ̂_diff = φ̂_1 - φ̂_0`` and let ``σ = std(φ̂_diff)``.
+    3. At the CV-best outcome λ, compute a **plugin-centered** influence vector
+       (same mean as the DR EIF at :math:`\\psi=\\overline{\\mu}_1-\\overline{\\mu}_0`)
+       and let ``σ = std(·)``.
     4. Threshold ``τ = σ / (√n · log n)``.
     5. Walk the **outcome** λ grid in **decreasing**
        order; pick the first (largest) λ for which
        ``|mean(EIF_diff)| ≤ τ`` — call it ``λ_u``.
-    6. Plug-in estimate: ``ψ̂ = mean(μ̂_1(W; λ_u) - μ̂_0(W; λ_u))``.
-       CI: ``ψ̂ ± z_{1 - α/2} · σ_u / √n`` where ``σ_u = std(EIF_diff)``
-       at ``λ_u``.
+    6. **Doubly robust** point estimate (same nuisances ``(π̂, μ̂₁, μ̂₀)``):
+       ``ψ̂ = mean(A/π̂·(Y-μ̂₁)+μ̂₁ - (1-A)/(1-π̂)·(Y-μ̂₀) - μ̂₀)``.
+       One-step influence function (centered at ``ψ̂``):
+       ``φ_i = A_i/π̂_i·(Y_i-μ̂_{1i}) + μ̂_{1i} - (1-A_i)/(1-π̂_i)·(Y_i-μ̂_{0i})
+       - μ̂_{0i} - ψ̂``.
+       CI: ``ψ̂ ± z_{1-α/2} · std(φ) / √n``.
+
+       This contrasts with **plug-in** G-computation ``mean(μ̂₁(W)-μ̂₀(W))``,
+       which can be materially biased when both nuisances are estimated on the
+       same sample and the outcome regressions are regularized.  The DR
+       ``ψ̂`` is consistent if **either** the propensity **or** the pair
+       ``(μ̂₁, μ̂₀)`` is correctly specified (standard double robustness).
 
     Examples
     --------
@@ -329,38 +340,60 @@ def ate_hapc(X: np.ndarray, Y: np.ndarray, A: np.ndarray,
             )
         return p[:n], p[n:]
 
-    def _eif_diff(mu1: np.ndarray, mu0: np.ndarray) -> np.ndarray:
+    def _eif_plugin_centered(mu1: np.ndarray, mu0: np.ndarray) -> np.ndarray:
+        """Plugin-centered influence vector (undersmoothing gate only).
+
+        Its mean matches the DR EIF evaluated at plug-in
+        :math:`\\psi=\\overline{\\mu}_1-\\overline{\\mu}_0`. The returned ATE
+        uses ``_psi_dr`` / ``_eif_dr`` instead.
+        """
         eif1 = (A01 / pi1) * (Y - mu1) - (mu1 - mu1.mean())
         eif0 = ((1.0 - A01) / (1.0 - pi1)) * (Y - mu0) - (mu0 - mu0.mean())
         return eif1 - eif0
 
+    def _psi_dr(mu1: np.ndarray, mu0: np.ndarray) -> float:
+        return float(
+            np.mean(
+                (A01 / pi1) * (Y - mu1)
+                + mu1
+                - ((1.0 - A01) / (1.0 - pi1)) * (Y - mu0)
+                - mu0
+            )
+        )
+
+    def _eif_dr(mu1: np.ndarray, mu0: np.ndarray, psi: float) -> np.ndarray:
+        return (
+            (A01 / pi1) * (Y - mu1)
+            + mu1
+            - ((1.0 - A01) / (1.0 - pi1)) * (Y - mu0)
+            - mu0
+            - psi
+        )
+
     # --- 3. σ at CV configuration → threshold τ ----------------------------
     mu1_cv, mu0_cv = _mu_pair(lam_out_cv)
-    eif_cv = _eif_diff(mu1_cv, mu0_cv)
+    eif_cv = _eif_plugin_centered(mu1_cv, mu0_cv)
     sigma_cv = float(np.std(eif_cv, ddof=0))
     threshold = sigma_cv / (np.sqrt(n) * np.log(n))
 
     # --- 4. Undersmoothing sweep: largest λ → smallest --------------------
     lam_und: Optional[float] = None
-    eif_und: Optional[np.ndarray] = None
     mu1_und = mu0_und = None
     for lam in np.sort(lambdas_out)[::-1]:
         try:
             mu1, mu0 = _mu_pair(float(lam))
         except Exception:
             continue
-        eif = _eif_diff(mu1, mu0)
+        eif = _eif_plugin_centered(mu1, mu0)
         if abs(eif.mean()) <= threshold:
             lam_und = float(lam)
             mu1_und, mu0_und = mu1, mu0
-            eif_und = eif
             break
 
-    if eif_und is None:
+    if lam_und is None:
         # Threshold never met → fall back to the smallest λ in the grid.
         lam_und = float(lambdas_out.min())
         mu1_und, mu0_und = _mu_pair(lam_und)
-        eif_und = _eif_diff(mu1_und, mu0_und)
 
     if plot_diagnostics:
         t_lams: list[float] = []
@@ -370,7 +403,7 @@ def ate_hapc(X: np.ndarray, Y: np.ndarray, A: np.ndarray,
                 mu1, mu0 = _mu_pair(float(lam))
             except Exception:
                 continue
-            eif = _eif_diff(mu1, mu0)
+            eif = _eif_plugin_centered(mu1, mu0)
             t_lams.append(float(lam))
             t_abs.append(float(np.abs(eif.mean())))
         _plot_ate_diagnostics(
@@ -379,9 +412,10 @@ def ate_hapc(X: np.ndarray, Y: np.ndarray, A: np.ndarray,
             lam_prop_cv, lam_out_cv, lam_und, threshold,
         )
 
-    # --- 5. Point estimate + (1 - alpha) Wald CI --------------------------
-    psi = float(np.mean(mu1_und - mu0_und))
-    sigma_und = float(np.std(eif_und, ddof=0))
+    # --- 5. Doubly robust point estimate + (1 - alpha) Wald CI --------------
+    psi = _psi_dr(mu1_und, mu0_und)
+    eif_dr = _eif_dr(mu1_und, mu0_und, psi)
+    sigma_und = float(np.std(eif_dr, ddof=0))
     z = float(_normal.ppf(1.0 - alpha / 2.0))
     half = z * sigma_und / np.sqrt(n)
 

{hapc-2.0.2 → hapc-2.1.0}/python/hapc/single.py

@@ -95,6 +95,24 @@ def _to_pm1(Y: np.ndarray, *, verbose: bool = False) -> np.ndarray:
     )
 
 
+def _calibrate_logistic_intercept(y01: np.ndarray, eta: np.ndarray) -> float:
+    """Newton calibration for intercept with fixed linear predictor ``eta``."""
+    y01 = np.asarray(y01, dtype=np.float64).ravel()
+    eta = np.asarray(eta, dtype=np.float64).ravel()
+    if y01.shape != eta.shape:
+        raise ValueError("y01 and eta must have the same shape")
+    b0 = 0.0
+    for _ in range(50):
+        z = eta + b0
+        p = 1.0 / (1.0 + np.exp(-z))
+        g = float(np.sum(p - y01))
+        h = float(np.sum(p * (1.0 - p)))
+        if abs(g) < 1e-10 or h < 1e-12:
+            break
+        b0 -= g / h
+    return float(b0)
+
+
 # ---------------------------------------------------------------------------
 # Single λ — gaussian, norm in {"1", "2"} (closed-form)
 # ---------------------------------------------------------------------------
@@ -299,6 +317,14 @@ def single_pcghal_classification(
     res = pcghal_classification(Y_pm1, Xtilde, ENn, alpha0,
                                 max_iter=max_iter, tol=tol,
                                 step_factor=step_factor, verbose=verbose)
+    y01 = (Y_pm1 > 0).astype(np.float64)
+    eta_train = Xtilde @ np.asarray(res.alpha).ravel()
+    b0 = _calibrate_logistic_intercept(y01, eta_train)
+    ymu = Y_pm1 * (eta_train + b0)
+    risk = float(
+        np.where(ymu > 0, np.log1p(np.exp(-ymu)), -ymu + np.log1p(np.exp(ymu)))
+        .mean()
+    )
 
     predictions = probabilities = predicted_classes = None
     if predict is not None:
@@ -307,7 +333,7 @@ def single_pcghal_classification(
             raise ValueError(f"predict must have {p} columns")
         Ktest = cross_kernel_hapc(X, Xte, max_degree, center=center)
         v = des.U[:, :final_npc] @ ((1.0 / (des.d[:final_npc] + 1e-12)) * res.alpha)
-        log_odds = Ktest @ v
+        log_odds = Ktest @ v + b0
         predictions = log_odds
         probabilities = 1.0 / (1.0 + np.exp(-log_odds))
         predicted_classes = np.where(probabilities > 0.5, 1.0, -1.0)
@@ -315,7 +341,7 @@ def single_pcghal_classification(
     return SinglePcghalClassificationResult(
         alpha=res.alpha, predictions=predictions,
         probabilities=probabilities, predicted_classes=predicted_classes,
-        lambda_=float(lambda_), risk=res.risk, iter=res.iter,
+        lambda_=float(lambda_), risk=risk, iter=res.iter,
     )
 
 
@@ -352,7 +378,9 @@ def single_pcghal_classification_ridge_only(
     ).ravel()
 
     eta = Xtilde @ alpha
-    ymu = Y_pm1 * eta
+    y01 = (Y_pm1 > 0).astype(np.float64)
+    b0 = _calibrate_logistic_intercept(y01, eta)
+    ymu = Y_pm1 * (eta + b0)
     risk = float(
         np.where(ymu > 0, np.log1p(np.exp(-ymu)), -ymu + np.log1p(np.exp(ymu)))
         .mean()
@@ -365,7 +393,7 @@ def single_pcghal_classification_ridge_only(
             raise ValueError(f"predict must have {p} columns")
         Ktest = cross_kernel_hapc(X, Xte, max_degree, center=center)
         v = des.U[:, :final_npc] @ ((1.0 / (des.d[:final_npc] + 1e-12)) * alpha)
-        log_odds = Ktest @ v
+        log_odds = Ktest @ v + b0
         predictions = log_odds
         probabilities = 1.0 / (1.0 + np.exp(-log_odds))
         predicted_classes = np.where(probabilities > 0.5, 1.0, -1.0)
@@ -478,8 +506,9 @@ def single_pcghal_classification_lasso(
         model = LogisticRegression(penalty="l1", **common_kw)
         model.fit(_C(Xtilde), Y_01)
     alpha = np.asarray(model.coef_, dtype=np.float64).ravel()
+    b0 = _calibrate_logistic_intercept(Y_01.astype(np.float64), Xtilde @ alpha)
 
-    eta = Xtilde @ alpha
+    eta = Xtilde @ alpha + b0
     ymu = Y_pm1 * eta
     risk = float(
         np.where(ymu > 0, np.log1p(np.exp(-ymu)), -ymu + np.log1p(np.exp(ymu))).mean()
@@ -492,7 +521,7 @@ def single_pcghal_classification_lasso(
             raise ValueError(f"predict must have {p} columns")
         Ktest = cross_kernel_hapc(X, Xte, max_degree, center=center)
         v = des.U[:, :final_npc] @ ((1.0 / (des.d[:final_npc] + 1e-12)) * alpha)
-        log_odds = Ktest @ v
+        log_odds = Ktest @ v + b0
         predictions = log_odds
         probabilities = 1.0 / (1.0 + np.exp(-log_odds))
         predicted_classes = np.where(probabilities > 0.5, 1.0, -1.0)

{hapc-2.0.2 → hapc-2.1.0/python/hapc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hapc
-Version: 2.0.2
+Version: 2.1.0
 Summary: Highly Adaptive Principal Components
 Home-page: https://github.com/meixide/hapc
 Author: Carlos García Meixide

{hapc-2.0.2 → hapc-2.1.0}/src/pcghal_cv_classi_cpp.cpp

@@ -66,6 +66,38 @@ VectorXd logistic_ridge_init(const VectorXd& Y_pm1, const MatrixXd& X, double la
     return beta;
 }
 
+static double calibrate_logistic_intercept(const VectorXd& Y01,
+                                           const VectorXd& eta) {
+    const int n = (int)Y01.size();
+    if (eta.size() != n) {
+        throw std::runtime_error("calibrate_logistic_intercept: length mismatch");
+    }
+    double b0 = 0.0;
+    for (int it = 0; it < 50; ++it) {
+        const VectorXd z = eta.array() + b0;
+        const VectorXd p = (1.0 + (-z.array()).exp()).inverse();
+        const double g = (p - Y01).sum();
+        const double h = (p.array() * (1.0 - p.array())).sum();
+        if (std::abs(g) < 1e-10 || h < 1e-12) break;
+        b0 -= g / h;
+    }
+    return b0;
+}
+
+static double logistic_risk_pm1(const VectorXd& Y_pm1, const VectorXd& eta) {
+    const int n = (int)Y_pm1.size();
+    if (eta.size() != n) {
+        throw std::runtime_error("logistic_risk_pm1: length mismatch");
+    }
+    double risk = 0.0;
+    for (int i = 0; i < n; ++i) {
+        const double ymu = Y_pm1[i] * eta[i];
+        risk += (ymu > 0) ? std::log1p(std::exp(-ymu))
+                          : -ymu + std::log1p(std::exp(ymu));
+    }
+    return risk / n;
+}
+
 // ---------------------------------------------------------------------------
 // Build the Eigen-friendly "Xtilde = U_top * diag(d_top)" representation,
 // returning final_npc (which may be capped by the design rank).
@@ -112,25 +144,24 @@ static OptimizerOutput logistic_full_fit(const VectorXd& Y_pm1,
                                           double step_factor, bool verbose,
                                           bool with_pgd) {
     VectorXd alpha0 = logistic_ridge_init(Y_pm1, Xtilde, lambda);
-    if (with_pgd) {
-        return pcghal_classi_call(Y_pm1, Xtilde, E_Nn, alpha0,
-                                  max_iter, tol, step_factor, verbose);
-    }
-    // Logistic-ridge-only path: assemble the same OptimizerOutput shape with
-    // logistic training risk evaluated on (Y_pm1, Xtilde, alpha0).
     const int n = Xtilde.rows();
-    VectorXd eta = Xtilde * alpha0;
-    double risk = 0.0;
-    for (int i = 0; i < n; ++i) {
-        const double ymu = Y_pm1[i] * eta[i];
-        risk += (ymu > 0) ? std::log1p(std::exp(-ymu))
-                          : -ymu + std::log1p(std::exp(ymu));
+    VectorXd alpha_fit;
+    if (with_pgd) {
+        OptimizerOutput out = pcghal_classi_call(Y_pm1, Xtilde, E_Nn, alpha0,
+                                                 max_iter, tol, step_factor, verbose);
+        alpha_fit = out.alpha;
+    } else {
+        alpha_fit = alpha0;  // logistic ridge only (norm="2")
     }
-    risk /= n;
+    VectorXd Y01(n);
+    for (int i = 0; i < n; ++i) Y01[i] = (Y_pm1[i] > 0.0) ? 1.0 : 0.0;
+    VectorXd eta = Xtilde * alpha_fit;
+    const double b0 = calibrate_logistic_intercept(Y01, eta);
+    const double risk = logistic_risk_pm1(Y_pm1, eta.array() + b0);
     OptimizerOutput out;
-    out.alpha = alpha0;
-    out.alphaiters = MatrixXd::Zero(0, alpha0.size());
-    out.beta = E_Nn * alpha0;
+    out.alpha = alpha_fit;
+    out.alphaiters = MatrixXd::Zero(0, alpha_fit.size());
+    out.beta = E_Nn * alpha_fit;
     out.risk = risk;
     out.iter = 0;
     return out;
@@ -199,7 +230,11 @@ CVClassiOutput pcghal_cv_classi_python(const MatrixXd& X, const VectorXd& Y,
             MatrixXd Ktest = kernel_cross_call(X, predict_data, maxdeg, center);
             VectorXd d_inv = d_top.cwiseInverse();
             VectorXd v = U_top * (d_inv.asDiagonal() * best_alpha);
-            VectorXd eta_pred = Ktest * v;
+            VectorXd eta_full = Xtilde * best_alpha;
+            VectorXd Y01_full(n);
+            for (int i = 0; i < n; ++i) Y01_full[i] = Y[i];
+            const double b0_full = calibrate_logistic_intercept(Y01_full, eta_full);
+            VectorXd eta_pred = (Ktest * v).array() + b0_full;
             predictions = (1.0 + (-eta_pred.array()).exp()).inverse();
         }
         CVClassiOutput out;
@@ -251,7 +286,11 @@ CVClassiOutput pcghal_cv_classi_python(const MatrixXd& X, const VectorXd& Y,
                 alpha_fold = alpha0;  // logistic ridge only (norm="2")
             }
 
-            VectorXd eta = Xte * alpha_fold;
+            VectorXd eta_tr = Xtr * alpha_fold;
+            VectorXd Ytr01(ntr);
+            for (int i = 0; i < ntr; ++i) Ytr01[i] = (Ytr_pm1[i] > 0.0) ? 1.0 : 0.0;
+            const double b0_fold = calibrate_logistic_intercept(Ytr01, eta_tr);
+            VectorXd eta = (Xte * alpha_fold).array() + b0_fold;
             VectorXd probs = (1.0 + (-eta.array()).exp()).inverse();
             double dev = 0.0;
             for (int i = 0; i < nte; ++i) {
@@ -298,7 +337,11 @@ CVClassiOutput pcghal_cv_classi_python(const MatrixXd& X, const VectorXd& Y,
         MatrixXd Ktest = kernel_cross_call(X, predict_data, maxdeg, center);
         VectorXd d_inv = d_top.cwiseInverse();
         VectorXd v = U_top * (d_inv.asDiagonal() * full_out.alpha);
-        VectorXd eta_pred = Ktest * v;
+        VectorXd eta_full = Xtilde * full_out.alpha;
+        VectorXd Y01_full(n);
+        for (int i = 0; i < n; ++i) Y01_full[i] = Y[i];
+        const double b0_full = calibrate_logistic_intercept(Y01_full, eta_full);
+        VectorXd eta_pred = (Ktest * v).array() + b0_full;
         predictions = (1.0 + (-eta_pred.array()).exp()).inverse();
     }
 

{hapc-2.0.2 → hapc-2.1.0}/src/r_bindings.cpp

@@ -368,12 +368,25 @@ extern "C" SEXP single_pcghal_classi_ridge_call(SEXP X_, SEXP Y_, SEXP maxdeg_,
     VectorXd Y_pm1(n);
     for (int i = 0; i < n; ++i) Y_pm1[i] = (Y01[i] == 1.0) ? 1.0 : -1.0;
 
-    VectorXd alpha = logistic_ridge_init(Y_pm1, Xtilde, lambda);
+    auto calibrate_b0 = [](const VectorXd& y01, const VectorXd& eta) {
+        double b0 = 0.0;
+        for (int it = 0; it < 50; ++it) {
+            VectorXd z = eta.array() + b0;
+            VectorXd p = (1.0 + (-z.array()).exp()).inverse();
+            double g = (p - y01).sum();
+            double h = (p.array() * (1.0 - p.array())).sum();
+            if (std::abs(g) < 1e-10 || h < 1e-12) break;
+            b0 -= g / h;
+        }
+        return b0;
+    };
 
+    VectorXd alpha = logistic_ridge_init(Y_pm1, Xtilde, lambda);
     VectorXd eta = Xtilde * alpha;
+    const double b0 = calibrate_b0(Y01, eta);
     double risk = 0.0;
     for (int i = 0; i < n; ++i) {
-        double ymu = Y_pm1[i] * eta[i];
+        double ymu = Y_pm1[i] * (eta[i] + b0);
         if (ymu > 0)
             risk += std::log1p(std::exp(-ymu));
         else
@@ -392,7 +405,7 @@ extern "C" SEXP single_pcghal_classi_ridge_call(SEXP X_, SEXP Y_, SEXP maxdeg_,
         MatrixXd Ktest = kernel_cross_call(X, Xtest, maxdeg, center);
         VectorXd d_inv = des.d.array().cwiseInverse();
         VectorXd v = des.U * (d_inv.asDiagonal() * alpha);
-        VectorXd log_odds = Ktest * v;
+        VectorXd log_odds = (Ktest * v).array() + b0;
         predictions = PROTECT(Rf_allocVector(REALSXP, m_pred)); prot++;
         std::copy(log_odds.data(), log_odds.data() + m_pred, REAL(predictions));
     }

{hapc-2.0.2 → hapc-2.1.0}/tests/test_ate_hapc_diagnostics_example.py

@@ -8,7 +8,7 @@ can be regenerated from the package root::
 This uses ``alpha=0.05`` with the **moderate** DGP from the original
 ``ate/simulate_data.py`` script (vendored below — exact same draws thanks to
 ``np.random.seed`` + the same ``np.random.uniform`` / ``normal`` /
-``binomial`` call order):
+``binomial`` call order).  ``ate_hapc`` is run with ``npcs = n - 1``.
 
 * ``W1 ~ Uniform(-2, 2)``
 * ``W2 ~ Normal(0, 0.5)``
@@ -37,7 +37,6 @@ DEMO_SEED = 456
 DEMO_N = 300
 DEMO_ALPHA = 0.05
 DEMO_MAX_DEGREE = 2
-DEMO_NPCS = 40
 DEMO_NFOLDS = 4
 DEMO_NORM = "1"
 
@@ -51,10 +50,10 @@ GRID_LENGTH_OUT = 8
 
 FIGURE_NAME = "ate_hapc_diagnostics_demo.png"
 
-# Pinned outputs (``alpha=0.05``, current C++/Python stack)
-_EXPECTED_ESTIMATE = 0.09213745592304026
-_EXPECTED_LOWER = -0.03604174118365536
-_EXPECTED_UPPER = 0.22031665302973588
+# Pinned outputs (``alpha=0.05``, ``npcs = n - 1``, current C++/Python stack)
+_EXPECTED_ESTIMATE = 0.07790009282426053
+_EXPECTED_LOWER = -0.050705979103681936
+_EXPECTED_UPPER = 0.206506164752203
 
 
 def _expit(x: np.ndarray) -> np.ndarray:
@@ -104,17 +103,22 @@ def run_ate_hapc_demo(
     *,
     plot_diagnostics: bool = False,
 ) -> "ATEResult":
-    """Run ``ate_hapc`` with the pinned demo hyperparameters."""
+    """Run ``ate_hapc`` with the pinned demo hyperparameters.
+
+    Uses ``npcs = n - 1`` (sample size from ``load_demo_data``) for both
+    propensity and outcome stages, matching the usual HAL rank cap.
+    """
     from hapc import ate_hapc
 
     W, A, Y = load_demo_data()
+    npcs = int(W.shape[0]) - 1
     return ate_hapc(
         W,
         Y,
         A,
         alpha=DEMO_ALPHA,
         max_degree=DEMO_MAX_DEGREE,
-        npcs=DEMO_NPCS,
+        npcs=npcs,
         log_lambda_prop_min=LOG_LAMBDA_PROP_MIN,
         log_lambda_prop_max=LOG_LAMBDA_PROP_MAX,
         grid_length_prop=GRID_LENGTH_PROP,