diff-diff 1.4.0__tar.gz → 2.0.0__tar.gz

{diff_diff-1.4.0 → diff_diff-2.0.0}/PKG-INFO

@@ -1,14 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 1.4.0
-Summary: A library for Difference-in-Differences causal inference analysis
-Author: diff-diff contributors
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/igerber/diff-diff
-Project-URL: Documentation, https://diff-diff.readthedocs.io
-Project-URL: Repository, https://github.com/igerber/diff-diff
-Project-URL: Issues, https://github.com/igerber/diff-diff/issues
-Keywords: causal-inference,difference-in-differences,econometrics,statistics,treatment-effects
+Version: 2.0.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -18,20 +10,28 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
 Requires-Dist: numpy>=1.20.0
 Requires-Dist: pandas>=1.3.0
 Requires-Dist: scipy>=1.7.0
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
+Requires-Dist: black>=23.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.1.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0 ; extra == 'dev'
+Requires-Dist: sphinx>=6.0 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=1.0 ; extra == 'docs'
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0; extra == "dev"
-Requires-Dist: black>=23.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
-Requires-Dist: mypy>=1.0; extra == "dev"
 Provides-Extra: docs
-Requires-Dist: sphinx>=6.0; extra == "docs"
-Requires-Dist: sphinx-rtd-theme>=1.0; extra == "docs"
+Summary: A library for Difference-in-Differences causal inference analysis
+Keywords: causal-inference,difference-in-differences,econometrics,statistics,treatment-effects
+Author: diff-diff contributors
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://diff-diff.readthedocs.io
+Project-URL: Homepage, https://github.com/igerber/diff-diff
+Project-URL: Issues, https://github.com/igerber/diff-diff/issues
+Project-URL: Repository, https://github.com/igerber/diff-diff
 
 # diff-diff
 
@@ -2253,3 +2253,4 @@ The `HonestDiD` module implements sensitivity analysis methods for relaxing the
 ## License
 
 MIT License
+

{diff_diff-1.4.0 → diff_diff-2.0.0}/diff_diff/__init__.py

@@ -5,6 +5,16 @@ This library provides sklearn-like estimators for causal inference
 using the difference-in-differences methodology.
 """
 
+# Import backend detection from dedicated module (avoids circular imports)
+from diff_diff._backend import (
+    HAS_RUST_BACKEND,
+    _rust_bootstrap_weights,
+    _rust_compute_robust_vcov,
+    _rust_project_simplex,
+    _rust_solve_ols,
+    _rust_synthetic_weights,
+)
+
 from diff_diff.bacon import (
     BaconDecomposition,
     BaconDecompositionResults,
@@ -103,7 +113,7 @@ from diff_diff.visualization import (
     plot_sensitivity,
 )
 
-__version__ = "1.4.0"
+__version__ = "2.0.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",
@@ -187,4 +197,6 @@ __all__ = [
     "compute_pretrends_power",
     "compute_mdv",
     "plot_pretrends_power",
+    # Rust backend
+    "HAS_RUST_BACKEND",
 ]

diff_diff-2.0.0/diff_diff/_backend.py

@@ -0,0 +1,64 @@
+"""
+Backend detection and configuration for diff-diff.
+
+This module handles:
+1. Detection of optional Rust backend
+2. Environment variable configuration (DIFF_DIFF_BACKEND)
+3. Exports HAS_RUST_BACKEND and Rust function references
+
+Other modules should import from here to avoid circular imports with __init__.py.
+"""
+
+import os
+
+# Check for backend override via environment variable
+# DIFF_DIFF_BACKEND can be: 'auto' (default), 'python', or 'rust'
+_backend_env = os.environ.get('DIFF_DIFF_BACKEND', 'auto').lower()
+
+# Try to import Rust backend for accelerated operations
+try:
+    from diff_diff._rust_backend import (
+        generate_bootstrap_weights_batch as _rust_bootstrap_weights,
+        compute_synthetic_weights as _rust_synthetic_weights,
+        project_simplex as _rust_project_simplex,
+        solve_ols as _rust_solve_ols,
+        compute_robust_vcov as _rust_compute_robust_vcov,
+    )
+    _rust_available = True
+except ImportError:
+    _rust_available = False
+    _rust_bootstrap_weights = None
+    _rust_synthetic_weights = None
+    _rust_project_simplex = None
+    _rust_solve_ols = None
+    _rust_compute_robust_vcov = None
+
+# Determine final backend based on environment variable and availability
+if _backend_env == 'python':
+    # Force pure Python mode - disable Rust even if available
+    HAS_RUST_BACKEND = False
+    _rust_bootstrap_weights = None
+    _rust_synthetic_weights = None
+    _rust_project_simplex = None
+    _rust_solve_ols = None
+    _rust_compute_robust_vcov = None
+elif _backend_env == 'rust':
+    # Force Rust mode - fail if not available
+    if not _rust_available:
+        raise ImportError(
+            "DIFF_DIFF_BACKEND=rust but Rust backend is not available. "
+            "Install with: pip install diff-diff[rust]"
+        )
+    HAS_RUST_BACKEND = True
+else:
+    # Auto mode - use Rust if available
+    HAS_RUST_BACKEND = _rust_available
+
+__all__ = [
+    'HAS_RUST_BACKEND',
+    '_rust_bootstrap_weights',
+    '_rust_synthetic_weights',
+    '_rust_project_simplex',
+    '_rust_solve_ols',
+    '_rust_compute_robust_vcov',
+]

{diff_diff-1.4.0 → diff_diff-2.0.0}/diff_diff/linalg.py

@@ -1,15 +1,17 @@
 """
 Unified linear algebra backend for diff-diff.
 
-This module provides optimized OLS and variance estimation that can be
-swapped to a compiled backend (Rust/C++) for maximum performance.
+This module provides optimized OLS and variance estimation with an optional
+Rust backend for maximum performance.
 
 The key optimizations are:
 1. scipy.linalg.lstsq with 'gelsy' driver (QR-based, faster than SVD)
 2. Vectorized cluster-robust SE via groupby (eliminates O(n*clusters) loop)
 3. Single interface for all estimators (reduces code duplication)
+4. Optional Rust backend for additional speedup (when available)
 
-Future: This module can be extended with a Rust backend for additional speedup.
+The Rust backend is automatically used when available, with transparent
+fallback to NumPy/SciPy implementations.
 """
 
 from typing import Optional, Tuple, Union
@@ -18,6 +20,13 @@ import numpy as np
 import pandas as pd
 from scipy.linalg import lstsq as scipy_lstsq
 
+# Import Rust backend if available (from _backend to avoid circular imports)
+from diff_diff._backend import (
+    HAS_RUST_BACKEND,
+    _rust_compute_robust_vcov,
+    _rust_solve_ols,
+)
+
 
 def solve_ols(
     X: np.ndarray,
@@ -119,6 +128,87 @@ def solve_ols(
                 "Clean your data or set check_finite=False to skip this check."
             )
 
+    # Use Rust backend if available
+    # Note: Fall back to NumPy if check_finite=False since Rust's LAPACK
+    # doesn't support non-finite values
+    if HAS_RUST_BACKEND and check_finite:
+        # Ensure contiguous arrays for Rust
+        X = np.ascontiguousarray(X, dtype=np.float64)
+        y = np.ascontiguousarray(y, dtype=np.float64)
+
+        # Convert cluster_ids to int64 for Rust (if provided)
+        cluster_ids_int = None
+        if cluster_ids is not None:
+            cluster_ids_int = pd.factorize(cluster_ids)[0].astype(np.int64)
+
+        try:
+            coefficients, residuals, vcov = _rust_solve_ols(
+                X, y, cluster_ids_int, return_vcov
+            )
+        except ValueError as e:
+            # Translate Rust LAPACK errors to consistent Python error messages
+            error_msg = str(e)
+            if "Matrix inversion failed" in error_msg or "Least squares failed" in error_msg:
+                raise ValueError(
+                    "Design matrix is rank-deficient (singular X'X matrix). "
+                    "This indicates perfect multicollinearity. Check your fixed effects "
+                    "and covariates for linear dependencies."
+                ) from e
+            raise
+
+        if return_fitted:
+            fitted = X @ coefficients
+            return coefficients, residuals, fitted, vcov
+        else:
+            return coefficients, residuals, vcov
+
+    # Fallback to NumPy/SciPy implementation
+    return _solve_ols_numpy(
+        X, y, cluster_ids=cluster_ids, return_vcov=return_vcov, return_fitted=return_fitted
+    )
+
+
+def _solve_ols_numpy(
+    X: np.ndarray,
+    y: np.ndarray,
+    *,
+    cluster_ids: Optional[np.ndarray] = None,
+    return_vcov: bool = True,
+    return_fitted: bool = False,
+) -> Union[
+    Tuple[np.ndarray, np.ndarray, Optional[np.ndarray]],
+    Tuple[np.ndarray, np.ndarray, np.ndarray, Optional[np.ndarray]],
+]:
+    """
+    NumPy/SciPy fallback implementation of solve_ols.
+
+    Uses scipy.linalg.lstsq with 'gelsy' driver (QR with column pivoting)
+    for fast and stable least squares solving.
+
+    Parameters
+    ----------
+    X : np.ndarray
+        Design matrix of shape (n, k).
+    y : np.ndarray
+        Response vector of shape (n,).
+    cluster_ids : np.ndarray, optional
+        Cluster identifiers for cluster-robust SEs.
+    return_vcov : bool
+        Whether to compute variance-covariance matrix.
+    return_fitted : bool
+        Whether to return fitted values.
+
+    Returns
+    -------
+    coefficients : np.ndarray
+        OLS coefficients of shape (k,).
+    residuals : np.ndarray
+        Residuals of shape (n,).
+    fitted : np.ndarray, optional
+        Fitted values if return_fitted=True.
+    vcov : np.ndarray, optional
+        Variance-covariance matrix if return_vcov=True.
+    """
     # Solve OLS using scipy's optimized solver
     # 'gelsy' uses QR with column pivoting, faster than default 'gelsd' (SVD)
     # Note: gelsy doesn't reliably report rank, so we don't check for deficiency
@@ -131,7 +221,7 @@ def solve_ols(
     # Compute variance-covariance matrix if requested
     vcov = None
     if return_vcov:
-        vcov = compute_robust_vcov(X, residuals, cluster_ids)
+        vcov = _compute_robust_vcov_numpy(X, residuals, cluster_ids)
 
     if return_fitted:
         return coefficients, residuals, fitted, vcov
@@ -176,6 +266,63 @@ def compute_robust_vcov(
     The cluster-robust computation is vectorized using pandas groupby,
     which is much faster than a Python loop over clusters.
     """
+    # Use Rust backend if available
+    if HAS_RUST_BACKEND:
+        X = np.ascontiguousarray(X, dtype=np.float64)
+        residuals = np.ascontiguousarray(residuals, dtype=np.float64)
+
+        cluster_ids_int = None
+        if cluster_ids is not None:
+            cluster_ids_int = pd.factorize(cluster_ids)[0].astype(np.int64)
+
+        try:
+            return _rust_compute_robust_vcov(X, residuals, cluster_ids_int)
+        except ValueError as e:
+            # Translate Rust LAPACK errors to consistent Python error messages
+            error_msg = str(e)
+            if "Matrix inversion failed" in error_msg:
+                raise ValueError(
+                    "Design matrix is rank-deficient (singular X'X matrix). "
+                    "This indicates perfect multicollinearity. Check your fixed effects "
+                    "and covariates for linear dependencies."
+                ) from e
+            raise
+
+    # Fallback to NumPy implementation
+    return _compute_robust_vcov_numpy(X, residuals, cluster_ids)
+
+
+def _compute_robust_vcov_numpy(
+    X: np.ndarray,
+    residuals: np.ndarray,
+    cluster_ids: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """
+    NumPy fallback implementation of compute_robust_vcov.
+
+    Computes HC1 (heteroskedasticity-robust) or cluster-robust variance-covariance
+    matrix using the sandwich estimator.
+
+    Parameters
+    ----------
+    X : np.ndarray
+        Design matrix of shape (n, k).
+    residuals : np.ndarray
+        OLS residuals of shape (n,).
+    cluster_ids : np.ndarray, optional
+        Cluster identifiers. If None, uses HC1. If provided, uses
+        cluster-robust with G/(G-1) small-sample adjustment.
+
+    Returns
+    -------
+    vcov : np.ndarray
+        Variance-covariance matrix of shape (k, k).
+
+    Notes
+    -----
+    Uses vectorized groupby aggregation for cluster-robust SEs to avoid
+    the O(n * G) loop that would be required with explicit iteration.
+    """
     n, k = X.shape
     XtX = X.T @ X
 

{diff_diff-1.4.0 → diff_diff-2.0.0}/diff_diff/staggered.py

@@ -20,6 +20,9 @@ from diff_diff.utils import (
     compute_p_value,
 )
 
+# Import Rust backend if available (from _backend to avoid circular imports)
+from diff_diff._backend import HAS_RUST_BACKEND, _rust_bootstrap_weights
+
 # Type alias for pre-computed structures
 PrecomputedData = Dict[str, Any]
 
@@ -99,6 +102,45 @@ def _generate_bootstrap_weights_batch(
     rng : np.random.Generator
         Random number generator.
 
+    Returns
+    -------
+    np.ndarray
+        Array of bootstrap weights with shape (n_bootstrap, n_units).
+    """
+    # Use Rust backend if available (parallel + fast RNG)
+    if HAS_RUST_BACKEND:
+        # Get seed from the NumPy RNG for reproducibility
+        seed = rng.integers(0, 2**63 - 1)
+        return _rust_bootstrap_weights(n_bootstrap, n_units, weight_type, seed)
+
+    # Fallback to NumPy implementation
+    return _generate_bootstrap_weights_batch_numpy(n_bootstrap, n_units, weight_type, rng)
+
+
+def _generate_bootstrap_weights_batch_numpy(
+    n_bootstrap: int,
+    n_units: int,
+    weight_type: str,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    NumPy fallback implementation of _generate_bootstrap_weights_batch.
+
+    Generates multiplier bootstrap weights for wild cluster bootstrap.
+    All weight distributions satisfy E[w] = 0, E[w^2] = 1.
+
+    Parameters
+    ----------
+    n_bootstrap : int
+        Number of bootstrap iterations.
+    n_units : int
+        Number of units (clusters) to generate weights for.
+    weight_type : str
+        Type of weights: "rademacher" (+-1), "mammen" (2-point),
+        or "webb" (6-point).
+    rng : np.random.Generator
+        Random number generator for reproducibility.
+
     Returns
     -------
     np.ndarray
@@ -1074,7 +1116,9 @@ class CallawaySantAnna:
             )
 
         # Compute overall ATT (simple aggregation)
-        overall_att, overall_se = self._aggregate_simple(group_time_effects, df, unit)
+        overall_att, overall_se = self._aggregate_simple(
+            group_time_effects, influence_func_info, df, unit
+        )
         overall_t = overall_att / overall_se if overall_se > 0 else 0.0
         overall_p = compute_p_value(overall_t)
         overall_ci = compute_confidence_interval(overall_att, overall_se, self.alpha)
@@ -1085,12 +1129,13 @@ class CallawaySantAnna:
 
         if aggregate in ["event_study", "all"]:
             event_study_effects = self._aggregate_event_study(
-                group_time_effects, treatment_groups, time_periods, balance_e
+                group_time_effects, influence_func_info,
+                treatment_groups, time_periods, balance_e
             )
 
         if aggregate in ["group", "all"]:
             group_effects = self._aggregate_by_group(
-                group_time_effects, treatment_groups
+                group_time_effects, influence_func_info, treatment_groups
             )
 
         # Run bootstrap inference if requested
@@ -1423,6 +1468,7 @@ class CallawaySantAnna:
     def _aggregate_simple(
         self,
         group_time_effects: Dict,
+        influence_func_info: Dict,
         df: pd.DataFrame,
         unit: str,
     ) -> Tuple[float, float]:
@@ -1430,19 +1476,22 @@ class CallawaySantAnna:
         Compute simple weighted average of ATT(g,t).
 
         Weights by group size (number of treated units).
+
+        Standard errors are computed using influence function aggregation,
+        which properly accounts for covariances across (g,t) pairs due to
+        shared control units. This matches R's `did` package approach.
         """
         effects = []
-        weights = []
-        variances = []
+        weights_list = []
+        gt_pairs = []
 
         for (g, t), data in group_time_effects.items():
             effects.append(data['effect'])
-            weights.append(data['n_treated'])
-            variances.append(data['se'] ** 2)
+            weights_list.append(data['n_treated'])
+            gt_pairs.append((g, t))
 
         effects = np.array(effects)
-        weights = np.array(weights, dtype=float)
-        variances = np.array(variances)
+        weights = np.array(weights_list, dtype=float)
 
         # Normalize weights
         weights = weights / np.sum(weights)
@@ -1450,15 +1499,77 @@ class CallawaySantAnna:
         # Weighted average
         overall_att = np.sum(weights * effects)
 
-        # Standard error (assuming independence across g,t)
-        overall_var = np.sum((weights ** 2) * variances)
-        overall_se = np.sqrt(overall_var)
+        # Compute SE using influence function aggregation
+        overall_se = self._compute_aggregated_se(
+            gt_pairs, weights, influence_func_info
+        )
 
         return overall_att, overall_se
 
+    def _compute_aggregated_se(
+        self,
+        gt_pairs: List[Tuple[Any, Any]],
+        weights: np.ndarray,
+        influence_func_info: Dict,
+    ) -> float:
+        """
+        Compute standard error using influence function aggregation.
+
+        This properly accounts for covariances across (g,t) pairs by
+        aggregating unit-level influence functions:
+
+            ψ_i(overall) = Σ_{(g,t)} w_(g,t) × ψ_i(g,t)
+            Var(overall) = (1/n) Σ_i [ψ_i]²
+
+        This matches R's `did` package analytical SE formula.
+        """
+        if not influence_func_info:
+            # Fallback if no influence functions available
+            return 0.0
+
+        # Build unit index mapping from all (g,t) pairs
+        all_units = set()
+        for (g, t) in gt_pairs:
+            if (g, t) in influence_func_info:
+                info = influence_func_info[(g, t)]
+                all_units.update(info['treated_units'])
+                all_units.update(info['control_units'])
+
+        if not all_units:
+            return 0.0
+
+        all_units = sorted(all_units)
+        n_units = len(all_units)
+        unit_to_idx = {u: i for i, u in enumerate(all_units)}
+
+        # Aggregate influence functions across (g,t) pairs
+        psi_overall = np.zeros(n_units)
+
+        for j, (g, t) in enumerate(gt_pairs):
+            if (g, t) not in influence_func_info:
+                continue
+
+            info = influence_func_info[(g, t)]
+            w = weights[j]
+
+            # Treated unit contributions
+            for i, unit_id in enumerate(info['treated_units']):
+                idx = unit_to_idx[unit_id]
+                psi_overall[idx] += w * info['treated_inf'][i]
+
+            # Control unit contributions
+            for i, unit_id in enumerate(info['control_units']):
+                idx = unit_to_idx[unit_id]
+                psi_overall[idx] += w * info['control_inf'][i]
+
+        # Compute variance: Var(θ̄) = (1/n) Σᵢ ψᵢ²
+        variance = np.sum(psi_overall ** 2)
+        return np.sqrt(variance)
+
     def _aggregate_event_study(
         self,
         group_time_effects: Dict,
+        influence_func_info: Dict,
         groups: List[Any],
         time_periods: List[Any],
         balance_e: Optional[int] = None,
@@ -1467,17 +1578,20 @@ class CallawaySantAnna:
         Aggregate effects by relative time (event study).
 
         Computes average effect at each event time e = t - g.
+
+        Standard errors use influence function aggregation to account for
+        covariances across (g,t) pairs.
         """
-        # Organize effects by relative time
-        effects_by_e: Dict[int, List[Tuple[float, float, int]]] = {}
+        # Organize effects by relative time, keeping track of (g,t) pairs
+        effects_by_e: Dict[int, List[Tuple[Tuple[Any, Any], float, int]]] = {}
 
         for (g, t), data in group_time_effects.items():
             e = t - g  # Relative time
             if e not in effects_by_e:
                 effects_by_e[e] = []
             effects_by_e[e].append((
+                (g, t),  # Keep track of the (g,t) pair
                 data['effect'],
-                data['se'],
                 data['n_treated']
             ))
 
@@ -1490,15 +1604,15 @@ class CallawaySantAnna:
                     groups_at_e.add(g)
 
             # Filter effects to only include balanced groups
-            balanced_effects: Dict[int, List[Tuple[float, float, int]]] = {}
+            balanced_effects: Dict[int, List[Tuple[Tuple[Any, Any], float, int]]] = {}
             for (g, t), data in group_time_effects.items():
                 if g in groups_at_e:
                     e = t - g
                     if e not in balanced_effects:
                         balanced_effects[e] = []
                     balanced_effects[e].append((
+                        (g, t),
                         data['effect'],
-                        data['se'],
                         data['n_treated']
                     ))
             effects_by_e = balanced_effects
@@ -1507,16 +1621,19 @@ class CallawaySantAnna:
         event_study_effects = {}
 
         for e, effect_list in sorted(effects_by_e.items()):
-            effs = np.array([x[0] for x in effect_list])
-            ses = np.array([x[1] for x in effect_list])
+            gt_pairs = [x[0] for x in effect_list]
+            effs = np.array([x[1] for x in effect_list])
             ns = np.array([x[2] for x in effect_list], dtype=float)
 
             # Weight by group size
             weights = ns / np.sum(ns)
 
             agg_effect = np.sum(weights * effs)
-            agg_var = np.sum((weights ** 2) * (ses ** 2))
-            agg_se = np.sqrt(agg_var)
+
+            # Compute SE using influence function aggregation
+            agg_se = self._compute_aggregated_se(
+                gt_pairs, weights, influence_func_info
+            )
 
             t_stat = agg_effect / agg_se if agg_se > 0 else 0.0
             p_val = compute_p_value(t_stat)
@@ -1536,19 +1653,24 @@ class CallawaySantAnna:
     def _aggregate_by_group(
         self,
         group_time_effects: Dict,
+        influence_func_info: Dict,
         groups: List[Any],
     ) -> Dict[Any, Dict[str, Any]]:
         """
         Aggregate effects by treatment cohort.
 
         Computes average effect for each cohort across all post-treatment periods.
+
+        Standard errors use influence function aggregation to account for
+        covariances across time periods within a cohort.
         """
         group_effects = {}
 
         for g in groups:
             # Get all effects for this group (post-treatment only: t >= g)
+            # Keep track of (g, t) pairs for influence function aggregation
             g_effects = [
-                (data['effect'], data['se'], data['n_treated'])
+                ((g, t), data['effect'])
                 for (gg, t), data in group_time_effects.items()
                 if gg == g and t >= g
             ]
@@ -1556,15 +1678,18 @@ class CallawaySantAnna:
             if not g_effects:
                 continue
 
-            effs = np.array([x[0] for x in g_effects])
-            ses = np.array([x[1] for x in g_effects])
+            gt_pairs = [x[0] for x in g_effects]
+            effs = np.array([x[1] for x in g_effects])
 
             # Equal weight across time periods for a group
             weights = np.ones(len(effs)) / len(effs)
 
             agg_effect = np.sum(weights * effs)
-            agg_var = np.sum((weights ** 2) * (ses ** 2))
-            agg_se = np.sqrt(agg_var)
+
+            # Compute SE using influence function aggregation
+            agg_se = self._compute_aggregated_se(
+                gt_pairs, weights, influence_func_info
+            )
 
             t_stat = agg_effect / agg_se if agg_se > 0 else 0.0
             p_val = compute_p_value(t_stat)