Examples

The examples below use the merit.csv dataset included in the package's test suite (test/data/merit.csv). It contains individual-level survey data on college attendance (coll), state identifiers (state), survey year (year), and demographic covariates (male, asian, black). The dataset covers U.S. states over the period 1989–2000 and is used to study the effect of merit scholarships on college attendance.

using DiDInt, CSV, DataFrames

merit = CSV.read(joinpath(@__DIR__, "../../test/data/merit.csv"), DataFrame);
first(merit, 5)
5×16 DataFrame
Rowcollmeritmaleblackasianyearstatechststyretaalphastchstchidindstnchidstid
Float64Float64Float64Float64Float64Int64Int64Float64Float64Float64Float64Float64Float64?Float64Float64?Float64
10.00.01.00.00.01993110.012993.0-0.3837480.03374650.0missing52.011.01.0
21.00.01.00.00.01997110.012997.00.6272880.03374650.0missing52.011.01.0
31.00.00.00.00.01992110.012992.00.5470320.03374650.0missing52.011.01.0
40.00.01.00.00.01989110.012989.0-0.3630450.03374650.0missing52.011.01.0
50.00.01.00.00.01991110.012991.0-0.3721180.03374650.0missing52.011.01.0

Staggered Adoption

This example illustrates a staggered adoption setting in which ten states adopted merit-aid programmes at different points between 1991 and 2000.

Running didint()

# Note that treated_states & state column in the merit data could alternatively
# be string vectors, here they just happen to be numeric codes instead of state names
treated_states = [34, 57, 58, 59, 61, 64, 71, 72, 85, 88];
treated_times  = [2000, 1998, 1993, 1997, 1999, 1996, 1991, 1998, 1997, 2000];

result = didint(
    "coll", "state", "year", merit;
    treatment_times = treated_times,
    treated_states  = treated_states,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = "cohort",
    nperm      = 399
)
DID-INT results
  Outcome:          coll
  Model:            Region-Varying DID-INT (ccc = "state")
  Covariates:       male, asian, black
  Aggregation:      "cohort" (by treatment time)
  Weighting:        "both"
  Controls:         never-treated states
  Periods:          1 year, from 1989 to 2000
  Standard errors:  HC1 (se) and jackknife (jknife_se)
  Permutations:     399 (seed 1234)

Aggregate ATT
 estimate       att        se          pval         jknife_se  jknife_pval  ri_pval 
────────────────────────────────────────────────────────────────────────────────────
 Aggregate ATT  0.0462414  0.00769881  0.000959237  0.0123516   0.00046902   0.0975

Sub-aggregate ATTs by treatment time (7)
 treatment_time  att          se          pval       jknife_se        jknife_pval      ri_pval  weight    
──────────────────────────────────────────────────────────────────────────────────────────────────────────
 1991-01-01       0.0553354   0.0222024   0.0342914  missing          missing           0.4575  0.201796
 1993-01-01       0.0504489   0.0161905   0.0169391  missing          missing           0.5175  0.191535
 1996-01-01       0.0424116   0.0255707   0.172536   missing          missing           0.5725  0.0756734
 1997-01-01       0.0606879   0.0236147   0.037012         0.0328756        0.0708186   0.28    0.321077
 1998-01-01       0.0398137   0.0406649   0.372511         0.0813398        0.626647    0.5825  0.108593
 1999-01-01       0.00173622  0.00350574  0.707256   missing          missing           0.985   0.0354853
 2000-01-01      -0.0253317   0.0333203   0.586179         0.0971445        0.795346    0.755   0.0658401

didint() returns a DiDIntResult. Displaying it, as above, prints a summary of the specification, the aggregate ATT, and the sub-aggregate ATTs (here, one per treatment time). Jackknife standard errors are missing for cohorts with a single treated state (see the Jackknife section).

Working with the results

The estimates are stored as tables in the fields of the result. The aggregate ATT with its standard errors and p-values:

result.agg
1×7 DataFrame
Rowestimateattsepvaljknife_sejknife_pvalri_pval
StringFloat64?Float64?Float64?Float64?Float64?Float64?
1Aggregate ATT0.04624140.007698810.0009592370.01235160.000469020.0975

The sub-aggregate ATTs, with the weight of each in the aggregate ATT:

result.sub
7×8 DataFrame
Rowtreatment_timeattsepvaljknife_sejknife_pvalri_pvalweight
DateFloat64?Float64?Float64?Float64?Float64?Float64?Float64?
11991-01-010.05533540.02220240.0342914missingmissing0.45750.201796
21993-01-010.05044890.01619050.0169391missingmissing0.51750.191535
31996-01-010.04241160.02557070.172536missingmissing0.57250.0756734
41997-01-010.06068790.02361470.0370120.03287560.07081860.280.321077
51998-01-010.03981370.04066490.3725110.08133980.6266470.58250.108593
61999-01-010.001736220.003505740.707256missingmissing0.9850.0354853
72000-01-01-0.02533170.03332030.5861790.09714450.7953460.7550.0658401

The ATT for each treated state in each period from its treatment time on, which is what every other estimate is computed from:

first(result.att_st, 5)
5×11 DataFrame
Rowstategvartr1periods_post_treatattsepvaln_tnn_controls
StringDateDateDateInt64Float64?Float64?Float64?Int64Int64Int64
1342000-01-012000-01-011999-01-010-0.04553380.01689270.010230212725741
2571998-01-011998-01-011997-01-0100.05574990.01729920.00252733377241
3571998-01-011999-01-011997-01-011-0.04536830.01702960.0110738346941
4571998-01-012000-01-011997-01-012-0.134360.01364162.98717e-12256041
5581993-01-011993-01-011992-01-0100.03111760.0156690.05392365810341

The estimates and standard errors are also available as vectors:

coef(result), stderror(result), stderror(result; type = :jackknife)
(Union{Missing, Float64}[0.0462413785365134], Union{Missing, Float64}[0.007698811001621377], Union{Missing, Float64}[0.012351552372901755])
coefnames(result; level = :sub), coef(result; level = :sub)
(["1991-01-01", "1993-01-01", "1996-01-01", "1997-01-01", "1998-01-01", "1999-01-01", "2000-01-01"], Union{Missing, Float64}[0.05533536915424712, 0.0504489015222826, 0.04241155528374173, 0.06068792505784653, 0.03981372957089521, 0.001736222501711654, -0.025331743559719733])

Finally, every result can be collected in a single wide table with DataFrame(result) (the same table is passed to the Stata and R wrappers), and a result can be written straight to a file, for example with CSV.write("results.csv", result):

names(DataFrame(result))
18-element Vector{String}:
 "treatment_time"
 "att_cohort"
 "agg_att"
 "se_agg_att"
 "pval_agg_att"
 "jknifese_agg_att"
 "jknifepval_agg_att"
 "ri_pval_agg_att"
 "nperm"
 "se_att_cohort"
 "pval_att_cohort"
 "jknifese_att_cohort"
 "jknifepval_att_cohort"
 "ri_pval_att_cohort"
 "weights"
 "period"
 "start_date"
 "end_date"

Other aggregations

The agg argument controls how the ATTs for each treated state and period are grouped into sub-aggregate ATTs (see the Aggregation section). For example, agg = "time" groups them by the number of periods since treatment:

result_time = didint(
    "coll", "state", "year", merit;
    treatment_times = treated_times,
    treated_states  = treated_states,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = "time",
    nperm      = 399
);

result_time.sub
10×8 DataFrame
Rowperiods_post_treatattsepvaljknife_sejknife_pvalri_pvalweight
Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
10.00.03705080.02762280.2126820.03271850.2628630.280.259513
21.00.02158690.01907310.2949960.02316040.3557840.56750.200513
32.00.0473840.02373360.09287670.02666130.08160870.18750.178281
43.00.07080910.02903420.0712990.04186090.09695940.130.138948
54.00.1029010.03637870.1055610.04823970.03784610.11750.0589996
65.00.1108730.004480610.0257130.01609368.94285e-90.1950.0474562
76.00.06165310.02136780.2123930.03454810.0804010.4250.0418982
87.00.01441390.0758290.8804160.1140650.899950.860.0376229
98.0-0.07335380.0154862.72849e-5missingmissing0.45750.0175289
109.00.04360310.0169520.0139265missingmissing0.64750.019239

Running didint_plot()

didint_plot() prepares the data for parallel trends plots and event study plots, and returns them as a DiDIntPlot. One call prepares the data for every kind of plot:

plot_data = didint_plot(
    "coll", "state", "year", merit;
    treatment_times = treated_times,
    treated_states  = treated_states,
    covariates = ["asian", "black", "male"]
)
DID-INT plot data
  Outcome:          coll
  Covariates:       asian, black, male
  ccc options:      none, hom, time, state, add, int
  Treated states:   34 (2000), 57 (1998), 58 (1993), 59 (1997), 61 (1999), 64 (1996),
                    71 (1991), 72 (1998), 85 (1997), 88 (2000)
  Controls:         never-treated states
  Periods:          1 year, from 1989 to 2000

Tables of plot data, each drawn with plot(x; plot_type = ...) (see ?DiDIntPlot)
  event          126 rows: ccc, time_since_treatment, y, se, ci_lower, ci_upper, ngroup
  conditional    3060 rows: state, time, period, ccc, lambda, n
  conditional2   23100 rows: state, time, period, ccc, delta, n, treated_state, base_period, treat_period
  integrated     4620 rows: state, time, period, delta, n, treated_state_covars, treat_period
  integrated2    4620 rows: state, time, period, delta, n, treated_state_covars, base_period, treat_period

With a Makie backend loaded, plot(plot_data; plot_type = ...) draws each of these: the Plotting Examples page shows every plot, and the Plotting with didint_plot() section gives the formulas behind them. The data of each kind of plot are in the table of the same name. The plot_type argument of didint_plot() selects the kinds to prepare, and ccc the options.

The conditional table has the mean outcome of each state and period, residualised by the covariates as each ccc option other than "int" specifies (lambda), and the number of observations behind it (n). "none" is the option without covariates.

plot_data.conditional[1:4, :]
4×6 DataFrame
Rowstatetimeperiodccclambdan
StringStringInt64StringFloat64Int64
11119890hom0.46789539
21119901hom0.31691235
31119912hom0.44593633
41119923hom0.57999732

How the series of a treated state changes over time relative to the series of its controls is exactly the comparison that didint() bases its estimates on under these options. The level of a series rests on a convention (the adjusted means are evaluated at covariates equal to zero), but another choice of covariate values would shift the series together and leave their parallelism unaffected.

The conditional2 table has those changes themselves: for each treated state (treated_state), the change in lambda of that state and of each of its control states (state) since the period before its treatment (base_period).

plot_data.conditional2[1:4, :]
4×9 DataFrame
Rowstatetimeperiodcccdeltantreated_statebase_periodtreat_period
StringStringInt64StringFloat64Int64StringInt64Int64
13419890hom0.0209245324341011
21119890hom0.23695784341011
31219890hom0.092423965341011
41319890hom0.040389860341011

Under ccc = "int" another choice of covariate values would change each point of a series by its own amount, so the levels cannot be compared. The integrated table therefore has, for each treated state (treated_state_covars), the change in the predicted outcome since the previous period (delta) of that state and of each of its control states (state), with every state evaluated at the covariate means of treated_state_covars. treat_period is the period in which that treated state is first treated, and n the number of observations of state in the two periods.

plot_data.integrated[1:4, :]
4×7 DataFrame
Rowstatetimeperioddeltantreated_state_covarstreat_period
StringStringInt64Float64Int64StringInt64
13419901-0.07915233753411
21119901-0.125941743411
312199010.0223095723411
41319901-0.160495643411

The integrated2 table has the same changes measured from the period before the treated state's treatment (base_period). In both tables the control states are the never-treated states; notyet = true adds the states of later cohorts while they are not yet treated.

Event study data

The event table has the treated-state means by period relative to treatment, with standard errors and confidence interval bounds.

plot_data.event[1:4, :]
4×7 DataFrame
Rowccctime_since_treatmentyseci_lowerci_upperngroup
StringInt64Float64Float64?Float64?Float64?Int64
1add-110.517280.104552-0.811181.845742
2add-100.4391950.05496420.2027030.6756873
3add-90.4721260.02897630.3916750.5525775
4add-80.43830.0301280.3645790.512027

The ccc column indicates which model was used ("hom", "time", "state", "add", "int", or "none" for no covariates), and time_since_treatment = 0 marks the treatment period; negative values are pre-treatment and positive values are post-treatment.


Separate ATTs by Policy

When treated states adopt different policies, the policy aggregation options report an ATT for each policy. The merit data does not record different types of merit-aid programmes, so purely for illustration the ten treated states are split here into two made-up policy types, "A" and "B", using the treated_policies argument (the pvar argument can be used instead when the policy is stored in a column of the data).

treated_policies = ["A", "A", "B", "A", "B", "A", "B", "B", "A", "B"];

result_policy = didint(
    "coll", "state", "year", merit;
    treatment_times  = treated_times,
    treated_states   = treated_states,
    treated_policies = treated_policies,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = "policy",
    policy_aggregation = true,
    nperm      = 399
)
DID-INT results
  Outcome:          coll
  Model:            Region-Varying DID-INT (ccc = "state")
  Covariates:       male, asian, black
  Aggregation:      "policy" (by policy)
  Weighting:        "both"
  Controls:         never-treated states
  Periods:          1 year, from 1989 to 2000
  Standard errors:  HC1 (se) and jackknife (jknife_se)
  Permutations:     399 (seed 1234)

Pooled ATT and ATT by policy
 estimate    att        se          pval         jknife_se  jknife_pval  ri_pval  policy_weight 
────────────────────────────────────────────────────────────────────────────────────────────────
 Pooled ATT  0.0461228  0.00749389  0.10254      0.0178092   0.0125462    0.135       missing   
 Policy A    0.0386289  0.0198199   0.0690503    0.0337412   0.257718     0.3025            0.5
 Policy B    0.0536167  0.0124119   0.000253747  0.0102837   3.53862e-6   0.24              0.5

Setting policy_aggregation = true also reports the pooled ATT across policies, here weighting the two policies equally (the policy_weight column). See the Policies section for the other policy aggregation options and for the weighting of policies in the pooled ATT.

Cohort ATTs With and Without Policies

agg = "cohort" reports one ATT per treatment time and ignores the policies, whereas agg = "policy_cohort" reports one ATT per treatment time within each policy. With the made-up policies above, the two treated states of the 1998 cohort have different policies, as do the two treated states of the 2000 cohort; the two states of the 1997 cohort both have policy "A", and every other cohort consists of a single state.

Under agg = "cohort" there are seven cohort ATTs, whether or not policies are given:

result_cohort = didint(
    "coll", "state", "year", merit;
    treatment_times  = treated_times,
    treated_states   = treated_states,
    treated_policies = treated_policies,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = "cohort",
    nperm      = 399
);

select(result_cohort.sub, :treatment_time, :att, :se, :jknife_se, :weight)
7×5 DataFrame
Rowtreatment_timeattsejknife_seweight
DateFloat64?Float64?Float64?Float64?
11991-01-010.05533540.0222024missing0.201796
21993-01-010.05044890.0161905missing0.191535
31996-01-010.04241160.0255707missing0.0756734
41997-01-010.06068790.02361470.03287560.321077
51998-01-010.03981370.04066490.08133980.108593
61999-01-010.001736220.00350574missing0.0354853
72000-01-01-0.02533170.03332030.09714450.0658401

Under agg = "policy_cohort" the cohorts are formed within each policy:

result_policy_cohort = didint(
    "coll", "state", "year", merit;
    treatment_times  = treated_times,
    treated_states   = treated_states,
    treated_policies = treated_policies,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = "policy_cohort",
    nperm      = 399
)
DID-INT results
  Outcome:          coll
  Model:            Region-Varying DID-INT (ccc = "state")
  Covariates:       male, asian, black
  Aggregation:      "policy_cohort" (by policy and treatment time)
  Weighting:        "both"
  Controls:         never-treated states
  Periods:          1 year, from 1989 to 2000
  Standard errors:  HC1 (se) and jackknife (jknife_se)
  Permutations:     399 (seed 1234)

ATT by policy
 estimate  att        se          pval         jknife_se  jknife_pval  ri_pval 
───────────────────────────────────────────────────────────────────────────────
 Policy A  0.0386289  0.0208515   0.161013     0.0337412   0.257718     0.3025
 Policy B  0.0536167  0.00606071  0.000901416  0.0102837   3.53862e-6   0.24

Sub-aggregate ATTs by policy and treatment time (9)
 policy  treatment_time  att          se          pval         jknife_se        jknife_pval      ri_pval  weight    
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 A       1996-01-01       0.0424116   0.0255707   0.172536     missing          missing           0.6     0.153779
 A       1997-01-01       0.0606879   0.0236147   0.037012           0.0328756        0.0708186   0.2575  0.652476
 A       1998-01-01      -0.0295705   0.0527826   0.631703     missing          missing           0.8575  0.0834057
 A       2000-01-01      -0.0455338   0.0168927   0.0102302    missing          missing           0.7075  0.110339
 B       1991-01-01       0.0553354   0.0222024   0.0342914    missing          missing           0.445   0.397306
 B       1993-01-01       0.0504489   0.0161905   0.0169391    missing          missing           0.5225  0.377104
 B       1998-01-01       0.0819712   0.0533283   0.264087     missing          missing           0.3325  0.132997
 B       1999-01-01       0.00173622  0.00350574  0.707256     missing          missing           0.9775  0.0698653
 B       2000-01-01       0.0696929   0.0168927   0.000181788  missing          missing           0.55    0.0227273

Comparing the two sets of results:

  • The 1998 and 2000 cohorts, which contain both policies, are each split in two: one ATT for the state with policy "A" and one for the state with policy "B". Each of these is now based on a single treated state, so it has no jackknife standard error. The split can matter: the 2000 cohort has an ATT of about -0.025 as a whole, which is made up of about -0.046 under policy "A" and 0.070 under policy "B".
  • The cohorts that contain a single policy (1991, 1993, 1996, 1997 and 1999) appear once, under that policy, with the same ATT and standard errors as under agg = "cohort". Their randomization inference p-values differ slightly, because for the policy aggregation options a state's policy is reassigned together with its treatment time.
  • The weight column now gives the weight of each cohort ATT within its policy, and the ATT of each policy (the first table of the output) is the weighted mean of the cohort ATTs of that policy. There is no single aggregate ATT; setting policy_aggregation = true adds the pooled ATT across policies, as in the example above.

The Aggregate ATT Across Aggregation Options

With the default weighting (weighting = "both"), and also with weighting = "att", the aggregate ATT does not depend on the agg option (see the Aggregate ATT Equivalency section). Running the staggered adoption example above with every (non-policy) agg option and the default weighting:

aggs = ["cohort", "simple", "state", "sgt", "time", "calendar"]

results = [didint(
    "coll", "state", "year", merit;
    treatment_times = treated_times,
    treated_states  = treated_states,
    seed       = 1234,
    ccc        = "state",
    covariates = [:male, :asian, :black],
    agg        = agg,
    nperm      = 399
) for agg in aggs]

# The aggregate ATT and its inference, one row per agg option
aggregate(result) = result.agg[1, :]
DataFrame(
    agg         = aggs,
    agg_att     = [aggregate(result).att for result in results],
    se          = [aggregate(result).se for result in results],
    pval        = [aggregate(result).pval for result in results],
    jknife_se   = [aggregate(result).jknife_se for result in results],
    jknife_pval = [aggregate(result).jknife_pval for result in results],
    ri_pval     = [aggregate(result).ri_pval for result in results]
)
6×7 DataFrame
Rowaggagg_attsepvaljknife_sejknife_pvalri_pval
StringFloat64Float64Float64Float64Float64Float64
1cohort0.04624140.007698810.0009592370.01235160.000469020.0975
2simple0.04624140.0100716.48658e-50.01235160.000469020.0975
3state0.04624140.009552150.0009198240.01235160.000469020.14
4sgt0.04624140.01143070.000231880.01235160.000469020.14
5time0.04624140.008733870.0004974710.01235160.000469020.0975
6calendar0.04624140.007184110.0001200060.01235160.000469020.0975

The aggregate ATT (agg_att) is identical in every row. Its HC standard error and p-value (se, pval) differ, as they are computed from the spread of the sub-aggregate ATTs of each option. The jackknife standard error and p-value do not differ: each removal of a state recomputes the same aggregate ATT, whatever the grouping. Neither does the randomization inference p-value, except under "state" and "sgt", whose randomization inference draws an additional stand-in state for each treated state (see the Randomization Inference section).


Common Adoption

When every treated state is treated at the same time, didint() is used in exactly the same way, and every aggregation option is available. This example keeps the two states that adopted merit-aid programmes in 1998 along with the never-treated states. A single treatment time applies to every treated state.

merit_common = filter(
    row -> row.state ∈ [57, 72] || !(row.state ∈ treated_states),
    merit
);

result_common = didint(
    "coll", "state", "year", merit_common;
    treated_states  = [57, 72],
    treatment_times = 1998,
    seed       = 1234,
    ccc        = "hom",
    covariates = [:male, :asian, :black],
    agg        = "time",
    nperm      = 399
)
DID-INT results
  Outcome:          coll
  Model:            Homogeneous DID-INT (ccc = "hom")
  Covariates:       male, asian, black
  Aggregation:      "time" (by periods since treatment)
  Weighting:        "both"
  Controls:         never-treated states
  Periods:          1 year, from 1989 to 2000
  Standard errors:  HC1 (se) and jackknife (jknife_se)
  Permutations:     399 (seed 1234)

Aggregate ATT
 estimate       att        se         pval      jknife_se  jknife_pval  ri_pval 
────────────────────────────────────────────────────────────────────────────────
 Aggregate ATT  0.0362295  0.0134074  0.114003  0.0728969     0.621784   0.5775

Sub-aggregate ATTs by periods since treatment (3)
 periods_post_treat  att        se         pval      jknife_se  jknife_pval  ri_pval  weight   
───────────────────────────────────────────────────────────────────────────────────────────────
                0.0  0.0114218  0.035171   0.800098  0.0548238     0.835973   0.9025  0.358268
                1.0  0.0517801  0.0677093  0.584371  0.102537      0.616206   0.5375  0.338583
                2.0  0.0481794  0.118292   0.75377   0.19972       0.810547   0.5     0.30315

Trying a different CCC assumption

The ccc argument controls the assumption made about how covariate effects vary across states and time. Swapping ccc = "hom" for any of "time", "state", "add", or "int" changes whether covariate effects are allowed to vary by time, by state, additively by both, or interactively by both, respectively. For example:

result_common_int = didint(
    "coll", "state", "year", merit_common;
    treated_states  = [57, 72],
    treatment_times = 1998,
    seed       = 1234,
    ccc        = "int",
    covariates = [:male, :asian, :black],
    agg        = "time",
    nperm      = 399
);

result_common_int.sub
3×8 DataFrame
Rowperiods_post_treatattsepvaljknife_sejknife_pvalri_pvalweight
Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
10.00.04159820.05037240.5605520.0771530.592620.630.358268
21.00.03708770.1018720.7777270.1537670.8105780.66750.338583
32.00.04819680.132020.7771590.2235350.8303340.49750.30315

A Single Control State

This example compares a single treated state (state 71, treated in 1991) against a single untreated control state (state 73). With agg = "sgt", an ATT is reported for state 71 in each period from 1991 onwards. With only one control state, the usual standard error of each of these ATTs cannot be computed; setting edgecase = true recovers it from the first-stage estimates instead.

merit_pair = filter(row -> row.state ∈ [71, 73], merit);

result_pair = didint(
    "coll", "state", "year", merit_pair;
    treated_states  = [71],
    treatment_times = [1991],
    seed       = 1234,
    ccc        = "hom",
    covariates = [:male, :asian, :black],
    agg        = "sgt",
    edgecase   = true
);

select(result_pair.sub, :state, :t, :att, :se)
10×4 DataFrame
Rowstatetattse
StringDateFloat64?Float64?
1711991-01-01-0.04493820.136587
2711992-01-01-0.1737570.133532
3711993-01-01-0.09087040.130533
4711994-01-01-0.1330350.134481
5711995-01-010.05218760.133253
6711996-01-01-0.02687920.12889
7711997-01-010.08768220.133043
8711998-01-010.1079330.14195
9711999-01-01-0.1156580.127827
10712000-01-01-0.1474190.137571

No p-value accompanies these standard errors, as the regression behind each ATT has no residual degrees of freedom. With one treated state and one control state there is also nothing for the jackknife to compute and only one alternative treatment assignment for the randomization inference, so didint() issues warnings to that effect. For more information on these standard errors, including a caveat for panel data, see the section Computation of Edge Case Standard Errors on the "Details" page of the documentation site.

See the Functions for function syntax and the Under the Hood page for more details.