openstat-cli 1.0.0__py3-none-any.whl

openstat/stats/factor.py

@@ -0,0 +1,174 @@
+"""Factor Analysis and PCA."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+
+try:
+    from sklearn.decomposition import PCA as _SklearnPCA
+    _HAS_SKLEARN = True
+except ImportError:
+    _HAS_SKLEARN = False
+
+
+# ── PCA ────────────────────────────────────────────────────────────────────
+
+def fit_pca(
+    df: pl.DataFrame,
+    cols: list[str],
+    n_components: int | None = None,
+) -> dict:
+    """
+    Fit PCA using numpy SVD (no sklearn required).
+
+    Returns:
+        eigenvalues, loadings, explained_variance_ratio, cumulative_var,
+        scores (component scores for each observation), n_components, cols
+    """
+    X = df.select(cols).to_numpy().astype(float)
+    # standardise
+    X = (X - X.mean(axis=0)) / (X.std(axis=0) + 1e-15)
+
+    n, p = X.shape
+    if n_components is None:
+        n_components = min(n, p)
+    n_components = min(n_components, min(n, p))
+
+    cov = X.T @ X / (n - 1)
+    eigvals, eigvecs = np.linalg.eigh(cov)
+    # sort descending
+    order = np.argsort(eigvals)[::-1]
+    eigvals = eigvals[order]
+    eigvecs = eigvecs[:, order]
+
+    eigvals = eigvals[:n_components]
+    eigvecs = eigvecs[:, :n_components]
+
+    total_var = eigvals.sum()
+    if total_var <= 0:
+        total_var = 1.0
+    evr = eigvals / p  # proportion of total variance (eigenvalue / p)
+    cum_var = np.cumsum(eigvals / p)
+
+    scores = X @ eigvecs
+
+    return {
+        "eigenvalues": eigvals.tolist(),
+        "loadings": eigvecs.tolist(),        # shape (p, n_components)
+        "explained_variance_ratio": evr.tolist(),
+        "cumulative_variance": cum_var.tolist(),
+        "scores": scores.tolist(),
+        "n_components": n_components,
+        "cols": cols,
+    }
+
+
+# ── Varimax rotation ───────────────────────────────────────────────────────
+
+def varimax_rotation(loadings: np.ndarray, tol: float = 1e-6, max_iter: int = 1000) -> np.ndarray:
+    """Orthogonal varimax rotation of factor loadings."""
+    p, k = loadings.shape
+    rotation = np.eye(k)
+
+    for _ in range(max_iter):
+        old_rotation = rotation.copy()
+        for i in range(k):
+            for j in range(i + 1, k):
+                x = loadings @ rotation
+                u = x[:, i] ** 2 - x[:, j] ** 2
+                v = 2 * x[:, i] * x[:, j]
+                A = v.sum()
+                B = u.sum()
+                C = (v**2 - u**2).sum()
+                D = 2 * (u * v).sum()
+                num = D - 2 * A * B / p
+                den = C - (A**2 - B**2) / p
+                if abs(den) < 1e-15:
+                    continue
+                theta = 0.25 * np.arctan2(num, den)
+                c, s = np.cos(theta), np.sin(theta)
+                rot2 = np.eye(k)
+                rot2[i, i] = c
+                rot2[j, j] = c
+                rot2[i, j] = -s
+                rot2[j, i] = s
+                rotation = rotation @ rot2
+
+        if np.max(np.abs(rotation - old_rotation)) < tol:
+            break
+
+    return loadings @ rotation
+
+
+# ── Factor Analysis ────────────────────────────────────────────────────────
+
+def fit_factor(
+    df: pl.DataFrame,
+    cols: list[str],
+    n_factors: int = 2,
+    method: str = "pc",
+    rotate: bool = True,
+) -> dict:
+    """
+    Fit a factor analysis model.
+
+    method: 'pc' (principal components extraction) or 'ml' (max likelihood via statsmodels if available)
+    rotate: apply varimax rotation when True
+
+    Returns:
+        loadings, communalities, uniqueness, n_factors, cols
+    """
+    X = df.select(cols).to_numpy().astype(float)
+    n, p = X.shape
+    X = (X - X.mean(axis=0)) / (X.std(axis=0) + 1e-15)
+    n_factors = min(n_factors, p)
+
+    if method == "ml":
+        try:
+            import statsmodels.multivariate.factor as sm_fa  # type: ignore[import]
+            fa = sm_fa.Factor(X, n_factor=n_factors, method="ml")
+            res = fa.fit()
+            loadings = np.array(res.loadings)
+            if rotate and n_factors > 1:
+                loadings = varimax_rotation(loadings)
+            communalities = (loadings**2).sum(axis=1)
+            uniqueness = 1 - communalities
+            return {
+                "method": "ml",
+                "loadings": loadings.tolist(),
+                "communalities": communalities.tolist(),
+                "uniqueness": uniqueness.tolist(),
+                "n_factors": n_factors,
+                "cols": cols,
+            }
+        except Exception:
+            pass  # fall through to PC method
+
+    # Principal components extraction
+    cov = X.T @ X / (n - 1)
+    eigvals, eigvecs = np.linalg.eigh(cov)
+    order = np.argsort(eigvals)[::-1]
+    eigvals = eigvals[order]
+    eigvecs = eigvecs[:, order]
+
+    eigvals_k = eigvals[:n_factors]
+    eigvecs_k = eigvecs[:, :n_factors]
+
+    loadings = eigvecs_k * np.sqrt(np.maximum(eigvals_k, 0))
+
+    if rotate and n_factors > 1:
+        loadings = varimax_rotation(loadings)
+
+    communalities = (loadings**2).sum(axis=1)
+    uniqueness = 1 - communalities
+
+    return {
+        "method": "pc",
+        "eigenvalues": eigvals.tolist(),
+        "loadings": loadings.tolist(),
+        "communalities": communalities.tolist(),
+        "uniqueness": uniqueness.tolist(),
+        "n_factors": n_factors,
+        "cols": cols,
+    }

openstat/stats/imputation.py

@@ -0,0 +1,282 @@
+"""Multiple Imputation by Chained Equations (MICE) and Rubin's rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import polars as pl
+import statsmodels.api as sm
+from scipy import stats as sp_stats
+
+
+@dataclass
+class MIResult:
+    """Combined result from multiple imputation using Rubin's rules."""
+
+    model_type: str
+    formula: str
+    m: int  # number of imputations
+    params: dict[str, float]
+    std_errors: dict[str, float]
+    t_values: dict[str, float]
+    p_values: dict[str, float]
+    conf_int_low: dict[str, float]
+    conf_int_high: dict[str, float]
+    n_obs: int
+    within_var: dict[str, float]  # U_bar
+    between_var: dict[str, float]  # B
+    fmi: dict[str, float]  # fraction of missing information
+
+
+def _initial_fill(series: np.ndarray, rng: np.random.Generator) -> np.ndarray:
+    """Initialize missing values by sampling from observed."""
+    result = series.copy()
+    mask = np.isnan(result)
+    observed = result[~mask]
+    if len(observed) > 0 and mask.any():
+        result[mask] = rng.choice(observed, size=mask.sum())
+    return result
+
+
+def _impute_regression(data: np.ndarray, col_idx: int, rng: np.random.Generator) -> None:
+    """Impute a continuous variable using Bayesian linear regression."""
+    mask = np.isnan(data[:, col_idx])
+    if not mask.any():
+        return
+
+    obs_idx = ~mask
+    predictors = np.delete(data, col_idx, axis=1)
+
+    y_obs = data[obs_idx, col_idx]
+    X_obs = sm.add_constant(predictors[obs_idx])
+
+    try:
+        model = sm.OLS(y_obs, X_obs).fit()
+        # Draw from posterior (proper imputation)
+        beta_hat = model.params
+        sigma2 = model.scale
+        # Draw sigma from scaled inverse chi-squared
+        n = len(y_obs)
+        k = len(beta_hat)
+        sigma2_draw = sigma2 * (n - k) / rng.chisquare(n - k)
+        # Draw beta from multivariate normal
+        cov = model.cov_params() * sigma2_draw / sigma2
+        beta_draw = rng.multivariate_normal(beta_hat, cov)
+
+        # Predict missing
+        X_miss = sm.add_constant(predictors[mask])
+        y_pred = X_miss @ beta_draw
+        y_pred += rng.normal(0, np.sqrt(sigma2_draw), size=len(y_pred))
+        data[mask, col_idx] = y_pred
+    except Exception:
+        # Fallback: simple mean imputation
+        data[mask, col_idx] = np.nanmean(data[:, col_idx])
+
+
+def _impute_logit(data: np.ndarray, col_idx: int, rng: np.random.Generator) -> None:
+    """Impute a binary variable using logistic regression."""
+    mask = np.isnan(data[:, col_idx])
+    if not mask.any():
+        return
+
+    obs_idx = ~mask
+    predictors = np.delete(data, col_idx, axis=1)
+
+    y_obs = data[obs_idx, col_idx]
+    X_obs = sm.add_constant(predictors[obs_idx])
+
+    try:
+        model = sm.Logit(y_obs, X_obs).fit(disp=0)
+        beta_hat = model.params
+        cov = model.cov_params()
+        beta_draw = rng.multivariate_normal(beta_hat, cov)
+
+        X_miss = sm.add_constant(predictors[mask])
+        logits = X_miss @ beta_draw
+        probs = 1 / (1 + np.exp(-logits))
+        data[mask, col_idx] = (rng.random(size=len(probs)) < probs).astype(float)
+    except Exception:
+        data[mask, col_idx] = np.round(np.nanmean(data[:, col_idx]))
+
+
+def _impute_pmm(data: np.ndarray, col_idx: int, rng: np.random.Generator, k: int = 5) -> None:
+    """Impute using Predictive Mean Matching."""
+    mask = np.isnan(data[:, col_idx])
+    if not mask.any():
+        return
+
+    obs_idx = ~mask
+    predictors = np.delete(data, col_idx, axis=1)
+
+    y_obs = data[obs_idx, col_idx]
+    X_obs = sm.add_constant(predictors[obs_idx])
+
+    try:
+        model = sm.OLS(y_obs, X_obs).fit()
+        y_hat_obs = model.predict(X_obs)
+
+        beta_draw = rng.multivariate_normal(model.params, model.cov_params())
+        X_miss = sm.add_constant(predictors[mask])
+        y_hat_miss = X_miss @ beta_draw
+
+        # For each missing, find k nearest donors and sample
+        for i, pred in enumerate(y_hat_miss):
+            distances = np.abs(y_hat_obs - pred)
+            donor_indices = np.argsort(distances)[:k]
+            chosen = rng.choice(donor_indices)
+            data[mask, col_idx] = y_obs.iloc[chosen] if hasattr(y_obs, 'iloc') else y_obs[chosen]
+    except Exception:
+        data[mask, col_idx] = np.nanmean(data[:, col_idx])
+
+
+def mice_impute(
+    df: pl.DataFrame,
+    specs: list[tuple[str, str]],
+    m: int = 5,
+    max_iter: int = 10,
+    seed: int = 42,
+) -> list[pl.DataFrame]:
+    """Run MICE (Multiple Imputation by Chained Equations).
+
+    Args:
+        df: Input DataFrame with missing values.
+        specs: List of (method, column) tuples.
+            method: "regress", "logit", "pmm"
+        m: Number of imputed datasets.
+        max_iter: Number of MICE iterations.
+        seed: Random seed.
+
+    Returns list of m imputed DataFrames.
+    """
+    rng = np.random.default_rng(seed)
+    col_names = [col for _, col in specs]
+    other_cols = [c for c in df.columns if c not in col_names]
+    all_cols = col_names + other_cols
+
+    imputed_datasets: list[pl.DataFrame] = []
+
+    for imp in range(m):
+        # Convert to numpy for fast computation
+        data = df.select(all_cols).to_numpy().astype(float)
+        n_imp_cols = len(col_names)
+
+        # Initialize missing with random draws from observed
+        for i in range(n_imp_cols):
+            data[:, i] = _initial_fill(data[:, i], rng)
+
+        # Iterate chained equations
+        for _ in range(max_iter):
+            for i, (method, _col) in enumerate(specs):
+                # Temporarily set imputed values back to NaN for this col
+                orig = df[_col].to_numpy().astype(float)
+                was_missing = np.isnan(orig)
+                save = data[was_missing, i].copy()
+                data[was_missing, i] = np.nan
+
+                if method == "regress":
+                    _impute_regression(data, i, rng)
+                elif method == "logit":
+                    _impute_logit(data, i, rng)
+                elif method == "pmm":
+                    _impute_pmm(data, i, rng)
+                else:
+                    # Default to regression
+                    _impute_regression(data, i, rng)
+
+        # Convert back to Polars
+        imputed_df = pl.DataFrame({
+            col: data[:, i] for i, col in enumerate(all_cols)
+        })
+        imputed_datasets.append(imputed_df)
+
+    return imputed_datasets
+
+
+def rubins_rules(
+    estimates: list[dict[str, float]],
+    std_errors: list[dict[str, float]],
+    n_obs: int,
+) -> MIResult:
+    """Combine estimates from m imputed datasets using Rubin's rules.
+
+    Args:
+        estimates: List of param dicts from each imputed dataset.
+        std_errors: List of SE dicts from each imputed dataset.
+        n_obs: Number of observations.
+
+    Returns MIResult with combined estimates.
+    """
+    m = len(estimates)
+    var_names = list(estimates[0].keys())
+
+    combined_params: dict[str, float] = {}
+    combined_se: dict[str, float] = {}
+    combined_t: dict[str, float] = {}
+    combined_p: dict[str, float] = {}
+    combined_ci_low: dict[str, float] = {}
+    combined_ci_high: dict[str, float] = {}
+    within_var: dict[str, float] = {}
+    between_var: dict[str, float] = {}
+    fmi_dict: dict[str, float] = {}
+
+    for var in var_names:
+        # Point estimate: average across imputations
+        q_vals = np.array([est[var] for est in estimates])
+        q_bar = float(np.mean(q_vals))
+
+        # Within-imputation variance
+        u_vals = np.array([se[var] ** 2 for se in std_errors])
+        u_bar = float(np.mean(u_vals))
+
+        # Between-imputation variance
+        b = float(np.var(q_vals, ddof=1))
+
+        # Total variance
+        t = u_bar + (1 + 1 / m) * b
+
+        # Degrees of freedom (Barnard-Rubin)
+        if b > 0 and u_bar > 0:
+            r = (1 + 1 / m) * b / u_bar
+            df_old = (m - 1) * (1 + 1 / r) ** 2
+            df_obs = (n_obs - len(var_names) + 1) / (n_obs - len(var_names) + 3) * (n_obs - len(var_names)) * (1 - r)
+            if df_obs > 0:
+                df = (df_old * df_obs) / (df_old + df_obs)
+            else:
+                df = df_old
+            fmi = (r + 2 / (df + 3)) / (r + 1)
+        else:
+            df = max(n_obs - len(var_names), 1)
+            fmi = 0.0
+
+        se = np.sqrt(t)
+        t_val = q_bar / se if se > 0 else 0.0
+        p_val = float(2 * (1 - sp_stats.t.cdf(abs(t_val), df))) if df > 0 else 1.0
+        ci_low = q_bar - 1.96 * se
+        ci_high = q_bar + 1.96 * se
+
+        combined_params[var] = q_bar
+        combined_se[var] = float(se)
+        combined_t[var] = t_val
+        combined_p[var] = p_val
+        combined_ci_low[var] = ci_low
+        combined_ci_high[var] = ci_high
+        within_var[var] = u_bar
+        between_var[var] = b
+        fmi_dict[var] = fmi
+
+    return MIResult(
+        model_type="MI",
+        formula="",
+        m=m,
+        params=combined_params,
+        std_errors=combined_se,
+        t_values=combined_t,
+        p_values=combined_p,
+        conf_int_low=combined_ci_low,
+        conf_int_high=combined_ci_high,
+        n_obs=n_obs,
+        within_var=within_var,
+        between_var=between_var,
+        fmi=fmi_dict,
+    )

openstat/stats/influence.py

@@ -0,0 +1,78 @@
+"""Influence diagnostics: leverage, Cook's D, DFBETAs, outlier detection."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+
+
+def compute_influence(df: pl.DataFrame, dep: str, indeps: list[str]) -> dict:
+    """Compute OLS influence statistics: leverage, Cook's D, DFBETAs, studentized residuals."""
+    sub = df.select([dep] + indeps).drop_nulls()
+    y = sub[dep].to_numpy().astype(float)
+    X_raw = sub.select(indeps).to_numpy().astype(float)
+    n, k = X_raw.shape
+    X = np.column_stack([np.ones(n), X_raw])
+    kp = k + 1
+
+    # OLS fit
+    XtX_inv = np.linalg.pinv(X.T @ X)
+    beta = XtX_inv @ X.T @ y
+    y_hat = X @ beta
+    resid = y - y_hat
+    mse = (resid @ resid) / (n - kp)
+
+    # Hat matrix diagonal (leverage)
+    H = X @ XtX_inv @ X.T
+    leverage = np.diag(H)
+
+    # Studentized residuals (internal)
+    sigma = np.sqrt(mse)
+    std_resid = resid / (sigma * np.sqrt(1 - leverage + 1e-10))
+
+    # Cook's Distance
+    cooks_d = (std_resid ** 2 * leverage) / (kp * (1 - leverage + 1e-10))
+
+    # DFBETAs per coefficient
+    dfbetas = {}
+    se_beta = np.sqrt(mse * np.diag(XtX_inv))
+    for j in range(kp):
+        name = "_cons" if j == 0 else indeps[j - 1]
+        # Approximation: dfbeta_j = h_j * resid_j / (se_beta_j * (1-lev_j))
+        dfb = (X[:, j] * resid) / ((n - kp - 1) * se_beta[j] + 1e-10)
+        dfbetas[name] = dfb.tolist()
+
+    # Mahalanobis distance on X for outlier detection
+    X_centered = X_raw - X_raw.mean(axis=0)
+    try:
+        cov_inv = np.linalg.pinv(np.cov(X_raw.T))
+        mahal = np.array([float(x @ cov_inv @ x) for x in X_centered])
+    except Exception:
+        mahal = np.zeros(n)
+
+    return {
+        "n_obs": n,
+        "n_params": kp,
+        "leverage": leverage.tolist(),
+        "cooks_d": cooks_d.tolist(),
+        "std_residuals": std_resid.tolist(),
+        "mahalanobis": mahal.tolist(),
+        "dfbetas": dfbetas,
+        "high_leverage_threshold": 2 * kp / n,
+        "high_cooks_threshold": 4 / n,
+        "n_high_leverage": int((leverage > 2 * kp / n).sum()),
+        "n_high_cooks": int((cooks_d > 4 / n).sum()),
+    }
+
+
+def detect_outliers(df: pl.DataFrame, dep: str, indeps: list[str], threshold: float = 3.0) -> dict:
+    """Identify outliers by studentized residuals > threshold."""
+    inf = compute_influence(df, dep, indeps)
+    std_resid = np.array(inf["std_residuals"])
+    outlier_idx = np.where(np.abs(std_resid) > threshold)[0].tolist()
+    return {
+        "outlier_indices": outlier_idx,
+        "n_outliers": len(outlier_idx),
+        "threshold": threshold,
+        "std_residuals": inf["std_residuals"],
+    }

openstat/stats/iv.py

@@ -0,0 +1,131 @@
+"""Instrumental variables: 2SLS, first-stage diagnostics, overidentification tests."""
+
+from __future__ import annotations
+
+import numpy as np
+import polars as pl
+import statsmodels.api as sm
+
+from openstat.stats.models import FitResult
+
+
+def _try_import_linearmodels():
+    try:
+        import linearmodels  # noqa: F401
+    except ImportError:
+        raise ImportError(
+            "IV models require linearmodels. "
+            "Install it with: pip install openstat[panel]"
+        )
+
+
+def _iv_to_fit_result(result, dep: str, exog: list[str], endog: list[str], instruments: list[str]) -> FitResult:
+    """Convert linearmodels IVResults to FitResult."""
+    all_vars = list(result.params.index)
+    params = {name: float(val) for name, val in result.params.items()}
+    std_errors = {name: float(val) for name, val in result.std_errors.items()}
+    t_values = {name: float(val) for name, val in result.tstats.items()}
+    p_values = {name: float(val) for name, val in result.pvalues.items()}
+    ci = result.conf_int()
+    conf_low = {name: float(ci.loc[name, "lower"]) for name in all_vars}
+    conf_high = {name: float(ci.loc[name, "upper"]) for name in all_vars}
+
+    warnings_list: list[str] = []
+    warnings_list.append(f"Endogenous: {', '.join(endog)}")
+    warnings_list.append(f"Instruments: {', '.join(instruments)}")
+
+    return FitResult(
+        model_type="IV-2SLS",
+        formula=f"{dep} ~ {' + '.join(exog)} + ({' + '.join(endog)} = {' + '.join(instruments)})",
+        dep_var=dep,
+        indep_vars=all_vars,
+        n_obs=int(result.nobs),
+        params=params,
+        std_errors=std_errors,
+        t_values=t_values,
+        p_values=p_values,
+        conf_int_low=conf_low,
+        conf_int_high=conf_high,
+        r_squared=float(result.rsquared) if hasattr(result, "rsquared") else None,
+        f_statistic=float(result.f_statistic.stat) if hasattr(result, "f_statistic") and result.f_statistic is not None else None,
+        f_pvalue=float(result.f_statistic.pval) if hasattr(result, "f_statistic") and result.f_statistic is not None else None,
+        warnings=warnings_list,
+    )
+
+
+def fit_iv_2sls(
+    df: pl.DataFrame,
+    dep: str,
+    exog: list[str],
+    endog: list[str],
+    instruments: list[str],
+    robust: bool = False,
+) -> tuple[FitResult, object]:
+    """Fit an IV model via Two-Stage Least Squares."""
+    _try_import_linearmodels()
+    from linearmodels.iv import IV2SLS
+
+    all_cols = [dep] + exog + endog + instruments
+    pdf = df.select(all_cols).to_pandas().dropna()
+
+    dep_data = pdf[dep]
+    exog_data = sm.add_constant(pdf[exog]) if exog else sm.add_constant(pdf[[]])
+    endog_data = pdf[endog]
+    instr_data = pdf[instruments]
+
+    model = IV2SLS(dep_data, exog_data, endog_data, instr_data)
+    cov_type = "robust" if robust else "unadjusted"
+    result = model.fit(cov_type=cov_type)
+
+    fit = _iv_to_fit_result(result, dep, ["const"] + exog, endog, instruments)
+    return fit, result
+
+
+def first_stage_diagnostics(iv_result) -> str:
+    """Report first-stage regression diagnostics."""
+    lines = ["First-Stage Diagnostics:"]
+    try:
+        fs = iv_result.first_stage
+        for endog_var in fs.diagnostics:
+            diag = fs.diagnostics[endog_var]
+            lines.append(f"\n  Endogenous: {endog_var}")
+            lines.append(f"    Partial R²: {diag.rsquared:.4f}")
+            lines.append(f"    Partial F-stat: {diag.f_stat.stat:.2f} (p={diag.f_stat.pval:.4f})")
+            if diag.f_stat.stat < 10:
+                lines.append("    ⚠ Weak instruments (F < 10)")
+    except Exception as e:
+        lines.append(f"  Could not compute: {e}")
+    return "\n".join(lines)
+
+
+def overidentification_test(iv_result) -> str:
+    """Sargan/Hansen J-test for overidentifying restrictions."""
+    lines = ["Overidentification Test (Sargan/Hansen J):"]
+    try:
+        j_test = iv_result.sargan
+        lines.append(f"  J-statistic: {j_test.stat:.4f}")
+        lines.append(f"  p-value: {j_test.pval:.4f}")
+        lines.append(f"  df: {j_test.df}")
+        if j_test.pval < 0.05:
+            lines.append("  ⚠ Reject H0: instruments may not be valid")
+        else:
+            lines.append("  ✓ Cannot reject H0: instruments appear valid")
+    except Exception as e:
+        lines.append(f"  Not available (exactly identified or error: {e})")
+    return "\n".join(lines)
+
+
+def endogeneity_test(iv_result) -> str:
+    """Durbin-Wu-Hausman test for endogeneity."""
+    lines = ["Endogeneity Test (Durbin-Wu-Hausman):"]
+    try:
+        wu_test = iv_result.wu_hausman()
+        lines.append(f"  Statistic: {wu_test.stat:.4f}")
+        lines.append(f"  p-value: {wu_test.pval:.4f}")
+        if wu_test.pval < 0.05:
+            lines.append("  ⚠ Reject H0: endogeneity detected — IV is appropriate")
+        else:
+            lines.append("  ✓ Cannot reject exogeneity — OLS may be sufficient")
+    except Exception as e:
+        lines.append(f"  Could not compute: {e}")
+    return "\n".join(lines)