Address PR #356 CI review round 13 (1 P1 guide + code)

Bool-dtype treatment columns are now classified the same way as
numeric {0, 1} rather than as "categorical". The library's binary
estimators validate value support via `validate_binary` (utils.py:
49-67), which accepts bool because True/False coerce to 1/0
numerically. Classifying bool as categorical silently routed valid
binary DiD panels away from the supported estimator set.

Changes:
- _classify_treatment() no longer early-returns "categorical" for
  bool dtype. The downstream absorbing/non-absorbing logic handles
  bool by casting to int before np.diff (raw bool diff is XOR, which
  would mask a True -> False transition).
- treatment_varies_within_unit now includes bool-dtype columns (was
  previously hardcoded False for bool).
- Guide §2 removes the "bool = categorical" rule and adds an
  explicit "bool is binary" note with a pointer to validate_binary
  as the reason.
- profile_panel() docstring mirrors the same update.

Tests:
- test_bool_dtype_treatment_is_binary_absorbing: staggered-style
  bool panel with never-treated cohort -> binary_absorbing, correct
  has_never_treated / treatment_varies_within_unit / cohort_sizes.
- test_bool_dtype_non_absorbing: reversible False -> True -> False
  bool panel -> binary_non_absorbing. Guards the int-cast before
  np.diff so future refactors don't regress to bool XOR semantics.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: igerber

diff_diff/guides/llms-autonomous.txt

@@ -90,11 +90,16 @@ view. Every field below appears as a top-level key in that dict.
       two-valued numeric column whose values are not in {0, 1} (e.g.,
       a dose, a discrete-integer partial-adoption score). Use
       `ContinuousDiD` or `HeterogeneousAdoptionDiD`.
-    - `"categorical"`: non-numeric dtype (object / category), a bool
-      dtype column, or a column that is entirely NaN. Often indicates
-      a treatment arm. Encode each arm as a binary indicator and fit
-      separately, or use a multi-treatment workflow outside the
-      current estimator suite.
+    - `"categorical"`: non-numeric dtype (object / category), or a
+      column that is entirely NaN. Often indicates a treatment arm.
+      Encode each arm as a binary indicator and fit separately, or
+      use a multi-treatment workflow outside the current estimator
+      suite.
+
+  Bool-dtype treatment columns (`True` / `False`) are classified the
+  same way as numeric `{0, 1}`: the library's binary estimators
+  validate on value support rather than dtype, so `True` and `False`
+  behave like `1` and `0` for absorbing / non-absorbing classification.
 - **`is_staggered: bool`** - true iff treatment is `binary_absorbing` and
   at least two distinct first-treatment periods are observed. Drives the
   choice between classic DiD/TWFE and staggered-robust estimators.

diff_diff/profile.py

@@ -185,12 +185,14 @@ def profile_panel(
     - ``"continuous"``: numeric treatment with more than two distinct
       values, or a 2-valued numeric whose values are not in
       :math:`\\{0, 1\\}` (matches the ``ContinuousDiD`` convention).
-    - ``"categorical"``: non-numeric dtype (object / category), a
-      boolean-dtype column, or a column that is entirely NaN.
+    - ``"categorical"``: non-numeric dtype (object / category) or a
+      column that is entirely NaN.
 
-    Boolean-dtype columns are intentionally classified as
-    ``"categorical"``; cast to ``int`` if you want binary-treatment
-    profiling.
+    Bool-dtype columns (``True`` / ``False``) are classified the same
+    way as numeric ``{0, 1}``: the library's binary estimators validate
+    on value support via :func:`diff_diff.utils.validate_binary`, so
+    ``True`` / ``False`` behave like ``1`` / ``0`` for absorbing /
+    non-absorbing classification.
 
     ``has_never_treated`` is computed across both binary and
     continuous numeric treatment types: some unit has ``treatment ==
@@ -255,9 +257,7 @@ def profile_panel(
         last_tp,
     ) = _classify_treatment(df, unit=unit, time=time, treatment=treatment)
 
-    if pd.api.types.is_numeric_dtype(df[treatment]) and not pd.api.types.is_bool_dtype(
-        df[treatment]
-    ):
+    if pd.api.types.is_numeric_dtype(df[treatment]) or pd.api.types.is_bool_dtype(df[treatment]):
         per_unit_distinct = df.groupby(unit)[treatment].nunique(dropna=True)
         treatment_varies_within_unit = bool((per_unit_distinct > 1).any())
     else:
@@ -352,7 +352,13 @@ def _classify_treatment(
     is_numeric = pd.api.types.is_numeric_dtype(col)
     is_bool = pd.api.types.is_bool_dtype(col)
 
-    if (not is_numeric) or is_bool:
+    # Bool-dtype treatment columns are treated as binary 0/1 inputs.
+    # The library's binary estimators validate value support via
+    # `validate_binary`, which accepts bool because True/False coerce
+    # to 1/0 numerically. Classifying bool columns as "categorical"
+    # here would route a valid binary design away from the supported
+    # estimator set.
+    if (not is_numeric) and (not is_bool):
         return ("categorical", False, {}, False, False, None, None)
 
     distinct = col.dropna().unique()
@@ -400,7 +406,10 @@ def _classify_treatment(
     for _, group in sorted_df.groupby(unit, sort=False):
         vals = group[treatment].to_numpy()
         mask = ~pd.isna(vals)
-        observed = vals[mask]
+        # Cast to int so np.diff on a bool-dtype column performs
+        # arithmetic (1 - 0 = 1, 0 - 1 = -1) rather than XOR (which
+        # would mask a True -> False transition).
+        observed = vals[mask].astype(np.int64, copy=False)
         if len(observed) >= 2 and bool(np.any(np.diff(observed) < 0)):
             is_absorbing = False
             break

tests/test_profile_panel.py

@@ -155,6 +155,44 @@ def test_continuous_positive_dose_does_not_fire_has_always_treated():
     assert "has_always_treated_units" not in _alert_codes(profile)
 
 
+def test_bool_dtype_treatment_is_binary_absorbing():
+    """Bool-dtype treatment columns (True/False) must classify the same
+    way as numeric {0, 1}. The library's binary estimators validate on
+    value support via `validate_binary`, which accepts bool because
+    True/False coerce to 1/0 numerically. Classifying bool as
+    "categorical" would silently route valid binary DiD panels away
+    from the supported estimator set."""
+    first_treat = {u: 2 for u in range(11, 21)}
+    rows = []
+    for u in range(1, 21):
+        for t in range(4):
+            treated = u in first_treat and t >= first_treat[u]
+            rows.append({"u": u, "t": t, "tr": bool(treated), "y": float(u) + 0.1 * t})
+    df = pd.DataFrame(rows)
+    assert df["tr"].dtype == bool
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "binary_absorbing"
+    assert profile.has_never_treated is True
+    assert profile.has_always_treated is False
+    assert profile.treatment_varies_within_unit is True
+    assert profile.cohort_sizes == {2: 10}
+
+
+def test_bool_dtype_non_absorbing():
+    """Reversible 0 -> 1 -> 0 treatment expressed as a bool column must
+    classify as binary_non_absorbing, same as numeric."""
+    rows = []
+    for u in range(1, 11):
+        seq = [False, True, True, False, False] if u > 5 else [False] * 5
+        for t, tr in enumerate(seq):
+            rows.append({"u": u, "t": t, "tr": tr, "y": float(u) + 0.1 * t})
+    df = pd.DataFrame(rows)
+    assert df["tr"].dtype == bool
+    profile = profile_panel(df, unit="u", time="t", treatment="tr", outcome="y")
+    assert profile.treatment_type == "binary_non_absorbing"
+    assert profile.has_never_treated is True
+
+
 def test_categorical_treatment_object_dtype():
     rows = []
     for u in range(1, 11):