"panel where every unit is observed in every time period."

)

# Reject duplicate (unit, time) rows

dup_mask = df.duplicated(subset=[unit, time], keep=False)

if dup_mask.any():

n_dups = int(dup_mask.sum())

raise ValueError(

f"Found {n_dups} duplicate ({unit}, {time}) rows. "

"EfficientDiD requires exactly one observation per unit-period."

)

# Validate absorbing treatment (vectorized)

ft_nunique = df.groupby(unit)[first_treat].nunique()

bad_units = ft_nunique[ft_nunique > 1]

period_1_col = period_to_col[period_1]

# Pivot outcome to wide matrix (n_units, n_periods)

pivot = df.pivot(index=unit, columns=time, values=outcome)

# Reindex to match all_units ordering and time_periods column order

pivot = pivot.reindex(index=all_units, columns=time_periods)

outcome_wide = pivot.values.astype(float)

if balance_e is not None:

groups_at_e = {

gt_pairs[j][0]

for j, (g, t) in enumerate(gt_pairs)

if t - g == balance_e and np.isfinite(original_atts[j])

}

balanced: Dict[int, List[Tuple[int, float, float]]] = {}

for j, (g, t) in enumerate(gt_pairs):

- **All units eventually treated**: Last cohort serves as "never-treated" by dropping last time period (Phase 1: raises ValueError; last-cohort-as-control fallback planned for Phase 2)

- **Negative weights**: Explicitly stated as harmless for bias and beneficial for precision; arise from efficiency optimization under overidentification (Section 5.2)

- **PT-Post regime (just-identified)**: Under PT-Post, EDiD automatically reduces to standard single-baseline estimator (Corollary 3.2). No downside to using EDiD -- it subsumes standard estimators

- **Duplicate rows**: Duplicate `(unit, time)` entries are rejected with `ValueError`. The estimator requires exactly one observation per unit-period

- **PT-All index set**: Under PT-All, valid (g', t_pre) pairs require only t_pre < g' (pre-treatment for the comparison group), not t_pre < g. Same-group pairs (g'=g) are valid and contribute overidentifying moments. This follows from Equation 3.9: the target group g appears only in the first term (Y_t - Y_1), which is independent of t_pre

- **Bootstrap aggregation**: Multiplier bootstrap uses fixed cohort-size weights for overall/event-study aggregation, matching the CallawaySantAnna bootstrap pattern (CallawaySantAnnaBootstrapMixin._run_multiplier_bootstrap). The analytical path includes a WIF correction; the bootstrap captures sampling variability through per-cell EIF perturbation without re-estimating aggregation weights, consistent with both the library's CS implementation and the R `did` package approach

- **Overall ATT convention**: The library's `overall_att` uses cohort-size-weighted averaging of post-treatment (g,t) cells, matching the CallawaySantAnna simple aggregation. This differs from the paper's ES_avg (Eq 2.3), which uniformly averages over event-time horizons. ES_avg can be computed from event study output as `mean(event_study_effects[e]["effect"] for e >= 0)`

*Algorithm (two-step semiparametric estimation, Section 4):*

with pytest.raises(ValueError, match="never-treated"):

EfficientDiD(pt_assumption="post").fit(df, "y", "unit", "time", "first_treat")

def test_duplicate_unit_time_raises(self):

"""Duplicate (unit, time) rows should be rejected."""

df = _make_simple_panel()

# Duplicate a row

dup_row = df.iloc[[0]].copy()

df = pd.concat([df, dup_row], ignore_index=True)

with pytest.raises(ValueError, match="duplicate"):

EfficientDiD().fit(df, "y", "unit", "time", "first_treat")

class TestSklearnCompat:

"""Test get_params / set_params."""

assert len(post_effects) > 0

class TestBalanceE:

"""Test balance_e event study balancing."""

def test_balance_e_basic(self):

"""balance_e restricts event study to cohorts present at anchor horizon."""

df = _make_staggered_panel(n_per_group=80, n_control=80, groups=(3, 5))

result = EfficientDiD().fit(

df,

"y",

"unit",

"time",

"first_treat",

aggregate="event_study",

balance_e=0,

)

assert result.event_study_effects is not None

for e, d in result.event_study_effects.items():

assert np.isfinite(d["effect"])

def test_balance_e_with_bootstrap(self, ci_params):

"""Bootstrap balance_e should produce finite SEs."""

n_boot = ci_params.bootstrap(99)

df = _make_staggered_panel(n_per_group=80, n_control=80, groups=(3, 5))

result = EfficientDiD(n_bootstrap=n_boot, seed=42).fit(

df,

"y",

"unit",

"time",

"first_treat",

aggregate="event_study",

balance_e=0,

)

assert result.event_study_effects is not None

for e, d in result.event_study_effects.items():

if np.isfinite(d["effect"]):

assert np.isfinite(d["se"])

def test_balance_e_nan_anchor_filters_group(self):

"""When a group has NaN at the anchor horizon, bootstrap should

edid = EfficientDiD()

edid.anticipation = 0

# Simulate: group 3 has finite effect at e=0, group 5 has NaN at e=0

gt_pairs = [(3.0, 3), (3.0, 4), (5.0, 5), (5.0, 6)]

original_atts = np.array([1.0, 1.5, np.nan, 0.8])

cohort_fractions = {3.0: 0.4, 5.0: 0.3}

result = edid._prepare_es_agg_boot(gt_pairs, original_atts, cohort_fractions, balance_e=0)

# Group 5 has NaN at e=0 (t=5, g=5), so it should be excluded

# Only group 3 effects should appear in the balanced set

for e, info in result.items():

gt_indices = info["gt_indices"]

groups_in_e = {gt_pairs[j][0] for j in gt_indices}

assert 5.0 not in groups_in_e, (

f"Group 5 (NaN at anchor) should be excluded at e={e}, " f"got groups {groups_in_e}"

)