formative-ds 2.2.3__tar.gz → 2.2.5__tar.gz

{formative_ds-2.2.3 → formative_ds-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: formative-ds
-Version: 2.2.3
+Version: 2.2.5
 Summary: A Python library for quantitative reasoning.
 Project-URL: Homepage, https://getformative.dev
 Project-URL: Documentation, https://docs.getformative.dev
@@ -9,7 +9,7 @@ Author: Max Pagels
 License: MIT
 License-File: LICENSE
 Keywords: DAG,causal estimation,causal inference,econometrics,statistics
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3

{formative_ds-2.2.3 → formative_ds-2.2.5}/formative/causal/estimators/_base.py

@@ -1,6 +1,31 @@
 from __future__ import annotations
 
 from .._assumptions import Assumption
+from .._exceptions import IdentificationError
+
+
+def _backdoor_confounders(dag, treatment: str, outcome: str) -> set[str]:
+    """
+    Confounders under the backdoor criterion: common ancestors of treatment and
+    outcome that are not descendants of treatment (mediators or post-treatment
+    variables).
+    """
+    return (dag.ancestors(treatment) & dag.ancestors(outcome)) - dag.descendants(treatment)
+
+
+def _missing_confounders_error(missing: set[str], treatment: str, outcome: str) -> IdentificationError:
+    """``IdentificationError`` for DAG-declared confounders absent from the dataframe."""
+    return IdentificationError(
+        f"\nDAG confounders not found in dataframe: {sorted(missing)}\n\n"
+        f"Your DAG declares these variables as confounders of '{treatment}' and\n"
+        f"'{outcome}', but they are absent from the dataframe and cannot be\n"
+        f"controlled for. Note: there may also be confounders not modelled in your\n"
+        f"DAG at all — formative cannot detect those.\n\n"
+        f"Consider:\n"
+        f"  - Collecting data on {sorted(missing)} and adding it to the dataframe\n"
+        f"  - IV estimation if you have a valid instrument for '{treatment}'\n"
+        f"  - DiD or RD if a natural experiment is available"
+    )
 
 
 class _BaseResult:

{formative_ds-2.2.3 → formative_ds-2.2.5}/formative/causal/estimators/iv.py

@@ -7,7 +7,7 @@ from statsmodels.sandbox.regression.gmm import IV2SLS as _IV2SLS
 
 from .._assumptions import Assumption
 from ..dag import DAG
-from ._base import _StatsmodelsResult
+from ._base import _backdoor_confounders, _StatsmodelsResult
 
 IV_ASSUMPTIONS: list[Assumption] = [
     Assumption("Relevance: the instrument strongly affects treatment", testable=True),
@@ -228,14 +228,7 @@ class IV2SLS:
         Unobserved confounders are handled by the instrument and are not flagged
         as errors — this is the primary use case for IV estimation.
         """
-        dag = self._dag
-        T, Y = self._treatment, self._outcome
-
-        treatment_ancestors = dag.ancestors(T)
-        outcome_ancestors = dag.ancestors(Y)
-        treatment_descendants = dag.descendants(T)
-
-        confounders = (treatment_ancestors & outcome_ancestors) - treatment_descendants
+        confounders = _backdoor_confounders(self._dag, self._treatment, self._outcome)
         confounders.discard(self._instrument)
 
         return {c for c in confounders if c in data_columns}

{formative_ds-2.2.3 → formative_ds-2.2.5}/formative/causal/estimators/matching.py

@@ -6,9 +6,8 @@ import statsmodels.api as sm
 import statsmodels.formula.api as smf
 
 from .._assumptions import Assumption
-from .._exceptions import IdentificationError
 from ..dag import DAG
-from ._base import _BaseResult
+from ._base import _backdoor_confounders, _BaseResult, _missing_confounders_error
 
 MATCHING_ASSUMPTIONS: list[Assumption] = [
     Assumption("Conditional independence: no unobserved confounders given matched variables", testable=False),
@@ -283,14 +282,7 @@ class PropensityScoreMatching:
             raise ValueError("Treatment and outcome must be different variables.")
 
     def _identify(self, data_columns: set[str]) -> tuple[set[str], set[str]]:
-        dag = self._dag
-        T, Y = self._treatment, self._outcome
-
-        treatment_ancestors = dag.ancestors(T)
-        outcome_ancestors = dag.ancestors(Y)
-        treatment_descendants = dag.descendants(T)
-
-        confounders = (treatment_ancestors & outcome_ancestors) - treatment_descendants
+        confounders = _backdoor_confounders(self._dag, self._treatment, self._outcome)
         observed = {c for c in confounders if c in data_columns}
         missing = {c for c in confounders if c not in data_columns}
         return observed, missing
@@ -328,16 +320,7 @@ class PropensityScoreMatching:
         adjustment_set, missing = self._identify(data_columns)
 
         if missing:
-            raise IdentificationError(
-                f"\nDAG confounders not found in dataframe: {sorted(missing)}\n\n"
-                f"Your DAG declares these variables as confounders of "
-                f"'{self._treatment}' and '{self._outcome}', but they are "
-                f"absent from the dataframe and cannot be controlled for.\n\n"
-                f"Consider:\n"
-                f"  - Collecting data on {sorted(missing)} and adding it to the dataframe\n"
-                f"  - IV estimation if you have a valid instrument for '{self._treatment}'\n"
-                f"  - DiD or RD if a natural experiment is available"
-            )
+            raise _missing_confounders_error(missing, self._treatment, self._outcome)
 
         T, Y = self._treatment, self._outcome
 

{formative_ds-2.2.3 → formative_ds-2.2.5}/formative/causal/estimators/ols.py

@@ -4,9 +4,8 @@ import pandas as pd
 import statsmodels.formula.api as smf
 
 from .._assumptions import Assumption
-from .._exceptions import IdentificationError
 from ..dag import DAG
-from ._base import _StatsmodelsResult
+from ._base import _backdoor_confounders, _missing_confounders_error, _StatsmodelsResult
 from ._cate import (
     CATE_ASSUMPTIONS,
     _CATEResultMixin,
@@ -282,14 +281,7 @@ class OLSObservational:
         absent from the data. There may be additional unobserved confounders
         not represented in the DAG at all.
         """
-        dag = self._dag
-        T, Y = self._treatment, self._outcome
-
-        treatment_ancestors = dag.ancestors(T)
-        outcome_ancestors = dag.ancestors(Y)
-        treatment_descendants = dag.descendants(T)
-
-        confounders = (treatment_ancestors & outcome_ancestors) - treatment_descendants
+        confounders = _backdoor_confounders(self._dag, self._treatment, self._outcome)
 
         observed_confounders = {c for c in confounders if c in data_columns}
         dag_confounders_not_in_data = {c for c in confounders if c not in data_columns}
@@ -335,17 +327,7 @@ class OLSObservational:
         adjustment_set, dag_confounders_not_in_data = self._identify(data_columns)
 
         if dag_confounders_not_in_data:
-            raise IdentificationError(
-                f"\nDAG confounders not found in dataframe: {sorted(dag_confounders_not_in_data)}\n\n"
-                f"Your DAG declares these variables as confounders of '{self._treatment}' and\n"
-                f"'{self._outcome}', but they are absent from the dataframe and cannot be\n"
-                f"controlled for. Note: there may also be confounders not modelled in your\n"
-                f"DAG at all — formative cannot detect those.\n\n"
-                f"Consider:\n"
-                f"  - Collecting data on {sorted(dag_confounders_not_in_data)} and adding it to the dataframe\n"
-                f"  - IV estimation if you have a valid instrument for '{self._treatment}'\n"
-                f"  - DiD or RD if a natural experiment is available"
-            )
+            raise _missing_confounders_error(dag_confounders_not_in_data, self._treatment, self._outcome)
 
         unadjusted_result = smf.ols(f"{self._outcome} ~ {self._treatment}", data=data).fit()
 

{formative_ds-2.2.3 → formative_ds-2.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "formative-ds"
-version = "2.2.3"
+version = "2.2.5"
 description = "A Python library for quantitative reasoning."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -12,7 +12,7 @@ license = {text = "MIT"}
 authors = [{name = "Max Pagels"}]
 keywords = ["causal inference", "causal estimation", "econometrics", "statistics", "DAG"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Mathematics",
     "License :: OSI Approved :: MIT License",
@@ -48,7 +48,7 @@ docs = ["sphinx>=7,<10", "sphinx-rtd-theme>=2,<4", "sphinx-copybutton>=0.5,<0.6"
 packages = ["formative"]
 
 [tool.bumpversion]
-current_version = "2.2.3"
+current_version = "2.2.5"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{formative_ds-2.2.3 → formative_ds-2.2.5}/site/2.2/_sources/causal/benchmarks.rst.txt

@@ -118,7 +118,9 @@ treatment/outcome relationship. The observational DAG declares this:
         obs_dag.assume(c).causes("treat", "re78")
     obs_dag.assume("treat").causes("re78")
 
-    result = OLSObservational(obs_dag, treatment="treat", outcome="re78").fit(observational)
+    result = OLSObservational(
+        obs_dag, treatment="treat", outcome="re78"
+    ).fit(observational)
     print(result.summary())
 
 .. code-block:: text
@@ -156,7 +158,9 @@ each treated person only with the most similar controls:
 
     from formative.causal import PropensityScoreMatching
 
-    result = PropensityScoreMatching(obs_dag, treatment="treat", outcome="re78").fit(observational)
+    result = PropensityScoreMatching(
+        obs_dag, treatment="treat", outcome="re78"
+    ).fit(observational)
     print(result.summary())
 
 .. code-block:: text
@@ -293,7 +297,10 @@ Table 3 reports four cell means; formative's DiD will be built from exactly thes
 
     for state, name in [(1, "NJ"), (0, "PA")]:
         sub = raw[raw.STATE == state]
-        print(f"{name}: before {sub.fte_before.mean():.2f}, after {sub.fte_after.mean():.2f}")
+        print(
+            f"{name}: before {sub.fte_before.mean():.2f}, "
+            f"after {sub.fte_after.mean():.2f}"
+        )
 
 .. code-block:: text
 
@@ -317,8 +324,18 @@ binary group and time indicators:
 
     long = pd.concat(
         [
-            pd.DataFrame({"store": raw.SHEET, "nj": raw.STATE, "after": 0, "fte": raw.fte_before}),
-            pd.DataFrame({"store": raw.SHEET, "nj": raw.STATE, "after": 1, "fte": raw.fte_after}),
+            pd.DataFrame({
+                "store": raw.SHEET,
+                "nj": raw.STATE,
+                "after": 0,
+                "fte": raw.fte_before,
+            }),
+            pd.DataFrame({
+                "store": raw.SHEET,
+                "nj": raw.STATE,
+                "after": 1,
+                "fte": raw.fte_after,
+            }),
         ],
         ignore_index=True,
     ).dropna(subset=["fte"])

{formative_ds-2.2.3 → formative_ds-2.2.5}/site/2.2/_sources/causal/decisions.rst.txt

@@ -52,7 +52,11 @@ earnings using OLS with a DAG that encodes family background as a confounder:
    training   = 0.6 * background + rng.normal(size=N)
    earnings   = 3.0 * training + 1.2 * background + rng.normal(size=N)
 
-   df  = pd.DataFrame({"background": background, "training": training, "earnings": earnings})
+   df = pd.DataFrame({
+       "background": background,
+       "training": training,
+       "earnings": earnings,
+   })
    dag = DAG()
    dag.assume("background").causes("training", "earnings")
    dag.assume("training").causes("earnings")
@@ -85,7 +89,7 @@ But how confident are we in that estimate? And is it robust to estimation error?
      Decision confidence          :    100.0%
      Robust to estimation error   : Yes — decision is stable across 95% CI
 
-Game-theoretic robustness
+Robustness
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ``decide()`` uses expected value maximisation: it picks "treat" when
@@ -96,7 +100,7 @@ treats a certain $37 gain and a 50/50 gamble between $0 and $74 identically.
 The ``robust`` flag is a first step toward robustness: it checks whether
 the decision flips anywhere inside the 95% confidence interval. But it
 only returns ``True`` or ``False``, and it is implicitly using the most
-conservative possible standard (the CI bounds).
+conservative possible standard (the confidence interval bounds).
 
 For finer control, call ``to_outcomes()`` on the report and pass the result
 to any rule in ``formative.game``:
@@ -118,8 +122,8 @@ to any rule in ``formative.game``:
 
 By default, the three scenarios correspond to the 10th, 50th, and 90th
 percentiles of the net-benefit sampling distribution (assumed normal with
-the se derived from the 95% CI). The ``"don't treat"`` payoff is 0 in
-every scenario — the status quo baseline.
+the standard error derived from the 95% confidence interval). The ``"don't treat"`` payoff is 0 in
+every scenario.
 
 You can supply your own scenario names and quantiles:
 
@@ -129,17 +133,19 @@ You can supply your own scenario names and quantiles:
        scenarios={"bear": 0.05, "base": 0.50, "bull": 0.95}
    )
 
-**Relationship to** ``robust``. ``robust=True`` is equivalent to
-``maximin`` returning the same choice as ``optimal`` when the scenarios are
-set to the CI bounds (quantiles 0.025 and 0.975). ``to_outcomes()``
+How does this differ from using ``robust``? ``robust=True`` is equivalent to
+``maximin``, returning the same choice when the scenarios are
+set to the confidence interval bounds (quantiles 0.025 and 0.975). ``to_outcomes()``
 generalises that check: different rules express different risk attitudes, and
 you can dial in your own pessimism level via ``hurwicz(alpha=...)``.
 
 Should we treat each segment?
 -----------------------------
 
-An average effect can hide groups where the treatment is worthless — or where
-it pays for itself several times over. When an estimator was fitted with an
+An average effect can hide groups where the treatment is worthless, or where
+it pays for itself several times over. It will also cause you to scale up a treatment
+that is not worth it for everyone.
+When an estimator is fitted with an
 ``effect_modifier`` (see :doc:`estimands`), ``decide_by_group(cost, benefit)``
 runs the same cost-benefit analysis within each level of the modifier and
 returns a mapping of level → :class:`~formative.DecisionReport`, so different
@@ -161,19 +167,33 @@ and everyone else not at all:
    tenure    = rng.choice(["<2y", "2-5y", ">5y"], size=N)
    region    = rng.choice(["north", "south"], size=N)
    coaching  = rng.integers(0, 2, size=N)
-   retention = 6.0 * coaching * (tenure == "<2y") + 2.0 * (tenure == ">5y") + rng.normal(size=N)
+   retention = (
+       6.0 * coaching * (tenure == "<2y")
+       + 2.0 * (tenure == ">5y")
+       + rng.normal(size=N)
+   )
 
-   df = pd.DataFrame({"tenure": tenure, "region": region, "coaching": coaching, "retention": retention})
+   df = pd.DataFrame({
+       "tenure": tenure,
+       "region": region,
+       "coaching": coaching,
+       "retention": retention,
+   })
 
    dag = DAG()
    dag.assume("coaching").causes("retention")
    dag.assume("tenure").causes("retention")
    dag.assume("region").causes("retention")
 
-   result = RCT(dag, treatment="coaching", outcome="retention", effect_modifier="tenure").fit(df)
+   result = RCT(
+       dag, treatment="coaching", outcome="retention", effect_modifier="tenure"
+   ).fit(df)
    for level, decision in result.decide_by_group(cost=2.5, benefit=1.0).items():
        lo, hi = decision.net_benefit_ci
-       print(f"{level:>5}: {decision.optimal:<12} net benefit {decision.net_benefit:+.2f}  [{lo:+.2f}, {hi:+.2f}]")
+       print(
+           f"{level:>5}: {decision.optimal:<12} "
+           f"net benefit {decision.net_benefit:+.2f}  [{lo:+.2f}, {hi:+.2f}]"
+       )
 
 .. code-block:: text
 
@@ -203,10 +223,9 @@ one less thing to get wrong.
 How it works
 ~~~~~~~~~~~~
 
-``learn_policy()`` implements doubly robust policy learning in the style of
-Athey & Wager (2021):
+``learn_policy()`` implements doubly robust policy learning:
 
-1. **Score every unit.** Each unit gets a cross-fitted AIPW score — an
+1. **Score every unit.** Each unit gets a cross-fitted score — an
    unbiased estimate of its individual treatment effect. Outcome models are
    fit by OLS on the candidate features over four folds and evaluated on the
    fifth, so no unit is scored by a model that saw it.
@@ -225,7 +244,7 @@ Athey & Wager (2021):
 
 Because the tree may split on any level of any candidate feature, features
 must be discrete: bin continuous columns before passing them in. Candidate
-features face the same DAG validation as effect modifiers — each must cause
+features face the same DAG validation as effect modifiers; each must cause
 the outcome and must not be a descendant of the treatment (targeting on a
 mediator is not actionable at assignment time).
 
@@ -238,7 +257,13 @@ features instead of choosing a segmentation ourselves:
 .. code-block:: python
 
    result = RCT(dag, treatment="coaching", outcome="retention").fit(df)
-   policy = result.learn_policy(df, modifiers=["tenure", "region"], cost=2.5, benefit=1.0, max_depth=2)
+   policy = result.learn_policy(
+      df,
+      modifiers=["tenure", "region"],
+      cost=2.5,
+      benefit=1.0,
+      max_depth=2
+   )
    print(policy.summary())
 
 .. code-block:: text
@@ -286,10 +311,17 @@ it only helps recent hires in the north:
    coaching  = rng.integers(0, 2, size=N)
    helped    = (tenure == "<2y") & (region == "north")
    retention = 7.0 * coaching * helped + 2.0 * (tenure == ">5y") + rng.normal(size=N)
-   df = pd.DataFrame({"tenure": tenure, "region": region, "coaching": coaching, "retention": retention})
+   df = pd.DataFrame({
+       "tenure": tenure,
+       "region": region,
+       "coaching": coaching,
+       "retention": retention,
+   })
 
    result = RCT(dag, treatment="coaching", outcome="retention").fit(df)
-   policy = result.learn_policy(df, modifiers=["tenure", "region"], cost=2.5, benefit=1.0, max_depth=2)
+   policy = result.learn_policy(
+       df, modifiers=["tenure", "region"], cost=2.5, benefit=1.0, max_depth=2
+   )
    print(policy.summary())
 
 .. code-block:: text
@@ -316,7 +348,9 @@ back to treating all recent hires and burns money on the southern half:
 
 .. code-block:: python
 
-   result.learn_policy(df, modifiers=["tenure", "region"], cost=2.5, benefit=1.0, max_depth=1).value
+   result.learn_policy(
+       df, modifiers=["tenure", "region"], cost=2.5, benefit=1.0, max_depth=1
+   ).value
    # +0.34 per unit — versus +0.75 at depth 2
 
 When the deeper policy's value is clearly higher (as here), ship it; when the
@@ -339,7 +373,12 @@ segment-2 employees in the north:
    training = rng.integers(0, 2, size=N)
    effect   = 4.0 * (segment == 0) + 5.0 * ((segment == 2) & (region == "north"))
    earnings = effect * training + 0.5 * segment + rng.normal(size=N)
-   df = pd.DataFrame({"segment": segment, "region": region, "training": training, "earnings": earnings})
+   df = pd.DataFrame({
+       "segment": segment,
+       "region": region,
+       "training": training,
+       "earnings": earnings,
+   })
 
    dag = DAG()
    dag.assume("training").causes("earnings")
@@ -347,7 +386,13 @@ segment-2 employees in the north:
    dag.assume("region").causes("earnings")
 
    result = RCT(dag, treatment="training", outcome="earnings").fit(df)
-   policy = result.learn_policy(df, modifiers=["segment", "region"], cost=1.0, benefit=1.0, max_depth=2)
+   policy = result.learn_policy(
+      df, 
+      modifiers=["segment", "region"],
+      cost=1.0,
+      benefit=1.0,
+      max_depth=2
+   )
    print(policy.summary())
 
 .. code-block:: text

{formative_ds-2.2.3 → formative_ds-2.2.5}/site/2.2/_sources/causal/introduction.rst.txt

@@ -49,7 +49,7 @@ you choose.
 
 After you have obtained the result object, you can print a summary of the estimate and
 its assumptions. The assumptions are marked as testable or untestable depending on whether
-formative can check them. Most assumptions in causal inference are untestable by nature —
+formative can check them. Most assumptions in causal inference are untestable by nature, i.e.
 things you must argue for based on domain knowledge and theory.
 
 .. code-block:: python
@@ -83,7 +83,7 @@ communicating with non-technical audiences.
 **3. Refute**
 
 Once you have a result, run statistical checks that probe whether its assumptions hold
-in the data. Each check returns a clear pass or fail — but no set of tests can guarantee
+in the data. Each check returns a clear pass or fail, but no set of tests can guarantee
 validity. Use them as diagnostics, not proof. Causal inference is a judgment call, not a
 mathematical certainty.
 
@@ -104,10 +104,10 @@ mathematical certainty.
 
 **4. Decide**
 
-An estimate is rarely the end goal — the question is whether to act on it. Pass the
+An estimate is rarely the end goal; the question is whether to act on it. Pass the
 cost per unit of treatment applied and the value of one unit of improvement in the
 outcome, and formative turns the estimate and its uncertainty into a treat/don't-treat
-call. Suppose a unit of education costs $8 and a unit of income is worth $15:
+decision. Suppose a unit of education costs $8 and a unit of income is worth $15:
 
 .. code-block:: python
 
@@ -128,7 +128,12 @@ call. Suppose a unit of education costs $8 and a unit of income is worth $15:
      Decision confidence          :     100.0%
      Robust to estimation error   : Yes — decision is stable across 95% CI
 
-Depending on the estimator, decisions can go beyond a single call for everyone:
+You may ask why a cost must be passed; is it not enough if the estimate is positive?
+The answer is that a positive estimate does not guarantee that the treatment is worth it.
+If the estimate gives an effect of +1.0, but the treatment costs $10 and the outcome is worth $1,
+then the treatment is not worth it. The decision layer makes this explicit.
+
+Depending on the estimator you choose, decisions can go beyond a single call for everyone:
 per-group decisions via an effect modifier, or a learned treatment rule that
 decides *whom* to treat. See :doc:`decisions` for the full decision layer.
 

{formative_ds-2.2.3 → formative_ds-2.2.5}/site/2.2/_static/documentation_options.js

@@ -1,5 +1,5 @@
 const DOCUMENTATION_OPTIONS = {
-    VERSION: '2.2.2',
+    VERSION: '2.2.4',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',

{formative_ds-2.2.3 → formative_ds-2.2.5}/site/2.2/causal/benchmarks.html

@@ -6,7 +6,7 @@
   <meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Benchmarks &mdash; formative 2.2.2 documentation</title>
+  <title>Benchmarks &mdash; formative 2.2.4 documentation</title>
       <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" />
       <link rel="stylesheet" type="text/css" href="../_static/css/theme.css?v=9edc463e" />
       <link rel="stylesheet" type="text/css" href="../_static/copybutton.css?v=76b2166b" />
@@ -16,7 +16,7 @@
     <link rel="canonical" href="https://docs.getformative.dev/causal/benchmarks.html" />
       <script src="../_static/jquery.js?v=5d32c60e"></script>
       <script src="../_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
-      <script src="../_static/documentation_options.js?v=219dea72"></script>
+      <script src="../_static/documentation_options.js?v=4e6cfea6"></script>
       <script src="../_static/doctools.js?v=fd6eb6e6"></script>
       <script src="../_static/sphinx_highlight.js?v=6ffebe34"></script>
       <script src="../_static/clipboard.min.js?v=a7894cd8"></script>
@@ -50,8 +50,8 @@
         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Causal Estimation</span></p>
 <ul class="current">
-<li class="toctree-l1"><a class="reference internal" href="introduction.html">Introduction</a></li>
 <li class="toctree-l1"><a class="reference internal" href="motivation.html">Motivation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="introduction.html">Introduction</a></li>
 <li class="toctree-l1"><a class="reference internal" href="dag.html">DAG</a></li>
 <li class="toctree-l1"><a class="reference internal" href="estimands.html">Estimands</a></li>
 <li class="toctree-l1"><a class="reference internal" href="wizard.html">Choosing an estimator</a></li>
@@ -210,7 +210,9 @@ treatment/outcome relationship. The observational DAG declares this:</p>
     <span class="n">obs_dag</span><span class="o">.</span><span class="n">assume</span><span class="p">(</span><span class="n">c</span><span class="p">)</span><span class="o">.</span><span class="n">causes</span><span class="p">(</span><span class="s2">&quot;treat&quot;</span><span class="p">,</span> <span class="s2">&quot;re78&quot;</span><span class="p">)</span>
 <span class="n">obs_dag</span><span class="o">.</span><span class="n">assume</span><span class="p">(</span><span class="s2">&quot;treat&quot;</span><span class="p">)</span><span class="o">.</span><span class="n">causes</span><span class="p">(</span><span class="s2">&quot;re78&quot;</span><span class="p">)</span>
 
-<span class="n">result</span> <span class="o">=</span> <span class="n">OLSObservational</span><span class="p">(</span><span class="n">obs_dag</span><span class="p">,</span> <span class="n">treatment</span><span class="o">=</span><span class="s2">&quot;treat&quot;</span><span class="p">,</span> <span class="n">outcome</span><span class="o">=</span><span class="s2">&quot;re78&quot;</span><span class="p">)</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">observational</span><span class="p">)</span>
+<span class="n">result</span> <span class="o">=</span> <span class="n">OLSObservational</span><span class="p">(</span>
+    <span class="n">obs_dag</span><span class="p">,</span> <span class="n">treatment</span><span class="o">=</span><span class="s2">&quot;treat&quot;</span><span class="p">,</span> <span class="n">outcome</span><span class="o">=</span><span class="s2">&quot;re78&quot;</span>
+<span class="p">)</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">observational</span><span class="p">)</span>
 <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">summary</span><span class="p">())</span>
 </pre></div>
 </div>
@@ -244,7 +246,9 @@ linear model extrapolates across incomparable people. Propensity score matching
 each treated person only with the most similar controls:</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span><span class="w"> </span><span class="nn">formative.causal</span><span class="w"> </span><span class="kn">import</span> <span class="n">PropensityScoreMatching</span>
 
-<span class="n">result</span> <span class="o">=</span> <span class="n">PropensityScoreMatching</span><span class="p">(</span><span class="n">obs_dag</span><span class="p">,</span> <span class="n">treatment</span><span class="o">=</span><span class="s2">&quot;treat&quot;</span><span class="p">,</span> <span class="n">outcome</span><span class="o">=</span><span class="s2">&quot;re78&quot;</span><span class="p">)</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">observational</span><span class="p">)</span>
+<span class="n">result</span> <span class="o">=</span> <span class="n">PropensityScoreMatching</span><span class="p">(</span>
+    <span class="n">obs_dag</span><span class="p">,</span> <span class="n">treatment</span><span class="o">=</span><span class="s2">&quot;treat&quot;</span><span class="p">,</span> <span class="n">outcome</span><span class="o">=</span><span class="s2">&quot;re78&quot;</span>
+<span class="p">)</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">observational</span><span class="p">)</span>
 <span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">summary</span><span class="p">())</span>
 </pre></div>
 </div>
@@ -386,7 +390,10 @@ staff plus managers plus half the part-time staff.</p>
 Table 3 reports four cell means; formative’s DiD will be built from exactly these:</p>
 <div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">state</span><span class="p">,</span> <span class="n">name</span> <span class="ow">in</span> <span class="p">[(</span><span class="mi">1</span><span class="p">,</span> <span class="s2">&quot;NJ&quot;</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="s2">&quot;PA&quot;</span><span class="p">)]:</span>
     <span class="n">sub</span> <span class="o">=</span> <span class="n">raw</span><span class="p">[</span><span class="n">raw</span><span class="o">.</span><span class="n">STATE</span> <span class="o">==</span> <span class="n">state</span><span class="p">]</span>
-    <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s2">: before </span><span class="si">{</span><span class="n">sub</span><span class="o">.</span><span class="n">fte_before</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span><span class="si">:</span><span class="s2">.2f</span><span class="si">}</span><span class="s2">, after </span><span class="si">{</span><span class="n">sub</span><span class="o">.</span><span class="n">fte_after</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span><span class="si">:</span><span class="s2">.2f</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span>
+        <span class="sa">f</span><span class="s2">&quot;</span><span class="si">{</span><span class="n">name</span><span class="si">}</span><span class="s2">: before </span><span class="si">{</span><span class="n">sub</span><span class="o">.</span><span class="n">fte_before</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span><span class="si">:</span><span class="s2">.2f</span><span class="si">}</span><span class="s2">, &quot;</span>
+        <span class="sa">f</span><span class="s2">&quot;after </span><span class="si">{</span><span class="n">sub</span><span class="o">.</span><span class="n">fte_after</span><span class="o">.</span><span class="n">mean</span><span class="p">()</span><span class="si">:</span><span class="s2">.2f</span><span class="si">}</span><span class="s2">&quot;</span>
+    <span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-text notranslate"><div class="highlight"><pre><span></span>NJ: before 20.44, after 21.03
@@ -406,8 +413,18 @@ binary group and time indicators:</p>
 
 <span class="n">long</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">concat</span><span class="p">(</span>
     <span class="p">[</span>
-        <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">({</span><span class="s2">&quot;store&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">SHEET</span><span class="p">,</span> <span class="s2">&quot;nj&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">STATE</span><span class="p">,</span> <span class="s2">&quot;after&quot;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="s2">&quot;fte&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">fte_before</span><span class="p">}),</span>
-        <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">({</span><span class="s2">&quot;store&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">SHEET</span><span class="p">,</span> <span class="s2">&quot;nj&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">STATE</span><span class="p">,</span> <span class="s2">&quot;after&quot;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s2">&quot;fte&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">fte_after</span><span class="p">}),</span>
+        <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">({</span>
+            <span class="s2">&quot;store&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">SHEET</span><span class="p">,</span>
+            <span class="s2">&quot;nj&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">STATE</span><span class="p">,</span>
+            <span class="s2">&quot;after&quot;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
+            <span class="s2">&quot;fte&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">fte_before</span><span class="p">,</span>
+        <span class="p">}),</span>
+        <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">({</span>
+            <span class="s2">&quot;store&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">SHEET</span><span class="p">,</span>
+            <span class="s2">&quot;nj&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">STATE</span><span class="p">,</span>
+            <span class="s2">&quot;after&quot;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
+            <span class="s2">&quot;fte&quot;</span><span class="p">:</span> <span class="n">raw</span><span class="o">.</span><span class="n">fte_after</span><span class="p">,</span>
+        <span class="p">}),</span>
     <span class="p">],</span>
     <span class="n">ignore_index</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
 <span class="p">)</span><span class="o">.</span><span class="n">dropna</span><span class="p">(</span><span class="n">subset</span><span class="o">=</span><span class="p">[</span><span class="s2">&quot;fte&quot;</span><span class="p">])</span>