using DataFrames
using DataFramesMeta
using Panelest
using Vcov
using StatsModels
import StatsAPI: coeftable
using ReadStatTables
using CSV
using SynthDiD
using CairoMakie
CairoMakie.activate!(type = "png")
using Statistics
using Printf
using RegressionTables
using Random
using DistributionsWhen unconfoundedness fails, we need weaker assumptions. The parallel trends assumption leads to the difference-in-differences estimator.
Related reading: For a side-by-side comparison of DiD, synthetic control, synthetic DiD, and multivariate SC on a single panel — and how the choice of estimator changes the answer — see the Same data, different estimators chapter of Topics on Econometrics and Causal Inference.
Suppose we have two periods, \(t = (1,2)\). Some units are treated just prior to period 2. For each individual \(i\), there are four potential outcomes:
\[ [Y_{i1}(0), Y_{i1}(1), Y_{i2}(0), Y_{i2}(1)] \tag{13.1}\]
Let \(D\) denote the treated group. The ATT in period 2 is
\[ \tau_{2,att} = E(Y_2(1) - Y_2(0) | D=1) \tag{13.2}\]
The first term is observed. The second is the counterfactual.
\[ E[Y_2(0) -Y_1(0) | D=1] = E[Y_2(0) - Y_1(0) | D =0] \tag{13.3}\]
or
\[ E[\Delta Y(0) | D=1] = E[\Delta Y(0) | D =0] \tag{13.4}\]
In words, the change in untreated potential outcomes between periods 1 and 2 is the same for treated and control groups.
\[ E[Y_1(1) - Y_1(0) | D=1] = 0 \tag{13.5}\]
This is to say, in period 1, there is no treatment effect for the treated group.
With Parallel Trends, we notice \[\small E[Y_2(0) | D=1 ]= E[Y_1(0) | D=1] + E[Y_2(0) - Y_1(0) | D=0] \tag{13.6}\]
Then, with No Anticipation, \[ \begin{aligned} E[Y_2(0) | D=1 ] &= E[Y_1(1) | D=1] + E[Y_2(0) - Y_1(0) | D=0]\\ &= E[Y_1 | D=1] + E[Y_2-Y_1 | D=0] \end{aligned} \tag{13.7}\]
\[\small \tau_{2,att} = E[Y_2 - Y_1 | D=1] - E[Y_2-Y_1 | D=0] \tag{13.8}\]
Advantages:
Disadvantages:
In practice, DiD in many period setting is usually done with
\[ Y_{it} = \alpha_i + \phi_t + W_{it} \beta + \epsilon_{it} \tag{13.9}\]
here \(W_{it} =(1[t=2] \cdot D_i)\), which is the interaction of post-treatment indicator and treatment group indicator.
This is usually called Two Way Fixed Effect (TWFE). There are multiple ways to implement the same model in practice.
TWFE can be done by “Pooled OLS”. That is, using OLS on time dummies and firm (individual) dummies. Wooldridge (2021) shows it’s equivalent to use treatment dummies, instead of individual dummies. He also shows that this model can be equivalently implemented with fixed effect model and random effect model.
The problem comes in when there is different timing of treatment. People used to still use
\[ Y_{it} = \alpha_i + \phi_t + W_{it} \beta + \epsilon_{it} \tag{13.10}\]
where \(W_{it}\) now is a dummy when an individual \(i\) gets treated at time \(t\).
However, what is \(\beta\) here?
Goodman-Bacon (2021) showed that \(\beta\) in the TWFE is a weighted average of many different treatment effects, between treated cohorts, and control units, both can be different at different time points. The weights are a function of the size of the subsample, relative size of treatment and control units, and the timing of treatment in the sub sample. The decomposition weights themselves are non-negative and sum to one; the problem is that the units treated earlier are used as controls later. When those “forbidden” 2x2 comparisons are expressed in terms of the underlying cohort-time ATTs, some ATTs receive negative weight (de Chaisemartin and D’Haultfœuille 2020). Therefore there is no meaningful interpretation of \(\beta\): it does not need to be a convex combination of treatment effects.
There are a lot of ways to deal with staggered DiD situation. Wooldridge (2021) is basically saying: This is not a problem of TWFE, it’s a mis-use of TWFE. The reason we get non-sensible result of \(\beta\) is that we know there is heterogeneous treatment effect, in the sense the treatment effect differs across cohort, but we force them to be the same. If we relax it, it can work. As he shows, this works when we specify cohort effects accordingly.
\[ y_{it} = \alpha_i + \phi_t + \sum_{g=g_0}^G \sum_{t=g}^T \lambda_{g,t} \times 1(g,t) + \epsilon_{i,t} \tag{13.11}\]
Here \(g\) is a cohort indicator, a cohort is determined by the time of getting treatment. ETWFE is allowing each cohort to have different effect at each different time point after being treated. The baseline group is the never treated group. If there is no never treated group, it can easily changed to comparing to the last treated group.
We’ll use the mpdta dataset on US teen employment from the did package. “Treatment” in this dataset refers to an increase in the minimum wage rate. Our goal is to estimate the effect of this minimum wage treatment (treat) on the log of teen employment (lemp). Notice that the panel ID is at the county level (countyreal), but treatment was staggered across cohorts (first_treat) so that a group of counties were treated at the same time. In addition to these staggered treatment effects, we also observe log population (lpop) as a potential control variable.
# Load mpdta dataset from the did R package (Callaway & Sant'Anna 2021)
# US teen employment data; treatment = minimum wage increase
mpdta = CSV.read("data/mpdta.csv", DataFrame)
rename!(mpdta, "first.treat" => "first_treat")
first(mpdta, 6)| Row | year | countyreal | lpop | lemp | first_treat | treat |
|---|---|---|---|---|---|---|
| Int64 | Int64 | Float64 | Float64 | Int64 | Int64 | |
| 1 | 2003 | 8001 | 5.89676 | 8.46147 | 2007 | 1 |
| 2 | 2004 | 8001 | 5.89676 | 8.33687 | 2007 | 1 |
| 3 | 2005 | 8001 | 5.89676 | 8.34022 | 2007 | 1 |
| 4 | 2006 | 8001 | 5.89676 | 8.37816 | 2007 | 1 |
| 5 | 2007 | 8001 | 5.89676 | 8.48735 | 2007 | 1 |
| 6 | 2003 | 8019 | 2.23238 | 4.99721 | 2007 | 1 |
combine(groupby(mpdta, :year), nrow)
combine(groupby(mpdta, :treat), nrow)
combine(groupby(mpdta, :first_treat), nrow)| Row | first_treat | nrow |
|---|---|---|
| Int64 | Int64 | |
| 1 | 0 | 1545 |
| 2 | 2004 | 100 |
| 3 | 2006 | 200 |
| 4 | 2007 | 655 |
# String columns enable StatsModels to generate cohort×time dummies (ETWFE)
mpdta.first_treat_str = string.(mpdta.first_treat)
mpdta.year_str = string.(mpdta.year)
mod = feols(mpdta, @formula(lemp ~ lpop + first_treat_str & year_str + fe(countyreal) + fe(year)), vcov = Vcov.cluster(:countyreal));show_regression_html(mod)| Estimate | Std. Error | t value | Pr(>|t|) | |
|---|---|---|---|---|
| lpop | -3.414e-33 | 2.694e-33 | -1.267 | 0.205 |
| first_treat_str: 0 & year_str: 2003 | -0.016 | 0.010 | -1.594 | 0.111 |
| first_treat_str: 2004 & year_str: 2003 | 0.048 | 0.016 | 2.992 | 0.003 ** |
| first_treat_str: 2006 & year_str: 2003 | -0.010 | 0.017 | -0.611 | 0.541 |
| first_treat_str: 2007 & year_str: 2003 | -0.021 | 0.012 | -1.802 | 0.072 . |
| first_treat_str: 0 & year_str: 2004 | -0.023 | 0.008 | -2.982 | 0.003 ** |
| first_treat_str: 2004 & year_str: 2004 | 0.031 | 0.014 | 2.199 | 0.028 * |
| first_treat_str: 2006 & year_str: 2004 | -0.011 | 0.010 | -1.070 | 0.285 |
| first_treat_str: 2007 & year_str: 2004 | 0.003 | 0.009 | 0.305 | 0.761 |
| first_treat_str: 0 & year_str: 2005 | -0.006 | 0.006 | -0.979 | 0.328 |
| first_treat_str: 2004 & year_str: 2005 | -0.013 | 0.010 | -1.244 | 0.214 |
| first_treat_str: 2006 & year_str: 2005 | 0.003 | 0.009 | 0.327 | 0.744 |
| first_treat_str: 2007 & year_str: 2005 | 0.016 | 0.008 | 2.050 | 0.040 * |
| first_treat_str: 0 & year_str: 2006 | 0.019 | 0.008 | 2.334 | 0.020 * |
| first_treat_str: 2004 & year_str: 2006 | -0.054 | 0.013 | -4.082 | 4.468e-05 *** |
| first_treat_str: 2006 & year_str: 2006 | 0.024 | 0.010 | 2.363 | 0.018 * |
| first_treat_str: 2007 & year_str: 2006 | 0.011 | 0.009 | 1.170 | 0.242 |
| first_treat_str: 0 & year_str: 2007 | 0.026 | 0.009 | 2.824 | 0.005 ** |
| first_treat_str: 2004 & year_str: 2007 | -0.011 | 0.016 | -0.720 | 0.472 |
| first_treat_str: 2006 & year_str: 2007 | -0.006 | 0.013 | -0.476 | 0.634 |
| first_treat_str: 2007 & year_str: 2007 | -0.009 | 0.011 | -0.766 | 0.444 |
| --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 |
||||
emfx(mod)| Row | type | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| String | Float64 | Float64 | Float64 | Float64 | |
| 1 | ATT | -0.00547767 | 0.00252612 | -0.0104288 | -0.000526576 |
mod_es = emfx(mod, type = "event")
mod_es| Row | event | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| Int64 | Float64 | Float64 | Float64 | Float64 | |
| 1 | 0 | 0.0153342 | 0.00778068 | 8.43689e-5 | 0.030584 |
| 2 | 1 | -0.00949622 | 0.0079286 | -0.025036 | 0.00604351 |
| 3 | 2 | -0.0541802 | 0.0132735 | -0.0801957 | -0.0281647 |
| 4 | 3 | -0.0111736 | 0.015526 | -0.041604 | 0.0192568 |
mod_es2 = emfx(mod, type = "event", post_only = false)
fig = Figure()
ax = Axis(fig[1, 1],
xlabel = "Years post treatment",
ylabel = "Effect on log teen employment",
title = "Note: Zero pre-treatment effects for illustrative purposes only.")
hlines!(ax, 0, color = :black)
vlines!(ax, -1, color = :black, linestyle = :dash)
rangebars!(ax, mod_es2.event, mod_es2.conf_low, mod_es2.conf_high, color = :darkcyan)
scatter!(ax, mod_es2.event, mod_es2.estimate, color = :darkcyan)
fig
did_data = DataFrame(readstat("data/did_staggered_6.dta"))
@rtransform! did_data :first_treat = begin
if :d4 == 1
2004
elseif :d5 == 1
2005
elseif :d6 == 1
2006
else
0
end
end
first(select(did_data, :id, :year, :y, :x, :d4, :d5, :d6, :te4, :te5, :te6, :first_treat), 6)| Row | id | year | y | x | d4 | d5 | d6 | te4 | te5 | te6 | first_treat |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Int16 | Int16 | Float32 | Float32 | Int8 | Int8 | Int8 | Float32 | Float32 | Float32 | Int64 | |
| 1 | 1 | 2001 | 18.3596 | 0.899984 | 0 | 0 | 0 | 0.0 | 0.0 | 0.0 | 0 |
| 2 | 1 | 2002 | 18.1016 | 0.899984 | 0 | 0 | 0 | 0.0 | 0.0 | 0.0 | 0 |
| 3 | 1 | 2003 | 18.5956 | 0.899984 | 0 | 0 | 0 | 0.0 | 0.0 | 0.0 | 0 |
| 4 | 1 | 2004 | 16.5003 | 0.899984 | 0 | 0 | 0 | 1.43223 | 0.0 | 0.0 | 0 |
| 5 | 1 | 2005 | 19.9573 | 0.899984 | 0 | 0 | 0 | 2.57319 | 2.24723 | 0.0 | 0 |
| 6 | 1 | 2006 | 19.8659 | 0.899984 | 0 | 0 | 0 | 5.06752 | 4.23316 | 0.785892 | 0 |
combine(groupby(did_data, :first_treat), nrow)| Row | first_treat | nrow |
|---|---|---|
| Int64 | Int64 | |
| 1 | 0 | 1572 |
| 2 | 2004 | 714 |
| 3 | 2005 | 498 |
| 4 | 2006 | 216 |
@rtransform! did_data :treated_cohort1 = begin
if :d4 == 1 && :f04 == 1
"d4f04"
elseif :d4 == 1 && :f05 == 1
"d4f05"
elseif :d4 == 1 && :f06 == 1
"d4f06"
else
missing
end
end
@rtransform! did_data :treated_cohort2 = begin
if :d5 == 1 && :f05 == 1
"d5f05"
elseif :d5 == 1 && :f06 == 1
"d5f06"
else
missing
end
end
@rtransform! did_data :treated_cohort3 = begin
if :d6 == 1 && :f06 == 1
"d6f06"
else
missing
end
end
combine(groupby(dropmissing(did_data, :treated_cohort1), :treated_cohort1), :te4 => mean => :mean4)| Row | treated_cohort1 | mean4 |
|---|---|---|
| String | Float32 | |
| 1 | d4f04 | 3.75709 |
| 2 | d4f05 | 4.01757 |
| 3 | d4f06 | 4.57895 |
combine(groupby(dropmissing(did_data, :treated_cohort2), :treated_cohort2), :te5 => mean => :mean5)
combine(groupby(dropmissing(did_data, :treated_cohort3), :treated_cohort3), :te6 => mean => :mean6)| Row | treated_cohort3 | mean6 |
|---|---|---|
| String | Float32 | |
| 1 | d6f06 | 1.84886 |
# String columns needed for cohort×time ETWFE dummies
did_data.first_treat_str = string.(did_data.first_treat)
did_data.year_str = string.(did_data.year)
# this replicates Jeff's results with pooled ols or xtreg, with covariate x.
mod = feols(did_data, @formula(y ~ x + first_treat_str & year_str + fe(id) + fe(year)), vcov = Vcov.cluster(:id))
show_regression_html(mod)| Estimate | Std. Error | t value | Pr(>|t|) | |
|---|---|---|---|---|
| x | -1.313e-32 | 5.787e-32 | -0.227 | 0.820 |
| first_treat_str: 0 & year_str: 2001 | 0.913 | 0.133 | 6.850 | 7.378e-12 *** |
| first_treat_str: 2004 & year_str: 2001 | -1.124 | 0.159 | -7.086 | 1.381e-12 *** |
| first_treat_str: 2005 & year_str: 2001 | -0.425 | 0.172 | -2.465 | 0.014 * |
| first_treat_str: 2006 & year_str: 2001 | 0.636 | 0.242 | 2.625 | 0.009 ** |
| first_treat_str: 0 & year_str: 2002 | 0.802 | 0.129 | 6.194 | 5.854e-10 *** |
| first_treat_str: 2004 & year_str: 2002 | -1.198 | 0.178 | -6.724 | 1.767e-11 *** |
| first_treat_str: 2005 & year_str: 2002 | -0.291 | 0.181 | -1.610 | 0.107 |
| first_treat_str: 2006 & year_str: 2002 | 0.687 | 0.233 | 2.950 | 0.003 ** |
| first_treat_str: 0 & year_str: 2003 | 0.644 | 0.137 | 4.707 | 2.510e-06 *** |
| first_treat_str: 2004 & year_str: 2003 | -1.187 | 0.168 | -7.073 | 1.512e-12 *** |
| first_treat_str: 2005 & year_str: 2003 | 0.198 | 0.211 | 0.939 | 0.348 |
| first_treat_str: 2006 & year_str: 2003 | 0.345 | 0.260 | 1.324 | 0.186 |
| first_treat_str: 0 & year_str: 2004 | 0.224 | 0.138 | 1.628 | 0.104 |
| first_treat_str: 2004 & year_str: 2004 | 1.611 | 0.205 | 7.860 | 3.832e-15 *** |
| first_treat_str: 2005 & year_str: 2004 | -1.361 | 0.181 | -7.512 | 5.806e-14 *** |
| first_treat_str: 2006 & year_str: 2004 | -0.474 | 0.258 | -1.834 | 0.067 . |
| first_treat_str: 0 & year_str: 2005 | -0.966 | 0.146 | -6.629 | 3.389e-11 *** |
| first_treat_str: 2004 & year_str: 2005 | 1.299 | 0.213 | 6.109 | 1.000e-09 *** |
| first_treat_str: 2005 & year_str: 2005 | 0.916 | 0.223 | 4.102 | 4.092e-05 *** |
| first_treat_str: 2006 & year_str: 2005 | -1.249 | 0.254 | -4.910 | 9.123e-07 *** |
| first_treat_str: 0 & year_str: 2006 | -1.617 | 0.169 | -9.585 | < 2e-16 *** |
| first_treat_str: 2004 & year_str: 2006 | 0.600 | 0.232 | 2.587 | 0.010 ** |
| first_treat_str: 2005 & year_str: 2006 | 0.963 | 0.249 | 3.864 | 1.116e-04 *** |
| first_treat_str: 2006 & year_str: 2006 | 0.055 | 0.354 | 0.155 | 0.877 |
| --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 |
||||
emfx(mod)| Row | type | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| String | Float64 | Float64 | Float64 | Float64 | |
| 1 | ATT | 0.907151 | 0.0582209 | 0.793041 | 1.02126 |
mod_es = emfx(mod, type = "event")
mod_es| Row | event | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| Int64 | Float64 | Float64 | Float64 | Float64 | |
| 1 | 0 | 0.860449 | 0.177864 | 0.511843 | 1.20905 |
| 2 | 1 | 1.13086 | 0.165562 | 0.806369 | 1.45536 |
| 3 | 2 | 0.599837 | 0.231825 | 0.145468 | 1.05421 |
mod_es2 = emfx(mod, type = "calendar")
mod_es2| Row | calendar | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| Int64 | Float64 | Float64 | Float64 | Float64 | |
| 1 | 2004 | 1.6105 | 0.20489 | 1.20892 | 2.01208 |
| 2 | 2005 | 1.10755 | 0.122831 | 0.866807 | 1.3483 |
| 3 | 2006 | 0.539101 | 0.0562459 | 0.428862 | 0.649341 |
ETWFE is not limited to linear outcomes. When \(Y\) is a count or binary variable, the key identifying assumption shifts to Conditional Parallel Trends on the linear index: parallel trends on \(\log E[Y_{it}(\infty)]\) for Poisson, or on \(\text{logit}\, E[Y_{it}(\infty)]\) for logit. This is Wooldridge’s (2023, 2026) CPT assumption stated on \(G^{-1}(E[Y])\).
The correct Wooldridge ETWFE specification for a nonlinear model uses: - Cohort FE (one intercept per treatment cohort, including never-treated): captures selection into treatment - Year FE (common time trend): identified from never-treated units - Post-treatment cohort×year dummies (one per treated cohort per post-treatment year): capture the ATTs on the log scale
Critically, this is a pooled model, not a within-estimator. In the linear Gaussian examples above, unit FE and cohort FE give numerically identical ATTs (Wooldridge 2021). In nonlinear models, however, unit fixed effects raise the incidental-parameters problem and make average partial effects uncomputable — the unit intercepts cannot be averaged out of the nonlinear link. Wooldridge (2023) instead uses cohort intercepts (a Mundlak device), which is what etwfe implements; that is why the cohort-FE requirement matters only for Poisson/logit ETWFE.
We simulate panel data with three treatment cohorts (treated in years 3, 4, 5) and a never-treated group. The true treatment effect is multiplicative: \(\exp(0.4) - 1 \approx 49\%\) increase in counts. Parallel trends holds on the log scale.
Random.seed!(42)
N_pois = 600; Tmax_pois = 6
unit_fe_vals = randn(N_pois) .* 0.3
rows_p = [(id=i, year=t) for i in 1:N_pois for t in 1:Tmax_pois]
df_count = DataFrame(rows_p)
sort!(df_count, [:id, :year])
cohort_grp = ((df_count.id .- 1) .÷ 150) .+ 1
df_count.first_treat = [3, 4, 5, 0][cohort_grp] # 0 = never treated
df_count.treated = (df_count.first_treat .> 0) .& (df_count.year .>= df_count.first_treat)
df_count.unit_fe = unit_fe_vals[df_count.id]
df_count.log_mu = 1.0 .+ 0.2 .* df_count.year .+ df_count.unit_fe .+ 0.4 .* df_count.treated
df_count.count = rand.(Poisson.(exp.(df_count.log_mu)))
combine(groupby(df_count, [:first_treat, :treated]), :count => mean => :mean_count)| Row | first_treat | treated | mean_count |
|---|---|---|---|
| Int64 | Bool | Float64 | |
| 1 | 0 | false | 5.96222 |
| 2 | 3 | false | 3.73 |
| 3 | 3 | true | 10.5767 |
| 4 | 4 | false | 4.12222 |
| 5 | 4 | true | 11.1311 |
| 6 | 5 | false | 4.54333 |
| 7 | 5 | true | 12.63 |
etwfe() handles formula construction, cohort FE + year FE, and post-treatment dummy creation automatically. Pass family = "poisson" for count outcomes.
mod_pois = etwfe(df_count, @formula(count ~ 1);
gvar = :first_treat, tvar = :year,
family = "poisson", vcov = Vcov.cluster(:id))
# Show the coefficient table explicitly. Letting the returned struct be the
# cell's display value prints a raw
# `ETWFEResult(Panelest Model: ... CoefTable(Any[[...]]))` dump, because neither
# ETWFEResult nor CoefTable defines a text/plain show method that Jupyter picks
# up in that position.
show_regression_html(mod_pois.model)| Estimate | Std. Error | t value | Pr(>|t|) | |
|---|---|---|---|---|
| _D_g3_t3 | 0.429 | 0.051 | 8.382 | < 2e-16 *** |
| _D_g3_t4 | 0.417 | 0.051 | 8.226 | < 2e-16 *** |
| _D_g3_t5 | 0.430 | 0.056 | 7.657 | 1.902e-14 *** |
| _D_g3_t6 | 0.461 | 0.051 | 9.004 | < 2e-16 *** |
| _D_g4_t4 | 0.464 | 0.044 | 10.596 | < 2e-16 *** |
| _D_g4_t5 | 0.355 | 0.050 | 7.087 | 1.367e-12 *** |
| _D_g4_t6 | 0.415 | 0.048 | 8.630 | < 2e-16 *** |
| _D_g5_t5 | 0.462 | 0.047 | 9.812 | < 2e-16 *** |
| _D_g5_t6 | 0.427 | 0.044 | 9.729 | < 2e-16 *** |
| --- Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1 |
||||
att = emfx(mod_pois)
@printf("ATT (log scale): %.4f (SE = %.4f)\n", att.estimate[1], att.std_error[1])
@printf("IRR - 1: %.4f (true ≈ 0.492)\n", exp(att.estimate[1]) - 1)ATT (log scale): 0.4289 (SE = 0.0298)
IRR - 1: 0.5356 (true ≈ 0.492)The ATT is on the log scale (log incidence rate ratio). Exponentiate and subtract 1 for the proportional increase in counts.
mod_pois_es = emfx(mod_pois, type = "event")
fig_p = Figure()
ax_p = Axis(fig_p[1, 1],
xlabel = "Years post treatment",
ylabel = "ATT (log scale)",
title = "Poisson ETWFE event study")
hlines!(ax_p, 0, color = :black, linewidth = 1)
rangebars!(ax_p, mod_pois_es.event,
mod_pois_es.conf_low, mod_pois_es.conf_high, color = :darkcyan)
scatter!(ax_p, mod_pois_es.event, mod_pois_es.estimate, color = :darkcyan)
fig_p
df_count.log_count = log.(df_count.count .+ 1)
mod_lin = etwfe(df_count, @formula(log_count ~ 1);
gvar = :first_treat, tvar = :year,
vcov = Vcov.cluster(:id))
emfx(mod_lin)| Row | type | estimate | std_error | conf_low | conf_high |
|---|---|---|---|---|---|
| String | Float64 | Float64 | Float64 | Float64 | |
| 1 | ATT | 0.384516 | 0.0283914 | 0.32887 | 0.440162 |
The linear model estimates the ATT on the \(\log(Y+1)\) scale — a different and less interpretable quantity than the Poisson log IRR.
Everything in this chapter so far assumes SUTVA: one unit’s outcome does not depend on another unit’s treatment. That is not always plausible. A treated municipality may affect deforestation in nearby untreated municipalities. A vaccinated household may reduce transmission to nearby households. A labor-market policy in one commuting zone may change flows to its neighbors. With this kind of spatial spillover, the usual DiD estimand no longer has the interpretation we want. Xu (2023) shows that ignoring interference can produce an estimand that is neither a direct effect nor a spillover effect.
Xu (2023, 2026) develops a doubly robust DiD that keeps the identifying logic of conditional parallel trends but adds an exposure mapping \(G_{it} = G(i, W_{-it})\) for unit \(i\)’s neighborhood treatment status. The estimand is the direct ATT at exposure level \(g\),
\[ \tau_g(t, c) = \frac{1}{|S_M|} \sum_{i \in S_M} \mathbb{E}[y_{it}(c, g) - y_{it}(\infty, g) \mid z_i, C_i = c, G_{it} = g], \tag{13.12}\]
where \(C_i\) is unit \(i\)’s first treatment period (so \(\{C_i > t\}\) is the not-yet-directly-treated comparison group), \(S_M = \{C_i = c\} \cup \{C_i > t\}\), and \(g\) is a chosen exposure level. The DR plug-in averages three pieces over \(S_M\): an IPW term from the treated cohort, an IPW term from the not-yet-treated, and a regression-imputation term, with three propensity models (\(\eta_{tc}\) for cohort, \(\eta_{tcg}\) and \(\eta_{t\infty g}\) for exposure) and two outcome-change regressions. It is consistent if either all three propensities or both outcome models are correctly specified.
The companion package DidInterference.jl implements this. The 2×2 base case (Xu 2023):
using DidInterference, DataFrames
res = did_int_2x2(panel;
yname = :Y_post,
yname_pre = :Y_pre,
treat = :W,
exposure = :G,
g = 1,
covariates = [:z1, :z2],
trim = 0.01) # Xu (2026) uses 0.01 in the Brazil application
println(res.estimate, " ", res.ci)For staggered adoption (Xu 2026), did_int_staggered() loops over (cohort, time) cells with \(t \geq c\), restricts to \(S_M\) in each cell, fits the DR estimator, and aggregates across cells using joint-IF stacking (per-cell IFs share the never-treated comparison group, so independence-style SEs underestimate uncertainty noticeably). An R port with the same interface is available as didint; its Brazil Amazon Lista de Municípios Prioritários vignette replicates Section III of Xu (2026) using the public Assunção-McMillan-Murphy-Souza-Rodrigues replication archive on Zenodo.
Standard event-study TWFE regressions like
\[ Y_{it} = \alpha_i + \gamma_t + \sum_{j} D_{it}^j \delta_j + X_{it}'\beta + U_{it} \tag{13.13}\]
implicitly assume the residual has no serial dependence once unit and time fixed effects are absorbed. When outcomes are genuinely persistent — earnings, employment, consumption, anything with habits or adjustment costs — that assumption fails. The event-time dummies absorb persistence on top of the true causal effect, producing spurious pre-trends and biased post-treatment estimates whose bias grows geometrically with the event-time horizon (Botosaru and Liu 2025, Figure 1).
Botosaru and Liu (2025) introduce a dynamic panel with correlated random coefficients that handles both persistence and unit-level heterogeneity in dynamic responses:
\[ Y_{it} = \rho_Y Y_{i,t-1} + \alpha_i + \sum_j D_{it}^j \delta_{ij} + X_{it}'\beta + U_{it}, \tag{13.14}\]
with a parsimonious AR(1) on the event-time effects to keep dimensionality manageable:
\[ \delta_{ij} = \rho_\delta \delta_{i,j-1} + \varepsilon_{ij}, \quad j \geq 1. \tag{13.15}\]
The latent \(\lambda_i = (\alpha_i, \delta_{i0})\) is a unit-specific correlated random coefficient. A two-step semiparametric estimator: step 1 is quasi-maximum likelihood for the common parameters under a Gaussian working assumption on \(\lambda_i\) (consistent under misspecification); step 2 is Tweedie / Gaussian-conjugate empirical Bayes for the unit-level posterior trajectories \(\{\delta_{i,j}\}_{j=0}^J\).
A companion note (Botosaru and Liu 2026) adds a homogeneous-feedback extension: covariates \(X_{it}\) are allowed to adjust endogenously to past \(Y\) and treatment. Under the assumption that the covariate adjustment rule does not depend on \(\lambda_i\) given the observable history, the likelihood factors into a structural piece and a feedback piece, yielding a clean decomposition of dynamic treatment effects into direct (through \(\delta_{i,j}\)) and indirect (through covariate feedback) components.
The package TVHTE.jl implements both papers:
using TVHTE
# Fit on a panel with staggered cohorts and a covariate
fit = tvhte(panel_Y, baseline_Y; t0 = cohort, J = max_event_time, X = panel_X)
# Feedback model + direct/indirect counterfactual decomposition
fb = fit_feedback(panel_Y, baseline_Y, panel_X, baseline_X)
cf = simulate_counterfactual(fit, fb, alt_cohort)An R port with the same API is at tvhte; both packages have deployed docs at https://xiangao.github.io/TVHTE.jl/ and https://xiangao.github.io/tvhte/.
Synthetic control, synthetic DiD, and TASC are closely related enough that we treat them together in the next design chapter.