bossanova 0.1.0.dev16__tar.gz → 0.1.0.dev18__tar.gz

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/.gitignore

@@ -78,7 +78,7 @@ COMPARISON-REPORT.md
 ERROR_MESSAGE_IMPROVEMENTS.md
 *.qmd
 bossanova-docs/apidocs/
-bossanova-docs/help/
+bossanova-docs/api/
 bossanova-docs/wip/
 .hypothesis/
 research.md

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bossanova
-Version: 0.1.0.dev16
+Version: 0.1.0.dev18
 Summary: Bridging statistical cultures with some jazz
 Author: Eshin Jolly
 License-Expression: MIT
@@ -70,4 +70,19 @@ m.explore("Days")
 m.effects
 ```
 
+## Development
+
+```bash
+# Install dependencies
+pixi install
+
+# Install the IPython kernel (required for notebooks)
+pixi run setup-kernel
+
+# Run the full lint + type-check chain
+pixi run lint
+
+# Run fast unit tests
+pixi run test
+```
 

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/README.md

@@ -42,4 +42,19 @@ m.explore("Days")
 m.effects
 ```
 
+## Development
+
+```bash
+# Install dependencies
+pixi install
+
+# Install the IPython kernel (required for notebooks)
+pixi run setup-kernel
+
+# Run the full lint + type-check chain
+pixi run lint
+
+# Run fast unit tests
+pixi run test
+```
 

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/__init__.py

@@ -31,7 +31,7 @@ from bossanova.data import (  # noqa: E402
 from bossanova.model import model  # noqa: E402
 
 # Statistics
-from bossanova.internal.operations.compare import compare, lrt  # noqa: E402
+from bossanova.internal.compare import compare, lrt  # noqa: E402
 
 # Visualization
 from bossanova.internal import viz  # noqa: E402

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/expressions.py

@@ -2,7 +2,7 @@
 
 This module provides stateless Polars expressions for data transformations
 commonly used in statistical modeling. These match the semantics of the
-formula-based transforms in `bossanova.internal.operations.formula`.
+formula-based transforms in `bossanova.internal.formula`.
 
 Core Transforms:
     center(col): x - mean(x) — subtract mean only

bossanova-0.1.0.dev18/bossanova/internal/compare/__init__.py

@@ -0,0 +1,27 @@
+"""Model comparison: information criteria, likelihood ratio tests, and composite tables.
+
+Call chain:
+    bossanova.compare(m1, m2, ...) -> compare() (composite AIC/BIC/loglik table)
+    bossanova.lrt(m1, m2) -> lrt() (nested model likelihood ratio test)
+
+Container flow:
+    Input: Sequence of fitted model instances
+    Output: Polars DataFrame with comparison metrics
+
+Submodules:
+    compare: Composite comparison table (AIC, BIC, loglik, df)
+    ic: Information criterion comparison (delta-AIC/BIC, Akaike/Schwarz weights)
+    lrt: Likelihood ratio test for nested mixed models
+    lrt_compare: LRT implementation details
+    f_test: F-test for nested linear models
+    deviance: Deviance test for nested GLMs
+    cv: Cross-validation comparison (Nadeau-Bengio corrected t-test)
+    refit: REML-to-ML refit helper for mixed model comparison
+    helpers: Shared formatting utilities
+"""
+
+from bossanova.internal.compare.compare import compare
+from bossanova.internal.compare.ic import compare_aic, compare_bic
+from bossanova.internal.compare.lrt import lrt
+
+__all__ = ["compare", "compare_aic", "compare_bic", "lrt"]

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/compare.py

@@ -35,16 +35,17 @@ import polars as pl
 
 from bossanova.internal.maths.config import get_display_digits
 from bossanova.internal.maths.rounding import round_float_columns
-from bossanova.internal.operations.compare.cv import compare_cv
-from bossanova.internal.operations.compare.deviance import compare_deviance
-from bossanova.internal.operations.compare.f_test import compare_f_test
-from bossanova.internal.operations.compare.helpers import (
-    infer_method,
+from bossanova.internal.compare.cv import compare_cv
+from bossanova.internal.compare.deviance import compare_deviance
+from bossanova.internal.compare.f_test import compare_f_test
+from bossanova.internal.compare.helpers import (
+    resolve_method,
     sort_models_by_complexity,
     validate_models,
 )
-from bossanova.internal.operations.compare.lrt_compare import compare_lrt
-from bossanova.internal.operations.compare.refit import refit_with_ml
+from bossanova.internal.compare.ic import compare_aic, compare_bic
+from bossanova.internal.compare.lrt_compare import compare_lrt
+from bossanova.internal.compare.refit import refit_with_ml
 
 __all__ = ["compare"]
 
@@ -78,6 +79,8 @@ def compare(
             - "lrt": Likelihood ratio test (for mixed models)
             - "deviance": Deviance test (for glm)
             - "cv": Cross-validation comparison (for lm/glm)
+            - "aic": AIC comparison with delta-AIC and Akaike weights
+            - "bic": BIC comparison with delta-BIC and Schwarz weights
         sort: If True, sort models by complexity before comparing.
             This ensures proper nesting order.
         refit: If True and models are lmer/glmer with REML estimation,
@@ -140,6 +143,15 @@ def compare(
             - diff_se: Nadeau-Bengio corrected standard error
             - p_value: Two-sided p-value
 
+        For AIC/BIC comparison:
+            - model: Formula string
+            - npar: Number of estimated parameters
+            - loglik: Log-likelihood
+            - deviance: Deviance (-2 * loglik)
+            - AIC/BIC: Information criteria
+            - delta_AIC/delta_BIC: Difference from best model
+            - weight: Akaike/Schwarz weight (model probability)
+
     Raises:
         ValueError: If models are not valid for comparison.
 
@@ -211,15 +223,15 @@ def compare(
     # Validate and auto-fit models (pass method and refit for REML check)
     models = validate_models(models, method=method, refit=refit)
 
-    # Sort if requested (not applicable for CV)
-    if sort and method != "cv":
+    # Sort if requested (not applicable for CV or IC methods which sort internally)
+    if sort and method not in ("cv", "aic", "bic"):
         model_list = sort_models_by_complexity(models)
     else:
         model_list = list(models)
 
     # Infer method if auto
     if method == "auto":
-        method = infer_method(model_list[0])
+        method = resolve_method(model_list[0])
 
     # For LRT with refit=True, refit REML models with ML
     if method == "lrt" and refit:
@@ -234,9 +246,14 @@ def compare(
         result = compare_deviance(model_list, test=test)
     elif method == "cv":
         result = compare_cv(model_list, cv=cv, seed=seed, metric=metric)
+    elif method == "aic":
+        result = compare_aic(model_list)
+    elif method == "bic":
+        result = compare_bic(model_list)
     else:
         raise ValueError(
-            f"Unknown method: {method}. Use 'auto', 'f', 'lrt', 'deviance', or 'cv'."
+            f"Unknown method: {method}. "
+            "Use 'auto', 'f', 'lrt', 'deviance', 'cv', 'aic', or 'bic'."
         )
 
     # Round float columns to significant figures (digits=0 disables rounding)

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/cv.py

@@ -13,19 +13,19 @@ from scipy import stats
 
 from bossanova.internal.containers.schemas import Col, ComparisonCv
 from bossanova.internal.maths.rng import RNG
-from bossanova.internal.operations.compare.helpers import get_model_type
-from bossanova.internal.operations.resample.core import (
+from bossanova.internal.compare.helpers import get_model_type
+from bossanova.internal.infer.resample.core import (
     generate_kfold_indices,
     generate_loo_indices,
 )
 
 __all__ = [
     "compare_cv",
-    "cv_fold_score",
+    "compute_cv_fold_score",
 ]
 
 
-def cv_fold_score(
+def compute_cv_fold_score(
     model: Any,
     train_idx: np.ndarray,
     test_idx: np.ndarray,
@@ -142,7 +142,7 @@ def compare_cv(
 
     for train_idx, test_idx in splits:
         for i, model in enumerate(models):
-            score = cv_fold_score(model, train_idx, test_idx, metric)
+            score = compute_cv_fold_score(model, train_idx, test_idx, metric)
             fold_scores[i].append(score)
 
     # Convert to arrays

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/deviance.py

@@ -14,7 +14,7 @@ from bossanova.internal.containers.schemas import (
     ComparisonDevianceChi2,
     ComparisonDevianceF,
 )
-from bossanova.internal.operations.compare.helpers import check_nested
+from bossanova.internal.compare.helpers import check_nested
 
 __all__ = [
     "compare_deviance",

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/f_test.py

@@ -10,7 +10,7 @@ import polars as pl
 from scipy import stats
 
 from bossanova.internal.containers.schemas import Col, ComparisonFTest
-from bossanova.internal.operations.compare.helpers import check_nested
+from bossanova.internal.compare.helpers import check_nested
 
 __all__ = [
     "compare_f_test",

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/helpers.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 __all__ = [
     "check_nested",
     "get_model_type",
-    "infer_method",
+    "resolve_method",
     "sort_models_by_complexity",
     "validate_models",
 ]
@@ -100,7 +100,7 @@ def validate_models(
 
     # For LRT, check that all models use ML estimation (unless refit=True)
     model_type = model_types[0]
-    inferred_method = method if method != "auto" else infer_method(models[0])
+    inferred_method = method if method != "auto" else resolve_method(models[0])
 
     if inferred_method == "lrt" and model_type in ("lmer", "glmer") and not refit:
         methods = [m._spec.method for m in models]
@@ -151,7 +151,7 @@ def sort_models_by_complexity(models: tuple[Any, ...]) -> list[Any]:
     return sorted(models, key=get_total_params)
 
 
-def infer_method(model: Any) -> str:
+def resolve_method(model: Any) -> str:
     """Infer the appropriate comparison method for a model type.
 
     Uses :func:`classify_model_type` to canonically determine the model type

bossanova-0.1.0.dev18/bossanova/internal/compare/ic.py

@@ -0,0 +1,160 @@
+"""Information criterion comparison for model selection.
+
+Computes AIC/BIC tables with delta-IC and Akaike/Schwarz weights,
+following Burnham & Anderson (2002). Unlike hypothesis-test comparisons
+(F-test, LRT, deviance), IC comparison does not require model nesting —
+any set of models fitted to the same data can be compared.
+
+Functions:
+    compare_aic: Rank models by AIC with delta-AIC and Akaike weights.
+    compare_bic: Rank models by BIC with delta-BIC and Schwarz weights.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import polars as pl
+
+from bossanova.internal.containers.schemas import (
+    Col,
+    ComparisonAic,
+    ComparisonBic,
+)
+from bossanova.internal.maths.family import ESTIMATED_DISPERSION_FAMILIES
+from bossanova.internal.maths.inference import compute_aic, compute_bic
+
+__all__ = ["compare_aic", "compare_bic"]
+
+
+def _get_n_params_ic(model: Any) -> int:
+    """Get total number of estimated parameters for IC computation.
+
+    Follows the same counting as ``compute_diagnostics()``:
+
+    - ``rank`` (estimable fixed effects)
+    - ``+ len(theta)`` for mixed models (variance parameters)
+    - ``+ 1`` for families with estimated dispersion (e.g. Gaussian sigma)
+
+    Args:
+        model: A fitted model instance.
+
+    Returns:
+        Total parameter count for AIC/BIC computation.
+    """
+    k: int = model._bundle.rank
+    if model._fit.theta is not None:
+        k += len(model._fit.theta)
+    if model._spec.family in ESTIMATED_DISPERSION_FAMILIES:
+        k += 1
+    return k
+
+
+def compare_aic(models: list[Any]) -> pl.DataFrame:
+    """Compare models by AIC with delta-AIC and Akaike weights.
+
+    Models are sorted by AIC (best first). Delta-AIC is the difference
+    from the best model. Akaike weights represent the relative likelihood
+    of each model being the best, following Burnham & Anderson (2002):
+
+        w_i = exp(-0.5 * delta_i) / sum(exp(-0.5 * delta_j))
+
+    Args:
+        models: List of fitted model objects (at least 2).
+
+    Returns:
+        DataFrame with columns: model, npar, loglik, deviance, AIC, BIC,
+        delta_AIC, weight. Sorted by AIC ascending (best model first).
+    """
+    return _compare_ic(models, criterion="aic")
+
+
+def compare_bic(models: list[Any]) -> pl.DataFrame:
+    """Compare models by BIC with delta-BIC and Schwarz weights.
+
+    Models are sorted by BIC (best first). Delta-BIC is the difference
+    from the best model. Schwarz weights use the same formula as Akaike
+    weights but applied to BIC differences.
+
+    Args:
+        models: List of fitted model objects (at least 2).
+
+    Returns:
+        DataFrame with columns: model, npar, loglik, deviance, AIC, BIC,
+        delta_BIC, weight. Sorted by BIC ascending (best model first).
+    """
+    return _compare_ic(models, criterion="bic")
+
+
+def _compare_ic(models: list[Any], *, criterion: str) -> pl.DataFrame:
+    """Shared implementation for AIC/BIC comparison.
+
+    Args:
+        models: List of fitted models.
+        criterion: ``"aic"`` or ``"bic"``.
+
+    Returns:
+        DataFrame sorted by the chosen criterion with delta-IC and weights.
+    """
+    formulas: list[str] = []
+    npars: list[int] = []
+    logliks: list[float] = []
+    deviances: list[float] = []
+    aics: list[float] = []
+    bics: list[float] = []
+
+    for m in models:
+        k = _get_n_params_ic(m)
+        loglik = float(m._fit.loglik)
+        n = m._bundle.n
+
+        formulas.append(m.formula)
+        npars.append(k)
+        logliks.append(loglik)
+        deviances.append(-2.0 * loglik)
+        aics.append(compute_aic(loglik, k))
+        bics.append(compute_bic(loglik, k, n))
+
+    # Select criterion and schema
+    if criterion == "aic":
+        ic_values = aics
+        delta_col = Col.DELTA_AIC
+        schema = ComparisonAic
+    else:
+        ic_values = bics
+        delta_col = Col.DELTA_BIC
+        schema = ComparisonBic
+
+    # Sort all lists by IC value (ascending = best first)
+    order = sorted(range(len(models)), key=lambda i: ic_values[i])
+    formulas = [formulas[i] for i in order]
+    npars = [npars[i] for i in order]
+    logliks = [logliks[i] for i in order]
+    deviances = [deviances[i] for i in order]
+    aics = [aics[i] for i in order]
+    bics = [bics[i] for i in order]
+    ic_values = [ic_values[i] for i in order]
+
+    # Delta-IC: difference from best model
+    ic_min = ic_values[0]
+    deltas = [v - ic_min for v in ic_values]
+
+    # Akaike/Schwarz weights: exp(-0.5 * delta) / sum(exp(-0.5 * delta))
+    raw_weights = [math.exp(-0.5 * d) for d in deltas]
+    weight_sum = sum(raw_weights)
+    weights = [w / weight_sum for w in raw_weights]
+
+    return pl.DataFrame(
+        {
+            Col.MODEL: formulas,
+            Col.NPAR: npars,
+            Col.LOGLIK: logliks,
+            Col.DEVIANCE: deviances,
+            Col.AIC_R: aics,
+            Col.BIC_R: bics,
+            delta_col: deltas,
+            Col.WEIGHT: weights,
+        },
+        schema=schema,
+    )

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/lrt.py

@@ -4,7 +4,7 @@ from typing import Any
 
 import polars as pl
 
-from bossanova.internal.operations.compare.compare import compare
+from bossanova.internal.compare.compare import compare
 
 __all__ = ["lrt"]
 

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/lrt_compare.py

@@ -16,7 +16,7 @@ from bossanova.internal.containers.schemas import (
 from bossanova.internal.maths.config import is_singular
 from bossanova.internal.maths.inference import compute_aic as compute_aic
 from bossanova.internal.maths.inference import compute_bic as _compute_bic
-from bossanova.internal.operations.compare.helpers import check_nested, get_model_type
+from bossanova.internal.compare.helpers import check_nested, get_model_type
 
 __all__ = [
     "compare_lrt",

{bossanova-0.1.0.dev16/bossanova/internal/operations → bossanova-0.1.0.dev18/bossanova/internal}/compare/refit.py

@@ -6,7 +6,7 @@ estimation when the original uses REML, enabling valid likelihood ratio tests.
 
 from typing import Any
 
-from bossanova.internal.operations.compare.helpers import get_model_type
+from bossanova.internal.compare.helpers import get_model_type
 
 __all__ = [
     "refit_with_ml",

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/builders/dataframes.py

@@ -61,7 +61,7 @@ def build_params_dataframe(
     Column set varies by inference method:
 
     - **asymp**: all inference columns (p_value last).
-    - **boot**: no p_value; df = n_resamples.
+    - **boot**: all inference columns; df = n_resamples.
     - **perm**: no CIs; df = n_valid_resamples.
     - **cv**: PRE columns only.
     - **None**: term + estimate only.
@@ -96,6 +96,7 @@ def build_params_dataframe(
         data[Col.CI_UPPER] = params_inference.ci_upper.tolist()
         data[Col.STATISTIC] = params_inference.statistic.tolist()
         data[Col.DF] = params_inference.df.tolist()
+        data[Col.P_VALUE] = params_inference.p_value.tolist()
         return pl.DataFrame(data, schema=ParamsBoot)
 
     if method == "perm":

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/builders/results.py

@@ -28,7 +28,7 @@ _INFERENCE_COLS: tuple[str, ...] = (
 )
 
 # Columns excluded per inference method.
-_BOOT_EXCLUDE: frozenset[str] = frozenset({Col.P_VALUE})
+_BOOT_EXCLUDE: frozenset[str] = frozenset()
 _PERM_EXCLUDE: frozenset[str] = frozenset({Col.CI_LOWER, Col.CI_UPPER})
 
 
@@ -43,7 +43,6 @@ def append_inference_columns(
     column that is not None on *state*. Columns are added in canonical
     order: se, ci_lower, ci_upper, statistic, df, p_value.
 
-    When *method* is ``"boot"``, the ``p_value`` column is excluded.
     When *method* is ``"perm"``, the ``ci_lower`` and ``ci_upper``
     columns are excluded.
 

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/builders/specs.py

@@ -173,7 +173,7 @@ def build_model_spec_from_formula(
     if "~" not in formula:
         raise ValueError(f"Invalid formula: {formula!r}. Formula must contain '~'.")
 
-    from bossanova.internal.operations.formula.parse import extract_formula_structure
+    from bossanova.internal.formula.parse import extract_formula_structure
 
     try:
         structure = extract_formula_structure(formula)
@@ -269,13 +269,20 @@ def build_simulation_spec(
 # =============================================================================
 
 
+_CONTRAST_FUNC_RE = (
+    r"(?:treatment|dummy|sum|deviation|helmert|sequential|poly)\((\w+)(?:,\s*[^)]+)?\)"
+)
+
+
 def parse_formula_simple(formula: str) -> dict[str, Any]:
     """Simple formula parser for simulation defaults.
 
     Parses a model formula to extract variable types for default distributions.
+    Recognizes contrast encoding functions (``treatment(x)``, ``sum(x)``, etc.)
+    as categorical markers.
 
     Args:
-        formula: Model formula (e.g., "y ~ x + factor(group) + (1|subject)").
+        formula: Model formula (e.g., ``"y ~ x + treatment(group) + (1|subject)"``).
 
     Returns:
         Dictionary with keys: response, continuous, factors, re_groups.
@@ -283,6 +290,8 @@ def parse_formula_simple(formula: str) -> dict[str, Any]:
     Examples:
         >>> parse_formula_simple("y ~ x + z")
         {'response': 'y', 'continuous': ['x', 'z'], 'factors': [], 're_groups': []}
+        >>> parse_formula_simple("y ~ treatment(group) + x")
+        {'response': 'y', 'continuous': ['x'], 'factors': ['group'], 're_groups': []}
     """
     if "~" not in formula:
         msg = f"Invalid formula: missing '~'. Got: {formula}"
@@ -297,10 +306,10 @@ def parse_formula_simple(formula: str) -> dict[str, Any]:
         msg = f"Invalid formula: empty response variable. Got: {formula}"
         raise ValueError(msg)
 
-    factors = re.findall(r"factor\((\w+)\)", rhs)
+    factors = re.findall(_CONTRAST_FUNC_RE, rhs)
     re_groups = re.findall(r"\([^)]+\|(\w+)\)", rhs)
 
-    cleaned = re.sub(r"factor\(\w+\)", "", rhs)
+    cleaned = re.sub(_CONTRAST_FUNC_RE, "", rhs)
     cleaned = re.sub(r"\([^)]+\|\w+\)", "", cleaned)
 
     all_terms = re.findall(r"\b([a-zA-Z_]\w*)\b", cleaned)

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/builders/state.py

@@ -196,8 +196,8 @@ def build_mee_state(
     focal_var: str,
     mee_type: str,
     *,
-    units: str = "link",
-    weights: str = "equal",
+    how: str = "mem",
+    effect_scale: str = "link",
     L_matrix: np.ndarray | None = None,
     contrast_method: str | None = None,
     n_contrast_levels: int | None = None,
@@ -219,9 +219,11 @@ def build_mee_state(
         explore_formula: The explore formula string.
         focal_var: The primary variable being explored.
         mee_type: Type of effect ("means", "slopes", "contrasts").
-        units: Scale of the estimates: "link" (linear predictor) or "data" (response).
-        weights: Averaging philosophy: ``"equal"`` (balanced reference grid,
-            emmeans-style) or ``"observed"`` (g-computation over observed data).
+        how: Averaging method: ``"mem"`` (Marginal Estimated Mean,
+            balanced reference grid) or ``"ame"`` (Average Marginal
+            Effect, g-computation over observed data).
+        effect_scale: Scale of estimates: ``"link"`` (linear predictor)
+            or ``"response"`` (inverse-link / data scale).
         L_matrix: Design matrix for delta method inference (optional).
             Shape (n_estimates, n_coef). For EMMs this is X_ref.
         contrast_method: Original contrast type for multiplicity adjustment
@@ -260,8 +262,8 @@ def build_mee_state(
         explore_formula=explore_formula,
         focal_var=focal_var,
         type=mee_type,
-        units=units,
-        weights=weights,
+        how=how,
+        effect_scale=effect_scale,
         L_matrix=L_matrix,
         contrast_method=contrast_method,
         n_contrast_levels=n_contrast_levels,

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/schemas.py

@@ -231,6 +231,7 @@ ParamsBoot = Schema(
         Col.CI_UPPER: Float64,
         Col.STATISTIC: Float64,
         Col.DF: Float64,
+        Col.P_VALUE: Float64,
     }
 )
 
@@ -528,7 +529,7 @@ VaryingCorrSchema = Schema(
 # compare() Schemas (rows = models)
 # =============================================================================
 
-# Currently unused — retained as reference schema for AIC-based comparison.
+# AIC-based model comparison (used by compare(method='aic')).
 ComparisonAic = Schema(
     {
         Col.MODEL: String,
@@ -542,7 +543,7 @@ ComparisonAic = Schema(
     }
 )
 
-# Currently unused — retained as reference schema for BIC-based comparison.
+# BIC-based model comparison (used by compare(method='bic')).
 ComparisonBic = Schema(
     {
         Col.MODEL: String,

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/structs/data.py

@@ -171,7 +171,7 @@ class DataBundle:
     X: NDArray[np.floating] = field(validator=is_ndarray)
     y: NDArray[np.floating] = field(validator=is_ndarray)
     X_names: tuple[str, ...] = field(converter=to_tuple)
-    y_name: str
+    y_name: str = field(validator=validators.instance_of(str))
 
     valid_mask: NDArray[np.bool_] = field(validator=is_ndarray)
     n_total: int = field(validator=validators.instance_of(int))

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/structs/display.py

@@ -51,7 +51,12 @@ class MathDisplay:
     """
 
     equation: str = field(validator=validators.instance_of(str))
-    explanations: tuple[str, ...] = field(factory=tuple)
+    explanations: tuple[str, ...] = field(
+        factory=tuple,
+        validator=validators.deep_iterable(
+            member_validator=validators.instance_of(str)
+        ),
+    )
     model_info: str = field(default="", validator=validators.instance_of(str))
 
     def _repr_latex_(self) -> str:

{bossanova-0.1.0.dev16 → bossanova-0.1.0.dev18}/bossanova/internal/containers/structs/explore.py

@@ -109,6 +109,9 @@ class ExploreFormula:
             means use n_levels - 1, i.e., maximum degree).
         contrast_ref: Reference level for treatment/dummy contrasts
             (e.g., ``"Placebo"`` from ``treatment(Drug, ref=Placebo)``).
+        contrast_level_ordering: Explicit level ordering for order-dependent
+            contrasts (helmert, sequential, poly). Parsed from bracket list
+            syntax, e.g. ``poly(dose, [low, med, high])``.
         contrast_expr: Bracket contrast expression AST (e.g., from
             ``Drug[Active - Placebo]`` syntax). None for named contrast
             functions or simple EMMs.
@@ -125,6 +128,7 @@ class ExploreFormula:
     contrast_type: str | None = field(default=None)
     contrast_degree: int | None = field(default=None)
     contrast_ref: str | None = field(default=None)
+    contrast_level_ordering: tuple[str, ...] | None = field(default=None)
     contrast_expr: ContrastExpr | None = field(default=None)
     conditions: tuple[Condition, ...] = field(factory=tuple, converter=tuple)
     focal_at_values: tuple[float | str, ...] | None = field(default=None)