tppis 0.1.0__tar.gz

tppis-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg-info/
+.eggs/
+dist/
+build/
+.venv/
+venv/
+.env
+
+# Tests and typing
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.hypothesis/
+
+# Editors
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Local data caches (real datasets are fetched, not shipped)
+.tppis_data/
+
+# Working notes and paper copies, not part of the library
+discussions/
+research_paper_pdf/
+yet_to_do.md
+test_results/
+tools/
+
+# Simulation outputs
+reproduction/results/*
+!reproduction/results/.gitkeep

tppis-0.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-09-26
+
+### Added
+
+- SIS, FPSIS, FPSIS-BIC, PPIS and TPPIS estimators implementing Tanaka and Matsui (2023).
+- Shared spectral kernel, BIC-type criterion, and joint grid search over `d`, `alpha` and `k`.
+- Simulation generators for the paper's Examples 1 to 4, plus screening metrics.
+- scikit-learn compatible `fit` / `transform` / `get_support` API.
+

tppis-0.1.0/CITATION.cff

@@ -0,0 +1,25 @@
+cff-version: 1.2.0
+title: tppis
+message: If you use this software, please cite both the method paper and this package.
+type: software
+authors:
+  - family-names: M
+    given-names: Mohammed Aswath
+    email: mohammed.aswath07@gmail.com
+repository-code: https://github.com/Mohammed-Aswath/tppis
+license: MIT
+version: 0.1.0
+abstract: >
+  Open-source Python implementation of Truncated Preconditioned Profiled
+  Independence Screening (TPPIS) as specified by Tanaka and Matsui (2023).
+references:
+  - type: article
+    title: Variable screening using factor analysis for high-dimensional data with multicollinearity
+    authors:
+      - family-names: Tanaka
+        given-names: Shuntaro
+      - family-names: Matsui
+        given-names: Hidetoshi
+    year: 2023
+    doi: 10.48550/arXiv.2306.05702
+    url: https://arxiv.org/abs/2306.05702

tppis-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohammed Aswath M
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tppis-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.5
+Name: tppis
+Version: 0.1.0
+Summary: Truncated Preconditioned Profiled Independence Screening for high-dimensional data with multicollinearity.
+Project-URL: Homepage, https://github.com/Mohammed-Aswath/tppis
+Project-URL: Documentation, https://github.com/Mohammed-Aswath/tppis
+Project-URL: Source, https://github.com/Mohammed-Aswath/tppis
+Project-URL: Issues, https://github.com/Mohammed-Aswath/tppis/issues
+Author-email: Mohammed Aswath M <mohammed.aswath07@gmail.com>
+Maintainer-email: Mohammed Aswath M <mohammed.aswath07@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Mohammed Aswath M
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: SIS,TPPIS,factor-analysis,feature-selection,high-dimensional,multicollinearity,variable-screening
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.6
+Requires-Dist: scipy>=1.10
+Provides-Extra: datasets
+Requires-Dist: pandas>=2.0; extra == 'datasets'
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.82; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pandas>=2.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.6; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
+Provides-Extra: repro
+Requires-Dist: joblib>=1.3; extra == 'repro'
+Requires-Dist: matplotlib>=3.7; extra == 'repro'
+Requires-Dist: pandas>=2.0; extra == 'repro'
+Description-Content-Type: text/markdown
+
+# tppis
+
+Open-source Python implementation of **Truncated Preconditioned Profiled Independence Screening** (TPPIS) from Tanaka and Matsui (2023), plus the baselines SIS, FPSIS (and FPSIS-BIC), and PPIS.
+
+The method screens variables in high-dimensional regression when predictors are strongly multicollinear. A factor-analysis transform removes the common factors; TPPIS then *truncates* the tail of that transform so the unique-factor signal is not washed out.
+
+**Maintainer:** [Mohammed Aswath M](https://github.com/Mohammed-Aswath) · [mohammed.aswath07@gmail.com](mailto:mohammed.aswath07@gmail.com) · issues: [github.com/Mohammed-Aswath/tppis](https://github.com/Mohammed-Aswath/tppis/issues)
+
+## Install
+
+```bash
+pip install tppis
+```
+
+The package requires Python 3.10+, NumPy, SciPy, and **scikit-learn 1.6+**.
+
+From a clone of this repository:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+, NumPy, SciPy, and scikit-learn 1.6+.
+
+## Quickstart
+
+```python
+from tppis import TPPIS, make_example1
+
+data = make_example1(n=100, p=80, phi=0.7, seed=0)
+est = TPPIS().fit(data.X, data.y)
+
+est.get_support(indices=True)   # selected columns, ranking order
+est.d_, est.alpha_, est.k_      # BIC-chosen parameters
+est.bic_
+est.grid_                       # every (d, alpha, k, bic) evaluated
+```
+
+Fixed parameters, no search:
+
+```python
+TPPIS(d=20, alpha=0.4, k=10).fit(data.X, data.y)
+```
+
+Inside a scikit-learn pipeline:
+
+```python
+from sklearn.linear_model import LinearRegression
+from sklearn.pipeline import Pipeline
+from tppis import TPPIS
+
+pipe = Pipeline([
+    ("select", TPPIS(d=8, alpha=0.6, k=10)),
+    ("lm", LinearRegression()),
+])
+pipe.fit(data.X, data.y)
+```
+
+The functional entry point `screen(X, y, method="tppis")` returns the same fitted estimator.
+
+## When to use which method
+
+| Method | Transform | How `d` is chosen |
+| --- | --- | --- |
+| SIS | none (`X.T @ y`) | — |
+| FPSIS | project out leading `d` factors | singular-value ratio (3) |
+| FPSIS-BIC | same | BIC grid |
+| PPIS | Puffer whitening of the tail | singular-value ratio (3) |
+| TPPIS | PPIS with the tail truncated at `[n α]` | joint BIC over `d`, `α`, `k` |
+
+TPPIS at `alpha=1` is exactly PPIS. That identity is tested.
+
+## Citation
+
+If you use the method, cite the paper. If you use this software, cite the package as well.
+
+```
+Tanaka, S. and Matsui, H. (2023). Variable screening using factor analysis
+for high-dimensional data with multicollinearity. arXiv:2306.05702.
+```
+
+See [`CITATION.cff`](CITATION.cff).
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

tppis-0.1.0/README.md

@@ -0,0 +1,88 @@
+# tppis
+
+Open-source Python implementation of **Truncated Preconditioned Profiled Independence Screening** (TPPIS) from Tanaka and Matsui (2023), plus the baselines SIS, FPSIS (and FPSIS-BIC), and PPIS.
+
+The method screens variables in high-dimensional regression when predictors are strongly multicollinear. A factor-analysis transform removes the common factors; TPPIS then *truncates* the tail of that transform so the unique-factor signal is not washed out.
+
+**Maintainer:** [Mohammed Aswath M](https://github.com/Mohammed-Aswath) · [mohammed.aswath07@gmail.com](mailto:mohammed.aswath07@gmail.com) · issues: [github.com/Mohammed-Aswath/tppis](https://github.com/Mohammed-Aswath/tppis/issues)
+
+## Install
+
+```bash
+pip install tppis
+```
+
+The package requires Python 3.10+, NumPy, SciPy, and **scikit-learn 1.6+**.
+
+From a clone of this repository:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+, NumPy, SciPy, and scikit-learn 1.6+.
+
+## Quickstart
+
+```python
+from tppis import TPPIS, make_example1
+
+data = make_example1(n=100, p=80, phi=0.7, seed=0)
+est = TPPIS().fit(data.X, data.y)
+
+est.get_support(indices=True)   # selected columns, ranking order
+est.d_, est.alpha_, est.k_      # BIC-chosen parameters
+est.bic_
+est.grid_                       # every (d, alpha, k, bic) evaluated
+```
+
+Fixed parameters, no search:
+
+```python
+TPPIS(d=20, alpha=0.4, k=10).fit(data.X, data.y)
+```
+
+Inside a scikit-learn pipeline:
+
+```python
+from sklearn.linear_model import LinearRegression
+from sklearn.pipeline import Pipeline
+from tppis import TPPIS
+
+pipe = Pipeline([
+    ("select", TPPIS(d=8, alpha=0.6, k=10)),
+    ("lm", LinearRegression()),
+])
+pipe.fit(data.X, data.y)
+```
+
+The functional entry point `screen(X, y, method="tppis")` returns the same fitted estimator.
+
+## When to use which method
+
+| Method | Transform | How `d` is chosen |
+| --- | --- | --- |
+| SIS | none (`X.T @ y`) | — |
+| FPSIS | project out leading `d` factors | singular-value ratio (3) |
+| FPSIS-BIC | same | BIC grid |
+| PPIS | Puffer whitening of the tail | singular-value ratio (3) |
+| TPPIS | PPIS with the tail truncated at `[n α]` | joint BIC over `d`, `α`, `k` |
+
+TPPIS at `alpha=1` is exactly PPIS. That identity is tested.
+
+## Citation
+
+If you use the method, cite the paper. If you use this software, cite the package as well.
+
+```
+Tanaka, S. and Matsui, H. (2023). Variable screening using factor analysis
+for high-dimensional data with multicollinearity. arXiv:2306.05702.
+```
+
+See [`CITATION.cff`](CITATION.cff).
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

tppis-0.1.0/pyproject.toml

@@ -0,0 +1,127 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tppis"
+version = "0.1.0"
+description = "Truncated Preconditioned Profiled Independence Screening for high-dimensional data with multicollinearity."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+authors = [
+    { name = "Mohammed Aswath M", email = "mohammed.aswath07@gmail.com" },
+]
+maintainers = [
+    { name = "Mohammed Aswath M", email = "mohammed.aswath07@gmail.com" },
+]
+keywords = [
+    "feature-selection",
+    "variable-screening",
+    "high-dimensional",
+    "multicollinearity",
+    "factor-analysis",
+    "SIS",
+    "TPPIS",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+dependencies = [
+    "numpy>=1.24",
+    "scipy>=1.10",
+    "scikit-learn>=1.6",
+]
+
+[project.optional-dependencies]
+datasets = [
+    "pandas>=2.0",
+]
+repro = [
+    "pandas>=2.0",
+    "matplotlib>=3.7",
+    "joblib>=1.3",
+]
+dev = [
+    "pytest>=7.4",
+    "pytest-cov>=4.1",
+    "hypothesis>=6.82",
+    "ruff>=0.5",
+    "mypy>=1.8",
+    "pre-commit>=3.6",
+    "pandas>=2.0",
+]
+docs = [
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.24",
+]
+
+[project.urls]
+Homepage = "https://github.com/Mohammed-Aswath/tppis"
+Documentation = "https://github.com/Mohammed-Aswath/tppis"
+Source = "https://github.com/Mohammed-Aswath/tppis"
+Issues = "https://github.com/Mohammed-Aswath/tppis/issues"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/tppis",
+    "/tests",
+    "/README.md",
+    "/LICENSE",
+    "/CHANGELOG.md",
+    "/CITATION.cff",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["tppis"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+src = ["tppis", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+packages = ["tppis"]
+warn_unused_ignores = true
+
+[[tool.mypy.overrides]]
+module = ["sklearn.*", "scipy.*"]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q --strict-markers"
+filterwarnings = [
+    "ignore::UserWarning",
+    "ignore::FutureWarning",
+    "ignore::DeprecationWarning",
+]
+
+[tool.coverage.run]
+source = ["tppis"]
+branch = true
+
+[tool.coverage.report]
+fail_under = 90
+show_missing = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+]

tppis-0.1.0/tests/conftest.py

@@ -0,0 +1,39 @@
+"""Shared fixtures.
+
+Every random draw here is seeded explicitly, so that a failure is reproducible from the
+test name alone.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+
+def multicollinear_design(n_samples, n_features, n_factors=3, seed=0):
+    """A design with a few strong common factors above a noise floor."""
+    rng = np.random.default_rng(seed)
+    Z = rng.standard_normal((n_samples, n_factors))
+    B = rng.standard_normal((n_factors, n_features))
+    return Z @ B + rng.standard_normal((n_samples, n_features))
+
+
+@pytest.fixture
+def small_problem():
+    """A wide, strongly multicollinear problem with a known active set."""
+    rng = np.random.default_rng(11)
+    X = multicollinear_design(40, 120, seed=11)
+    X = (X - X.mean(axis=0)) / X.std(axis=0)
+    y = 5.0 * X[:, 0] - 4.0 * X[:, 1] + 3.0 * X[:, 2] + 0.1 * rng.standard_normal(40)
+    return X, y - y.mean()
+
+
+@pytest.fixture(params=[(20, 60), (30, 30), (40, 15)], ids=["wide", "square", "tall"])
+def shaped_problem(request):
+    """The same problem across the three shape regimes n < p, n == p and n > p."""
+    n_samples, n_features = request.param
+    rng = np.random.default_rng(hash(request.param) % 2**32)
+    X = multicollinear_design(n_samples, n_features, n_factors=2, seed=3)
+    X = (X - X.mean(axis=0)) / X.std(axis=0)
+    y = 4.0 * X[:, 0] - 3.0 * X[:, 1] + 0.2 * rng.standard_normal(n_samples)
+    return X, y - y.mean()

tppis-0.1.0/tests/reference.py

@@ -0,0 +1,103 @@
+"""Literal transcription of equations (4), (6), (7), (8) and (10).
+
+These routines form the explicit n-by-n projection matrices printed in the
+paper. They are the yardstick for the fast path, not a public API.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def svd_parts(
+    X: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:
+    U, mu, Vt = np.linalg.svd(X, full_matrices=False)
+    return U, mu, Vt.T
+
+
+def q_f(U1: NDArray[np.float64]) -> NDArray[np.float64]:
+    """Equation (4): ``Q_F = I - U1 (U1.T U1)^{-1} U1.T``."""
+    n = U1.shape[0]
+    if U1.shape[1] == 0:
+        return np.eye(n)
+    gram = U1.T @ U1
+    return np.eye(n) - U1 @ np.linalg.inv(gram) @ U1.T
+
+
+def q_p(
+    U1: NDArray[np.float64], U2: NDArray[np.float64], mu2: NDArray[np.float64]
+) -> NDArray[np.float64]:
+    """Equation (6) as printed, without an inverse on ``U1.T U1`` (A-3)."""
+    n = U1.shape[0]
+    if U2.shape[1] == 0:
+        return np.zeros((n, n))
+    tail = U2 @ np.diag(1.0 / mu2) @ U2.T
+    if U1.shape[1] == 0:
+        return tail
+    return tail @ (np.eye(n) - U1 @ (U1.T @ U1) @ U1.T)
+
+
+def q_t(
+    U1: NDArray[np.float64], U2a: NDArray[np.float64], mu2a: NDArray[np.float64]
+) -> NDArray[np.float64]:
+    """Equation (7) as printed."""
+    return q_p(U1, U2a, mu2a)
+
+
+def omega_from_q(
+    X: NDArray[np.float64],
+    y: NDArray[np.float64],
+    Q: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """``omega = (Q X).T @ (Q y)``."""
+    X_hat = Q @ X
+    y_hat = Q @ y
+    return X_hat.T @ y_hat
+
+
+def sis_omega(X: NDArray[np.float64], y: NDArray[np.float64]) -> NDArray[np.float64]:
+    return X.T @ y
+
+
+def fpsis_omega(
+    X: NDArray[np.float64],
+    y: NDArray[np.float64],
+    d: int,
+) -> NDArray[np.float64]:
+    U, _mu, _V = svd_parts(X)
+    return omega_from_q(X, y, q_f(U[:, :d]))
+
+
+def ppis_omega(
+    X: NDArray[np.float64],
+    y: NDArray[np.float64],
+    d: int,
+) -> NDArray[np.float64]:
+    U, mu, _V = svd_parts(X)
+    return omega_from_q(X, y, q_p(U[:, :d], U[:, d:], mu[d:]))
+
+
+def tppis_omega(
+    X: NDArray[np.float64],
+    y: NDArray[np.float64],
+    d: int,
+    m: int,
+) -> NDArray[np.float64]:
+    U, mu, _V = svd_parts(X)
+    return omega_from_q(X, y, q_t(U[:, :d], U[:, d:m], mu[d:m]))
+
+
+def refit_beta(
+    X_hat_m: NDArray[np.float64],
+    y_hat: NDArray[np.float64],
+) -> NDArray[np.float64]:
+    """Equation (8): ``beta = (X_hat_M.T X_hat_M)^{-1} X_hat_M.T y_hat``."""
+    gram = X_hat_m.T @ X_hat_m
+    return np.linalg.solve(gram, X_hat_m.T @ y_hat)
+
+
+def bic_paper(rss: float, k: int, n: int, p: int) -> float:
+    """Equation (10): natural log, unnormalized RSS (A-4)."""
+    return float(np.log(rss) + (np.log(p) / n) * k * np.log(n))

tppis-0.1.0/tests/test_criteria.py

@@ -0,0 +1,59 @@
+"""Refit (8), BIC (10), and the analytic check of specification Section 5.1."""
+
+from __future__ import annotations
+
+import numpy as np
+from tppis.criteria import bic_value, incremental_refit
+from tppis.datasets import make_example1
+
+from tests.reference import bic_paper, refit_beta
+
+
+def test_bic_matches_reference_transcription() -> None:
+    got = bic_value(100.0, 4, 100, 1000, kind="paper")
+    assert got == bic_paper(100.0, 4, 100, 1000)
+
+
+def test_section_51_analytic_check() -> None:
+    # RSS ~ n * sigma^2 = 100 at the true model; penalty ~ 1.272; BIC ~ 5.877.
+    value = bic_value(100.0, 4, 100, 1000, kind="paper")
+    assert 5.85 < value < 5.90
+
+
+def test_incremental_matches_direct_solve() -> None:
+    rng = np.random.default_rng(0)
+    n, K, s = 30, 6, 8
+    F = rng.standard_normal((K, s))
+    X_sel = rng.standard_normal((n, K))
+    y = rng.standard_normal(n)
+    rhs = rng.standard_normal(K)
+    sweep = incremental_refit(F, rhs, X_sel, y, p=20, kind="paper")
+    for k in range(1, K + 1):
+        gram = F[:k] @ F[:k].T
+        beta_k = np.linalg.solve(gram, rhs[:k])
+        resid = y - X_sel[:, :k] @ beta_k
+        rss = float(resid @ resid)
+        np.testing.assert_allclose(sweep.rss[k - 1], rss, rtol=1e-10, atol=1e-10)
+        if k == sweep.best_k:
+            np.testing.assert_allclose(sweep.best_beta, beta_k, rtol=1e-10, atol=1e-10)
+
+
+def test_direct_refit_matches_equation_8() -> None:
+    rng = np.random.default_rng(1)
+    n, k = 25, 4
+    X_hat = rng.standard_normal((n, k))
+    y_hat = rng.standard_normal(n)
+    beta = refit_beta(X_hat, y_hat)
+    gram = X_hat.T @ X_hat
+    np.testing.assert_allclose(gram @ beta, X_hat.T @ y_hat, rtol=1e-10, atol=1e-10)
+
+
+def test_example1_true_model_bic_is_near_588() -> None:
+    data = make_example1(n=100, p=80, phi=0.5, seed=0)
+    # Residual of the true four-variable model on this one draw.
+    X4 = data.X[:, :4]
+    beta, *_ = np.linalg.lstsq(X4, data.y, rcond=None)
+    rss = float(np.sum((data.y - X4 @ beta) ** 2))
+    value = bic_value(rss, 4, 100, 80, kind="paper")
+    # One draw, not the expectation: just check the criterion is O(1) not O(10).
+    assert 3.0 < value < 9.0