nullbic 0.1.0__py3-none-win_amd64.whl

nullbic/__init__.py

@@ -0,0 +1,45 @@
+"""nullbic — Symbolic regression with automatic null-baseline ΔBIC.
+
+Find formulas AND prove they're not noise.
+
+Quick start
+-----------
+
+    >>> from nullbic import Dataset, discover
+    >>> ds = Dataset.from_csv("data.csv", target="y")
+    >>> report = discover(ds, n_generations=40)
+    >>> print(report.summary())
+    >>> report.is_real_signal()
+    True
+
+Pandas
+------
+
+    >>> from nullbic import Dataset, discover
+    >>> import pandas as pd
+    >>> df = pd.read_csv("data.csv")
+    >>> ds = Dataset.from_pandas(df, target="y")
+    >>> report = discover(ds)
+
+The report always carries ΔBIC vs F=const, F=linear, and a shuffled-target
+control. Verdict is one of NOISE / WEAK / STRONG.
+"""
+
+from .core import (
+    Dataset,
+    DiscoverConfig,
+    DiscoverReport,
+    Verdict,
+    discover,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Dataset",
+    "DiscoverConfig",
+    "DiscoverReport",
+    "Verdict",
+    "discover",
+    "__version__",
+]

nullbic/_bindings.py

@@ -0,0 +1,119 @@
+"""ctypes bindings to the nullbic Rust DLL. Private — use `nullbic.core` instead."""
+from __future__ import annotations
+
+import ctypes
+import os
+import platform
+import sys
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# DLL location
+# ---------------------------------------------------------------------------
+
+def _find_dll() -> Path:
+    """Locate the bundled DLL/SO/dylib for the current platform."""
+    here = Path(__file__).resolve().parent / "_dll"
+    candidates = []
+    sysname = platform.system()
+    if sysname == "Windows":
+        candidates = ["nullbic.dll"]
+    elif sysname == "Linux":
+        candidates = ["libnullbic.so", "nullbic.so"]
+    elif sysname == "Darwin":
+        candidates = ["libnullbic.dylib", "nullbic.dylib"]
+    for c in candidates:
+        p = here / c
+        if p.exists():
+            return p
+    raise RuntimeError(
+        f"nullbic: no shared library found for {sysname} in {here}. "
+        f"Build the Rust crate and copy the artifact into {here}."
+    )
+
+_DLL_PATH = _find_dll()
+_lib = ctypes.CDLL(str(_DLL_PATH))
+
+
+# ---------------------------------------------------------------------------
+# ctypes signatures
+# ---------------------------------------------------------------------------
+
+# Dataset
+_lib.nullbic_dataset_new.restype = ctypes.c_void_p
+_lib.nullbic_dataset_new.argtypes = [ctypes.c_char_p]
+
+_lib.nullbic_dataset_add_feature.restype = ctypes.c_int
+_lib.nullbic_dataset_add_feature.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+
+_lib.nullbic_dataset_push_row.restype = ctypes.c_int
+_lib.nullbic_dataset_push_row.argtypes = [
+    ctypes.c_void_p,
+    ctypes.POINTER(ctypes.c_double),
+    ctypes.c_double,
+]
+
+_lib.nullbic_dataset_n_rows.restype = ctypes.c_size_t
+_lib.nullbic_dataset_n_rows.argtypes = [ctypes.c_void_p]
+
+_lib.nullbic_dataset_free.argtypes = [ctypes.c_void_p]
+
+# Discover
+_lib.nullbic_discover.restype = ctypes.c_void_p
+_lib.nullbic_discover.argtypes = [
+    ctypes.c_void_p,
+    ctypes.c_uint,
+    ctypes.c_size_t,
+    ctypes.c_uint,
+    ctypes.c_uint64,
+    ctypes.c_double,
+]
+
+# Report accessors
+_lib.nullbic_report_formula.restype = ctypes.c_void_p
+_lib.nullbic_report_formula.argtypes = [ctypes.c_void_p]
+
+_lib.nullbic_report_pretty.restype = ctypes.c_void_p
+_lib.nullbic_report_pretty.argtypes = [ctypes.c_void_p]
+
+_lib.nullbic_report_json.restype = ctypes.c_void_p
+_lib.nullbic_report_json.argtypes = [ctypes.c_void_p]
+
+_lib.nullbic_report_verdict.restype = ctypes.c_int
+_lib.nullbic_report_verdict.argtypes = [ctypes.c_void_p]
+
+for fn in (
+    "nullbic_report_mse_train",
+    "nullbic_report_mse_test",
+    "nullbic_report_bic",
+    "nullbic_report_delta_bic_const",
+    "nullbic_report_delta_bic_linear",
+    "nullbic_report_z_vs_shuffled",
+):
+    f = getattr(_lib, fn)
+    f.restype = ctypes.c_double
+    f.argtypes = [ctypes.c_void_p]
+
+_lib.nullbic_report_free.argtypes = [ctypes.c_void_p]
+_lib.nullbic_string_free.argtypes = [ctypes.c_void_p]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _take_string(ptr: int) -> str:
+    """Copy a Rust-allocated C string into a Python str and free the Rust buf."""
+    if not ptr:
+        return ""
+    s = ctypes.string_at(ptr).decode("utf-8", errors="replace")
+    _lib.nullbic_string_free(ptr)
+    return s
+
+
+def lib():
+    """Return the loaded shared library handle (for advanced/debug use)."""
+    return _lib
+
+
+__all__ = ["lib", "_take_string"]

nullbic/cli.py

@@ -0,0 +1,52 @@
+"""nullbic CLI — `nullbic data.csv target_col`."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .core import Dataset, DiscoverConfig, Verdict, discover
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="nullbic",
+        description="Symbolic regression with auto-falsification ΔBIC.",
+    )
+    p.add_argument("csv", type=Path, help="CSV file with a header row")
+    p.add_argument("target", type=str, help="Name of the column to predict")
+    p.add_argument("--gens", type=int, default=40, dest="n_generations")
+    p.add_argument("--pop", type=int, default=200, dest="pop_size")
+    p.add_argument("--depth", type=int, default=4, dest="max_depth")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--test-frac", type=float, default=0.2, dest="test_frac")
+    p.add_argument("--json", type=Path, default=None, help="Also write JSON report here")
+    args = p.parse_args(argv)
+
+    ds = Dataset.from_csv(args.csv, args.target)
+    sys.stderr.write(
+        f"loaded {len(ds)} rows, {len(ds.feature_names)} features → "
+        f"target '{ds.target_name}'\n"
+    )
+
+    cfg = DiscoverConfig(
+        n_generations=args.n_generations,
+        pop_size=args.pop_size,
+        max_depth=args.max_depth,
+        seed=args.seed,
+        test_frac=args.test_frac,
+    )
+    rep = discover(ds, cfg)
+    print(rep.summary())
+    print(f"\nverdict : {rep.verdict.name}")
+    print(f"n_train = {rep.n_train}  n_test = {rep.n_test}  wall = {rep.wall_clock_ms} ms")
+
+    if args.json:
+        args.json.write_text(rep.raw_json)
+        sys.stderr.write(f"wrote {args.json}\n")
+
+    return 0 if rep.verdict != Verdict.NOISE else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

nullbic/core.py

@@ -0,0 +1,315 @@
+"""Public Python API for nullbic — symbolic regression with auto-falsification."""
+from __future__ import annotations
+
+import ctypes
+import json
+from dataclasses import dataclass, field
+from enum import IntEnum
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Optional, Sequence, Union
+
+from ._bindings import _take_string, lib
+
+_lib = lib()
+
+
+class Verdict(IntEnum):
+    """Falsification verdict assigned to every discovery run."""
+
+    NOISE = 0
+    """Doesn't meaningfully beat F=const or F=linear baselines. Don't trust the formula."""
+
+    WEAK = 1
+    """Beats F=const but not F=linear. The formula adds non-linearity worth a marginal look."""
+
+    STRONG = 2
+    """Beats F=const AND F=linear by ≥10 BIC AND > 2σ below the shuffled-target distribution."""
+
+
+@dataclass
+class DiscoverReport:
+    """One symbolic-regression run with full auto-falsification context."""
+
+    formula: str
+    verdict: Verdict
+    bic: float
+    mse_train: float
+    mse_test: float
+    delta_bic_const: float
+    delta_bic_linear: float
+    z_vs_shuffled: float
+    n_train: int = 0
+    n_test: int = 0
+    wall_clock_ms: int = 0
+    raw_json: str = ""
+
+    def is_real_signal(self) -> bool:
+        """True iff the verdict is STRONG."""
+        return self.verdict == Verdict.STRONG
+
+    def summary(self) -> str:
+        """Compact one-block textual summary."""
+        return (
+            f"formula : {self.formula}\n"
+            f"verdict : {self.verdict.name}\n"
+            f"MSE     : train={self.mse_train:.6g}  test={self.mse_test:.6g}\n"
+            f"BIC     : {self.bic:.2f}\n"
+            f"ΔBIC    : vs const = {self.delta_bic_const:+.2f}   "
+            f"vs linear = {self.delta_bic_linear:+.2f}   "
+            f"z vs shuffled = {self.z_vs_shuffled:+.2f}"
+        )
+
+    def __str__(self) -> str:
+        return self.summary()
+
+
+@dataclass
+class DiscoverConfig:
+    """Knobs for the GA. Defaults are sensible for ≤10k-row tabular data."""
+
+    n_generations: int = 40
+    pop_size: int = 200
+    max_depth: int = 4
+    seed: int = 42
+    test_frac: float = 0.2
+
+
+# ---------------------------------------------------------------------------
+# Dataset wrapper
+# ---------------------------------------------------------------------------
+
+class Dataset:
+    """Rust-backed tabular dataset. Use the `from_*` constructors."""
+
+    def __init__(self, target_name: str):
+        ptr = _lib.nullbic_dataset_new(target_name.encode("utf-8"))
+        if not ptr:
+            raise MemoryError("nullbic_dataset_new returned NULL")
+        self._ptr = ctypes.c_void_p(ptr)
+        self._target_name = target_name
+        self._feature_names: list[str] = []
+
+    def add_feature(self, name: str) -> None:
+        """Register a feature name. Must be called for every column before `push_row`."""
+        rc = _lib.nullbic_dataset_add_feature(self._ptr, name.encode("utf-8"))
+        if rc != 0:
+            raise ValueError(f"could not add feature '{name}'")
+        self._feature_names.append(name)
+
+    def push_row(self, features: Sequence[float], target: float) -> None:
+        """Push one row. `features` order must match `add_feature` order."""
+        if len(features) != len(self._feature_names):
+            raise ValueError(
+                f"row has {len(features)} features, expected {len(self._feature_names)}"
+            )
+        arr = (ctypes.c_double * len(features))(*features)
+        rc = _lib.nullbic_dataset_push_row(self._ptr, arr, float(target))
+        if rc != 0:
+            raise ValueError("nullbic_dataset_push_row failed")
+
+    @property
+    def n_rows(self) -> int:
+        return int(_lib.nullbic_dataset_n_rows(self._ptr))
+
+    @property
+    def feature_names(self) -> list[str]:
+        return list(self._feature_names)
+
+    @property
+    def target_name(self) -> str:
+        return self._target_name
+
+    def __len__(self) -> int:
+        return self.n_rows
+
+    def __repr__(self) -> str:
+        return (
+            f"Dataset(target={self._target_name!r}, n={self.n_rows}, "
+            f"features={self._feature_names})"
+        )
+
+    # ------- constructors -------
+
+    @classmethod
+    def from_records(
+        cls,
+        records: Iterable[Mapping[str, Any]],
+        target: str,
+        feature_names: Optional[Sequence[str]] = None,
+    ) -> "Dataset":
+        """Build from an iterable of dicts. Non-numeric values are dropped."""
+        recs = list(records)
+        if not recs:
+            raise ValueError("empty records")
+        if feature_names is None:
+            keys = list(recs[0].keys())
+            feature_names = [k for k in keys if k != target]
+        ds = cls(target)
+        for f in feature_names:
+            ds.add_feature(f)
+        n_rejected = 0
+        for r in recs:
+            try:
+                t = float(r[target])
+                row = [float(r.get(f, 0.0)) for f in feature_names]
+            except (TypeError, ValueError, KeyError):
+                n_rejected += 1
+                continue
+            ds.push_row(row, t)
+        if ds.n_rows == 0:
+            raise ValueError(f"all {n_rejected} rows rejected (non-numeric data?)")
+        return ds
+
+    @classmethod
+    def from_pandas(cls, df: "pandas.DataFrame", target: str) -> "Dataset":
+        """Build from a pandas DataFrame. Non-numeric columns are skipped."""
+        try:
+            import pandas as pd  # noqa: F401
+        except ImportError as e:
+            raise ImportError("pandas is not installed; `pip install nullbic[pandas]`") from e
+        if target not in df.columns:
+            raise ValueError(f"target column '{target}' not in DataFrame")
+        numeric = df.select_dtypes(include="number").copy()
+        if target not in numeric.columns:
+            raise ValueError(f"target column '{target}' is not numeric")
+        features = [c for c in numeric.columns if c != target]
+        ds = cls(target)
+        for f in features:
+            ds.add_feature(f)
+        for _, row in numeric.iterrows():
+            ds.push_row([float(row[f]) for f in features], float(row[target]))
+        return ds
+
+    @classmethod
+    def from_csv(cls, path: Union[str, Path], target: str) -> "Dataset":
+        """Build from a CSV file. First row must be the header."""
+        path = Path(path)
+        try:
+            import pandas as pd
+            df = pd.read_csv(path)
+            return cls.from_pandas(df, target)
+        except ImportError:
+            pass
+        # Fallback: stdlib csv
+        import csv as _csv
+
+        with open(path, newline="") as fh:
+            reader = _csv.DictReader(fh)
+            rows = list(reader)
+        # Coerce numeric where possible
+        def coerce(v):
+            try:
+                return float(v)
+            except (TypeError, ValueError):
+                return None
+        clean = []
+        for r in rows:
+            r2 = {k: coerce(v) for k, v in r.items()}
+            if r2.get(target) is not None:
+                clean.append({k: (v if v is not None else 0.0) for k, v in r2.items()})
+        feature_names = [k for k in clean[0].keys() if k != target] if clean else []
+        return cls.from_records(clean, target, feature_names)
+
+    # ------- cleanup -------
+
+    def close(self) -> None:
+        if getattr(self, "_ptr", None):
+            _lib.nullbic_dataset_free(self._ptr)
+            self._ptr = ctypes.c_void_p(0)
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_a):
+        self.close()
+
+
+# ---------------------------------------------------------------------------
+# Discover
+# ---------------------------------------------------------------------------
+
+def discover(
+    dataset: Dataset,
+    config: Optional[DiscoverConfig] = None,
+    **kwargs: Any,
+) -> DiscoverReport:
+    """Run symbolic regression with auto-falsification.
+
+    Parameters
+    ----------
+    dataset : Dataset
+        The data to fit.
+    config : DiscoverConfig, optional
+        GA configuration. If None, defaults are used (40 gens, 200 pop, depth 4).
+    **kwargs
+        Override any DiscoverConfig field inline (`seed=7`, `n_generations=100`, etc.).
+
+    Returns
+    -------
+    DiscoverReport
+        Includes formula, verdict, BIC, and all baseline ΔBIC values.
+    """
+    cfg = config or DiscoverConfig()
+    for k, v in kwargs.items():
+        if not hasattr(cfg, k):
+            raise TypeError(f"unknown config field: {k}")
+        setattr(cfg, k, v)
+
+    rep_ptr = _lib.nullbic_discover(
+        dataset._ptr,
+        ctypes.c_uint(cfg.n_generations),
+        ctypes.c_size_t(cfg.pop_size),
+        ctypes.c_uint(cfg.max_depth),
+        ctypes.c_uint64(cfg.seed),
+        ctypes.c_double(cfg.test_frac),
+    )
+    if not rep_ptr:
+        raise RuntimeError("nullbic_discover returned NULL")
+    rep_ptr = ctypes.c_void_p(rep_ptr)
+
+    try:
+        formula = _take_string(_lib.nullbic_report_formula(rep_ptr))
+        raw_json = _take_string(_lib.nullbic_report_json(rep_ptr))
+        verdict = Verdict(_lib.nullbic_report_verdict(rep_ptr))
+        bic = _lib.nullbic_report_bic(rep_ptr)
+        mse_tr = _lib.nullbic_report_mse_train(rep_ptr)
+        mse_te = _lib.nullbic_report_mse_test(rep_ptr)
+        d_const = _lib.nullbic_report_delta_bic_const(rep_ptr)
+        d_lin = _lib.nullbic_report_delta_bic_linear(rep_ptr)
+        z_sh = _lib.nullbic_report_z_vs_shuffled(rep_ptr)
+
+        n_train = n_test = wall = 0
+        if raw_json:
+            try:
+                obj = json.loads(raw_json)
+                n_train = int(obj.get("n_train", 0))
+                n_test = int(obj.get("n_test", 0))
+                wall = int(obj.get("wall_clock_ms", 0))
+            except json.JSONDecodeError:
+                pass
+
+        return DiscoverReport(
+            formula=formula,
+            verdict=verdict,
+            bic=bic,
+            mse_train=mse_tr,
+            mse_test=mse_te,
+            delta_bic_const=d_const,
+            delta_bic_linear=d_lin,
+            z_vs_shuffled=z_sh,
+            n_train=n_train,
+            n_test=n_test,
+            wall_clock_ms=wall,
+            raw_json=raw_json,
+        )
+    finally:
+        _lib.nullbic_report_free(rep_ptr)
+
+
+__all__ = ["Dataset", "DiscoverConfig", "DiscoverReport", "Verdict", "discover"]

nullbic-0.1.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: nullbic
+Version: 0.1.0
+Summary: Symbolic regression with automatic null-baseline ΔBIC. Find formulas AND prove they're not noise.
+Author: nullbic contributors
+License: MIT
+Project-URL: Homepage, https://github.com/glogwa68/nullbic
+Project-URL: Repository, https://github.com/glogwa68/nullbic
+Project-URL: Issues, https://github.com/glogwa68/nullbic/issues
+Keywords: symbolic-regression,machine-learning,interpretability,BIC,auto-falsification
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3; extra == "pandas"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pandas>=1.3; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# nullbic
+
+**Symbolic regression with automatic null-baseline ΔBIC.**
+Find formulas AND prove they're not noise.
+
+```python
+from nullbic import Dataset, discover
+
+ds = Dataset.from_csv("data.csv", target="y")
+report = discover(ds, n_generations=40)
+
+print(report.summary())
+print("real signal?", report.is_real_signal())
+```
+
+## Why this exists
+
+Existing symbolic-regression tools (PySR, Eureqa, `gplearn`,
+`SymbolicRegression.jl`) all give you a formula. **None of them, by default,
+tell you whether that formula meaningfully beats a constant model or a
+trivial linear fit.** Most "discoveries" published with these tools are
+indistinguishable from noise, and the user has no easy way to tell.
+
+`nullbic` ships those baselines as a first-class output:
+
+- **ΔBIC vs F = const** (the mean predictor)
+- **ΔBIC vs F = linear** (best OLS on all features)
+- **z-score vs shuffled-target distribution** (30 shuffles by default)
+- **`Verdict.STRONG` / `WEAK` / `NOISE`** assigned automatically
+
+If the discovered formula doesn't beat all three baselines, the verdict
+downgrades. No silent overfit.
+
+## Install
+
+```bash
+git clone https://github.com/yourname/nullbic
+cd nullbic
+pip install -e .
+# optional: pandas integration
+pip install -e ".[pandas]"
+```
+
+The Rust core ships as a pre-built shared library inside the package
+(`nullbic/_dll/nullbic.dll` on Windows; `.so` / `.dylib` on Linux / macOS).
+No Rust toolchain needed at install time.
+
+## Usage
+
+### From a pandas DataFrame
+
+```python
+import pandas as pd
+from nullbic import Dataset, discover
+
+df = pd.read_csv("merge_results.csv")
+ds = Dataset.from_pandas(df, target="cosine_sim")
+rep = discover(ds, n_generations=40, pop_size=200, max_depth=4)
+
+if rep.is_real_signal():
+    print("Formula:", rep.formula)
+    print(f"ΔBIC vs const : {rep.delta_bic_const:+.1f}")
+    print(f"ΔBIC vs linear: {rep.delta_bic_linear:+.1f}")
+    print(f"z vs shuffled : {rep.z_vs_shuffled:+.2f}")
+```
+
+### From a CSV
+
+```python
+from nullbic import Dataset, discover
+
+ds = Dataset.from_csv("data.csv", target="y")
+print(discover(ds).summary())
+```
+
+### From a CLI
+
+```bash
+nullbic data.csv y --gens=40 --pop=200 --depth=4
+```
+
+Exit code is `0` if the verdict is `STRONG` or `WEAK`, `1` if `NOISE` —
+handy in CI/CD signal-validation pipelines.
+
+## Three real use cases
+
+### 1. Kaggle / tabular insight
+
+Point at any cleaned dataset. Get a formula. **Get the proof it's not in
+the noise.**
+
+### 2. Black-box surrogate
+
+Approximate an XGBoost / NN model with a symbolic surrogate; the verdict
+tells you when the surrogate is meaningful vs cosmetic.
+
+### 3. Empirical-law audit
+
+Feed in a paper's claimed empirical relationship. The verdict says whether
+the relationship really beats a linear baseline on the given data.
+
+## How the verdict is assigned
+
+| Verdict | Criteria |
+|---------|----------|
+| `STRONG`  | ΔBIC vs const < −10  **AND**  ΔBIC vs linear < −10  **AND**  z vs shuffled < −2 |
+| `WEAK`    | Beats const but not all three thresholds |
+| `NOISE`   | Doesn't beat const → formula is not extracting any signal |
+
+These thresholds match standard model-selection conventions (Kass &
+Raftery 1995 / Schwarz 1978).
+
+## Architecture
+
+```
+nullbic (Python package)
+  └── core.py             → public API (Dataset, discover, …)
+  └── _bindings.py        → ctypes layer (private)
+  └── _dll/nullbic.dll    → Rust shared library (pre-built)
+
+nullbic-core (Rust crate, ~600 LOC)
+  └── dataset             → tabular rows + train/test split + shuffled
+  └── expr                → expression trees over named features
+  └── optimizer           → single-level GA, niching, hyper-mutation
+  └── baselines           → F=const + F=linear (OLS) + shuffled-target
+  └── c_api               → extern "C" entry points
+```
+
+## Performance
+
+Typical run on 500 rows × 10 features, 40 generations, pop 200:
+
+- ~30–80 ms wall-clock on one core
+- ~150 MB peak RAM
+- Deterministic for a given seed
+
+The GA is parallel via Rayon; throughput scales near-linearly with cores.
+
+## Limitations and honest caveats
+
+- The GA is intentionally simple. PySR is more sophisticated when raw
+  accuracy is the only goal. **`nullbic` trades a few percent of accuracy
+  for the auto-falsification report.**
+- The "linear baseline" is plain OLS with a tiny ridge for numerical
+  safety; it's not feature-engineered. If you're comparing to a serious
+  linear model, replace `delta_bic_linear` with your own ΔBIC.
+- 580 rows is comfortable. Below ~50 rows, results are unreliable — the
+  shuffled-target distribution is too noisy to anchor the z-score.
+
+## License
+
+MIT. See `LICENSE`.
+
+## Citation
+
+If `nullbic` contributes to a paper, please cite it as:
+
+> nullbic: symbolic regression with auto-falsification ΔBIC. 2026.
+
+## Related
+
+- [PySR](https://github.com/MilesCranmer/PySR) — sophisticated symbolic regression
+- [gplearn](https://gplearn.readthedocs.io/) — sklearn-compatible GP
+- [SymbolicRegression.jl](https://github.com/MilesCranmer/SymbolicRegression.jl) — Julia

nullbic-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+nullbic/__init__.py,sha256=epkVh-RseHaD02R3JvqtbYUEqWhcA9iA2wUD8cpcOus,949
+nullbic/_bindings.py,sha256=jkgDS8p51G1gK4qcTPBpUoIZaXqr2wFbilCVDOdXV0c,3566
+nullbic/cli.py,sha256=MG9iOQHm60uxfVVaFsRXksY9fPDRsPHbsBLSV_hnzqs,1797
+nullbic/core.py,sha256=RrxLTfg9gfSQ4oBnHpqKgjiQtCh2_n2wDJFVqJosF1c,10344
+nullbic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nullbic/_dll/nullbic.dll,sha256=Fh6oDvDamhuh_1NNkgsufy3EKy2XU_Jebgnu_hvzjMk,1670041
+nullbic-0.1.0.dist-info/licenses/LICENSE,sha256=_ZS3-iHxrwL9N6dVMm1NRwTmIQs4xxM7GaK2UZYaNlc,1077
+nullbic-0.1.0.dist-info/METADATA,sha256=5Ql_iR7-kqJdTAi6oQU5O33V3wETxYYewOBPvaxNzJE,6672
+nullbic-0.1.0.dist-info/WHEEL,sha256=QR8DNjG6Lr6bNErJWJgF4dP2dJ2N7NpY-BWly1OvcTM,97
+nullbic-0.1.0.dist-info/entry_points.txt,sha256=WcH5B4HG89HHz-8FSz5J6tT6Y_nHfWXjm_4zc73aGb8,45
+nullbic-0.1.0.dist-info/top_level.txt,sha256=uU9_0EFoX7A_k1SXyug-1dovYwz5085UWdiOITgTYLc,8
+nullbic-0.1.0.dist-info/RECORD,,

nullbic-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

nullbic-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nullbic = nullbic.cli:main

nullbic-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nullbic contributors
+
+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.

nullbic-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nullbic