alphatonic 0.1.1__py3-none-any.whl

alphatonic/__init__.py

@@ -0,0 +1,41 @@
+"""Evaluate predictive signals with information coefficients you can trust.
+
+Pass a factor (scores) and prices to [`evaluate`][alphatonic.evaluate] to measure how well the
+scores rank assets at each timestamp (cross-sectional IC) and predict each asset's own returns
+over time (time-series IC), with Newey-West and block-bootstrap uncertainty, explicit reasons
+for every undefined statistic, and an offline HTML tearsheet.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from alphatonic.config import EvaluationConfig, PersistenceOptions, ReportOptions, TimeSeriesOptions
+from alphatonic.evaluation import Evaluation, evaluate
+from alphatonic.returns import bar_volatility, forward_returns
+from alphatonic.signal_persistence import PersistenceEvaluation
+from alphatonic.stats import summarize_ic
+from alphatonic.study import HoldoutError, Study, Trial, UnknownTrialError
+from alphatonic.time_series import TimeSeriesEvaluation
+
+try:
+    __version__ = version("alphatonic")
+except PackageNotFoundError:  # pragma: no cover - running from an unbuilt source tree
+    __version__ = "0+unknown"
+
+__all__ = [
+    "Evaluation",
+    "EvaluationConfig",
+    "HoldoutError",
+    "PersistenceEvaluation",
+    "PersistenceOptions",
+    "ReportOptions",
+    "Study",
+    "TimeSeriesEvaluation",
+    "TimeSeriesOptions",
+    "Trial",
+    "UnknownTrialError",
+    "__version__",
+    "bar_volatility",
+    "evaluate",
+    "forward_returns",
+    "summarize_ic",
+]

alphatonic/__main__.py

@@ -0,0 +1,5 @@
+"""Run the `alphatonic` command: `python -m alphatonic list <directory>`."""
+
+from alphatonic.cli import main
+
+raise SystemExit(main())

alphatonic/cli.py

@@ -0,0 +1,80 @@
+"""The `alphatonic` command: list the trials of a study, or serve them as a web page.
+
+    alphatonic list research --sort adjusted_p
+    alphatonic serve research --port 8000
+
+`python -m alphatonic` runs the same command.
+"""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from pathlib import Path
+
+import pandas as pd
+
+from alphatonic.study import Study
+
+_LISTED = ("signal", "sample", "cs_ic", "cs_z", "adjusted_p", "ts_ic", "trials")
+"""Board columns `alphatonic list` prints, after the identifier."""
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the command with `argv`, or with the process's arguments, and return its exit status."""
+    parser = _parser()
+    arguments = parser.parse_args(argv)
+    study = Study(arguments.directory, name=getattr(arguments, "name", None))
+    if arguments.command == "list":
+        try:
+            board = study.board(
+                arguments.horizon, sort=arguments.sort, descending=arguments.descending
+            )
+        except ValueError as error:
+            parser.error(str(error))
+        print(_table(board.head(arguments.limit), study))
+        unreadable = study.unreadable()
+        if unreadable:
+            print(f"{len(unreadable)} records could not be read: {', '.join(map(str, unreadable))}")
+        return 0
+    from alphatonic.server import serve
+
+    print(f"Serving {study.directory} on http://{arguments.host}:{arguments.port}", flush=True)
+    serve(study, arguments.host, arguments.port)
+    return 0
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="alphatonic", description="List or serve the trials of a study."
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    listing = commands.add_parser("list", help="Print the trials, sorted by a board column.")
+    listing.add_argument("directory", type=Path, help="The study's directory.")
+    listing.add_argument("--horizon", type=int, help="Horizon in bars; default: the smallest.")
+    listing.add_argument("--sort", help="Board column to sort by, such as adjusted_p.")
+    direction = listing.add_mutually_exclusive_group()
+    direction.add_argument("--ascending", dest="descending", action="store_false")
+    direction.add_argument("--descending", dest="descending", action="store_true")
+    listing.set_defaults(descending=None)
+    listing.add_argument("--limit", type=int, default=20, help="Rows to print (default 20).")
+
+    serving = commands.add_parser("serve", help="Serve the trials as a sortable web page.")
+    serving.add_argument("directory", type=Path, help="The study's directory.")
+    serving.add_argument("--host", default="127.0.0.1", help="Address (default 127.0.0.1).")
+    serving.add_argument("--port", type=int, default=8000, help="Port (default 8000).")
+    serving.add_argument("--name", help="The project's name, shown in the page's title.")
+    return parser
+
+
+def _table(board: pd.DataFrame, study: Study) -> str:
+    """The listed columns as text, numbers to four decimals and an en dash where undefined."""
+    if board.empty:
+        return f"No trials in {study.directory}."
+    horizon = int(board["horizon"].iloc[0])
+    table = board[list(_LISTED)].to_string(float_format=lambda value: f"{value:.4f}", na_rep="–")
+    return f"Horizon: {horizon} bar{'' if horizon == 1 else 's'}\n{table}"
+
+
+__all__ = ["main"]

alphatonic/config.py

@@ -0,0 +1,240 @@
+"""Validated options for an evaluation and for its tearsheet."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Annotated, Any, Literal, Self
+
+import pandas as pd
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, field_validator, model_validator
+
+Target = Literal["return", "vol_scaled"]
+"""What scores are correlated with: the forward return, or the forward return divided by the
+asset's ex-ante volatility over the horizon."""
+
+METHODS = ("spearman", "pearson")
+"""Correlation methods of the cross-sectional evaluation."""
+
+TS_METHODS = ("spearman", "pearson", "cosine")
+"""Correlation methods of the time-series evaluation. `cosine` is the uncentred correlation."""
+
+
+def _reject_bool(value: Any) -> Any:
+    # Lax ints accept strings such as "3" but would also turn True into 1.
+    if isinstance(value, bool):
+        raise ValueError("expected an integer, not a boolean")
+    return value
+
+
+PositiveInt = Annotated[int, Field(gt=0), BeforeValidator(_reject_bool)]
+
+_RELAXED_WINDOWS: dict[str, Any] = {
+    "min_pairs": 15,
+    "min_horizons": 3,
+    "rolling_window": "90D",
+    "rolling_step": "5D",
+}
+"""Time-series windows for bars too long for the defaults, such as 12-hour or daily bars."""
+
+
+def _duration(value: Any) -> str:
+    """Validate a fixed calendar duration such as `7D` or `12h` and return it as text."""
+    text = value if isinstance(value, str) else str(pd.Timedelta(value))
+    try:
+        duration = pd.Timedelta(text)
+    except ValueError as error:
+        raise ValueError(f"{text!r} is not a duration such as 7D or 12h") from error
+    if pd.isna(duration) or duration <= pd.Timedelta(0):
+        raise ValueError("must be a positive fixed duration, such as 7D")
+    return text
+
+
+def _utc(value: Any) -> datetime | None:
+    """Read a timestamp; naive values are UTC, aware values are converted to UTC."""
+    if value is None:
+        return None
+    stamp = pd.Timestamp(value)
+    if pd.isna(stamp):
+        raise ValueError("expected a timestamp, not NaT")
+    stamp = stamp.tz_localize("UTC") if stamp.tzinfo is None else stamp.tz_convert("UTC")
+    return stamp.to_pydatetime()
+
+
+class TimeSeriesOptions(BaseModel):
+    """Eligibility rules, windows and bootstrap settings for time-series IC.
+
+    The eligibility values are sample-size heuristics, not significance thresholds.
+    """
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    target: Target = "vol_scaled"
+    """Label of the time-series IC: `vol_scaled` divides each forward return by the asset's
+    ex-ante volatility over the horizon, so periods count by risk rather than by size; `return`
+    uses the forward return as it is."""
+
+    min_pairs: int = Field(default=100, ge=3)
+    """Finite score/return pairs a window needs before an asset's IC is computed."""
+
+    min_coverage: float = Field(default=0.8, gt=0, le=1)
+    """Fraction of a window's eligible bars that must contribute a finite pair."""
+
+    min_horizons: PositiveInt = 20
+    """Minimum window length, in multiples of the return horizon."""
+
+    min_months: int = Field(default=6, ge=2)
+    """Complete, valid calendar months needed for a monthly ICIR."""
+
+    rolling_window: str = "30D"
+    """Trailing window of the rolling TS IC, as a fixed duration such as `30D`."""
+
+    rolling_step: str = "1D"
+    """Spacing of rolling window endpoints, as a fixed duration."""
+
+    bootstrap_samples: int = Field(default=1000, ge=0)
+    """Circular block-bootstrap draws for confidence intervals; `0` disables them."""
+
+    block_bars: PositiveInt | None = None
+    """Bootstrap block length in bars. Default: `max(horizon, ceil(n ** (1/3)))`."""
+
+    seed: int = Field(default=0, ge=0)
+    """Seed of the bootstrap random number generator."""
+
+    @field_validator("rolling_window", "rolling_step", mode="before")
+    @classmethod
+    def _validate_duration(cls, value: Any) -> str:
+        return _duration(value)
+
+    @field_validator("bootstrap_samples")
+    @classmethod
+    def _validate_samples(cls, value: int) -> int:
+        if 0 < value < 100:
+            raise ValueError("bootstrap_samples must be zero (disabled) or at least 100")
+        return value
+
+    @classmethod
+    def for_bars(cls, bar: str | timedelta, **overrides: Any) -> Self:
+        """Return options whose windows suit bars of length `bar`, with `overrides` applied.
+
+        The defaults are kept while their 30-day rolling window holds enough bars for 100 pairs
+        at 80% coverage: bars of 5 hours 45 minutes or shorter. Longer bars, such as 12-hour or
+        daily ones, get relaxed windows: 15 pairs, 3 horizons, and a 90-day rolling window moved
+        in 5-day steps. Relaxed windows buy availability, not accuracy: a monthly IC from 15
+        pairs is noisy. With weekly or longer bars even these windows are mostly too short; rely
+        on the full-period IC and its bootstrap interval.
+
+        Args:
+            bar: Spacing of the price table's rows, such as `"1h"`, `"1D"` or a `timedelta`.
+            **overrides: Options that replace the preset's values, such as `bootstrap_samples`.
+
+        Returns:
+            Ordinary `TimeSeriesOptions`, saved with an evaluation like any others.
+
+        Raises:
+            ValueError: If `bar` is not a positive fixed duration, or an override is invalid.
+        """
+        duration = pd.Timedelta(_duration(bar))
+        defaults = cls.model_fields
+        window = pd.Timedelta(defaults["rolling_window"].default)
+        needed = defaults["min_pairs"].default / defaults["min_coverage"].default
+        preset = {} if window / duration >= needed else _RELAXED_WINDOWS
+        return cls(**{**preset, **overrides})
+
+
+class PersistenceOptions(BaseModel):
+    """Signal diagnostics on the original bar grid, independent of return horizons."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    lags: Annotated[tuple[PositiveInt, ...], Field(min_length=1)] = (1, 5, 10)
+    """Endpoint comparison distances in bars; never interpreted as holding periods."""
+
+    min_pairs: int = Field(default=2, ge=1)
+    """Valid endpoint pairs required for each asset's descriptive statistics."""
+
+    @field_validator("lags")
+    @classmethod
+    def _unique_lags(cls, value: tuple[int, ...]) -> tuple[int, ...]:
+        if len(set(value)) != len(value):
+            raise ValueError("lags must be unique")
+        return value
+
+
+class ReportOptions(BaseModel):
+    """Display options of the cross-sectional charts in a tearsheet."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    rolling_window: str = "7D"
+    """Trailing window of the rolling mean of cross-sectional IC, as a fixed duration."""
+
+    min_periods: PositiveInt = 3
+    """Valid IC observations a rolling window needs to draw its mean."""
+
+    @field_validator("rolling_window", mode="before")
+    @classmethod
+    def _validate_window(cls, value: Any) -> str:
+        return _duration(value)
+
+
+class EvaluationConfig(BaseModel):
+    """What to evaluate: horizons, eligibility rules and the evaluation window.
+
+    Every field has a default, so `EvaluationConfig()` is a valid configuration. The object is
+    immutable; use `model_copy(update=...)` to derive a variant.
+    """
+
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+    horizons: Annotated[tuple[PositiveInt, ...], Field(min_length=1)] = (1, 5, 10)
+    """Forward-return horizons in bars (rows of the price table)."""
+
+    min_assets: int = Field(default=5, ge=3)
+    """Finite score/return pairs a timestamp needs for a cross-sectional IC."""
+
+    delay: int = Field(default=0, ge=0)
+    """Extra bars between the observation and the start of the return it is scored against."""
+
+    quantiles: int = Field(default=5, ge=2)
+    """Number of score buckets in the quantile response tables."""
+
+    hac_lags: int | None = Field(default=None, ge=0)
+    """Newey-West lags for the cross-sectional mean IC. At least `horizon - 1` are always used.
+    Default: `floor(4 * (n / 100) ** (2 / 9))`."""
+
+    target: Target = "return"
+    """Label of the cross-sectional IC: the forward `return`, or `vol_scaled`, the forward return
+    divided by the asset's ex-ante volatility over the horizon (a risk-adjusted IC). The
+    time-series evaluation has its own `time_series.target`."""
+
+    vol_span: int = Field(default=60, ge=2)
+    """Span, in bars, of the exponentially weighted volatility behind `vol_scaled` targets."""
+
+    vol_min_bars: int = Field(default=20, ge=2)
+    """One-bar returns the volatility estimate needs before it is used."""
+
+    start: datetime | None = None
+    """First evaluation timestamp (inclusive, UTC). Default: the first timestamp with a score."""
+
+    end: datetime | None = None
+    """End of the evaluation window (exclusive, UTC). Prices at or after it are ignored, and a
+    label must end before it. Default: one bar after the last price."""
+
+    persistence: PersistenceOptions = Field(default_factory=PersistenceOptions)
+    """Signal persistence diagnostics; computed without future-return labels."""
+
+    time_series: TimeSeriesOptions = Field(default_factory=TimeSeriesOptions)
+    """Options of the time-series evaluation."""
+
+    @field_validator("start", "end", mode="before")
+    @classmethod
+    def _validate_bound(cls, value: Any) -> datetime | None:
+        return _utc(value)
+
+    @model_validator(mode="after")
+    def _validate_window(self) -> Self:
+        if self.start is not None and self.end is not None and self.end <= self.start:
+            raise ValueError("end must be after start")
+        if len(set(self.horizons)) != len(self.horizons):
+            raise ValueError("horizons must be unique")
+        return self

alphatonic/cross_section.py

@@ -0,0 +1,177 @@
+"""Cross-sectional IC: how well scores rank assets at the same timestamp."""
+
+from __future__ import annotations
+
+from typing import cast
+
+import numpy as np
+import pandas as pd
+
+from alphatonic.config import METHODS, EvaluationConfig
+from alphatonic.progress import ProgressFactory, silent
+from alphatonic.stats import BLOCK_ROWS, bucket_means, row_correlations, summarize_ic
+
+PERIOD_COLUMNS = [
+    "timestamp",
+    "horizon",
+    "spearman",
+    "pearson",
+    "n_available",
+    "n_signal",
+    "n_pairs",
+    "pair_coverage",
+    "status",
+]
+
+
+def cross_sectional_ic(
+    factor: pd.DataFrame,
+    labels: dict[int, pd.DataFrame],
+    prices: pd.DataFrame,
+    config: EvaluationConfig,
+    progress: ProgressFactory = silent,
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """Compute the IC at every timestamp and horizon, then summarize it per horizon.
+
+    All three frames share the evaluation grid of `factor`; `labels` holds each horizon's
+    forward returns and `prices` the prices that decide how many assets are available.
+
+    Returns:
+        `(periods, summary, quantiles)`: one row per timestamp and horizon with both
+        correlations, pair counts and a status; one row per horizon and method with mean, HAC
+        inference and counts; and the mean return of each score bucket per valid timestamp.
+    """
+    available = prices.notna().sum(axis=1).to_numpy()
+    scored = factor.notna().sum(axis=1).to_numpy()
+    timestamps = cast(pd.DatetimeIndex, factor.index).as_unit("ns")
+    scores = factor.to_numpy(dtype=float)
+    columns: dict[str, list[np.ndarray]] = {name: [] for name in PERIOD_COLUMNS}
+    buckets: list[dict] = []
+    with progress("Evaluating IC", len(config.horizons)) as advance:
+        for horizon in config.horizons:
+            advance(0, description=f"Evaluating IC · h{horizon}")
+            period, bucket = _horizon_periods(scores, labels[horizon].to_numpy(dtype=float), config)
+            with np.errstate(divide="ignore", invalid="ignore"):
+                coverage = np.where(available > 0, period["n_pairs"] / available, np.nan)
+            rows = len(timestamps)
+            for name, values in {
+                "timestamp": timestamps.view("int64"),
+                "horizon": np.full(rows, horizon),
+                "spearman": period["spearman"],
+                "pearson": period["pearson"],
+                "n_available": available,
+                "n_signal": scored,
+                "n_pairs": period["n_pairs"],
+                "pair_coverage": coverage,
+                "status": period["status"],
+            }.items():
+                columns[name].append(values)
+            buckets.append({**bucket, "horizon": horizon})
+            advance()
+    periods = pd.DataFrame({name: np.concatenate(parts) for name, parts in columns.items()})
+    periods["timestamp"] = pd.DatetimeIndex(periods["timestamp"].astype("int64"), tz="UTC")
+    return (
+        periods,
+        _summarize(periods, config),
+        _bucket_frame(buckets, timestamps, config.quantiles),
+    )
+
+
+def _horizon_periods(
+    scores: np.ndarray, targets: np.ndarray, config: EvaluationConfig
+) -> tuple[dict, dict]:
+    rows = len(scores)
+    valid = np.isfinite(scores) & np.isfinite(targets)
+    pairs = valid.sum(axis=1)
+    spearman = np.full(rows, np.nan)
+    pearson = np.full(rows, np.nan)
+    status = np.full(rows, "insufficient_assets", dtype=object)
+    bucket = {"rows": np.empty(0, dtype=int), "means": None, "counts": None}
+    eligible = np.flatnonzero(pairs >= config.min_assets)
+    done, means, counts = [], [], []
+    for start in range(0, len(eligible), BLOCK_ROWS):
+        block = eligible[start : start + BLOCK_ROWS]
+        x = np.where(valid[block], scores[block], np.nan)
+        y = np.where(valid[block], targets[block], np.nan)
+        constant_x = ~(np.nanmax(x, axis=1) > np.nanmin(x, axis=1))
+        constant_y = ~(np.nanmax(y, axis=1) > np.nanmin(y, axis=1))
+        status[block[constant_x]] = "constant_signal"
+        status[block[~constant_x & constant_y]] = "constant_returns"
+        ok = ~constant_x & ~constant_y
+        rows_ok = block[ok]
+        if not len(rows_ok):
+            continue
+        status[rows_ok] = "valid"
+        spearman[rows_ok] = row_correlations(x[ok], y[ok], "spearman")
+        pearson[rows_ok] = row_correlations(x[ok], y[ok], "pearson")
+        block_means, block_counts, _ = bucket_means(x[ok], y[ok], config.quantiles)
+        done.append(rows_ok)
+        means.append(block_means)
+        counts.append(block_counts)
+    if done:
+        bucket = {
+            "rows": np.concatenate(done),
+            "means": np.concatenate(means),
+            "counts": np.concatenate(counts),
+        }
+    period = {"spearman": spearman, "pearson": pearson, "n_pairs": pairs, "status": status}
+    return period, bucket
+
+
+def _bucket_frame(
+    buckets: list[dict], timestamps: pd.DatetimeIndex, quantiles: int
+) -> pd.DataFrame:
+    """Stack the score-bucket means of every horizon into one table."""
+    parts = [(b, b["rows"]) for b in buckets if len(b["rows"])]
+    if not parts:
+        return pd.DataFrame(
+            {
+                "timestamp": pd.DatetimeIndex([], tz="UTC"),
+                "horizon": np.empty(0, dtype=int),
+                "quantile": np.empty(0, dtype=int),
+                "mean_return": np.empty(0),
+                "n_pairs": np.empty(0, dtype=int),
+            }
+        )
+    frame = pd.DataFrame(
+        {
+            "timestamp": np.concatenate(
+                [np.repeat(timestamps.view("int64")[rows], quantiles) for _, rows in parts]
+            ),
+            "horizon": np.concatenate(
+                [np.full(len(rows) * quantiles, b["horizon"]) for b, rows in parts]
+            ),
+            "quantile": np.concatenate(
+                [np.tile(np.arange(1, quantiles + 1), len(rows)) for _, rows in parts]
+            ),
+            "mean_return": np.concatenate([b["means"].ravel() for b, _ in parts]),
+            "n_pairs": np.concatenate([b["counts"].ravel() for b, _ in parts]),
+        }
+    )
+    frame["timestamp"] = pd.DatetimeIndex(frame["timestamp"].astype("int64"), tz="UTC")
+    return frame
+
+
+def _summarize(periods: pd.DataFrame, config: EvaluationConfig) -> pd.DataFrame:
+    summaries = []
+    for horizon, group in periods.groupby("horizon", sort=True):
+        horizon = cast(int, horizon)
+        for method in METHODS:
+            series = group[method]
+            n = int(series.notna().sum())
+            automatic = int(np.floor(4 * (n / 100) ** (2 / 9))) if n else 0
+            lags = max(
+                int(horizon) - 1, config.hac_lags if config.hac_lags is not None else automatic
+            )
+            summaries.append(
+                {
+                    "horizon": horizon,
+                    "method": method,
+                    "total_periods": len(group),
+                    "skipped_periods": int(series.isna().sum()),
+                    "mean_pair_coverage": float(group["pair_coverage"].mean()),
+                    "mean_n_pairs": float(group["n_pairs"].mean()),
+                    **summarize_ic(series, lags),
+                }
+            )
+    return pd.DataFrame(summaries)

alphatonic/demo.py

@@ -0,0 +1,62 @@
+"""Synthetic data for tutorials, tests and trying the library without a data vendor."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+
+def synthetic_market(
+    n_assets: int = 50,
+    n_bars: int = 500,
+    *,
+    freq: str = "B",
+    start: str = "2020-01-01",
+    ic: float = 0.05,
+    persistence: float = 0.9,
+    missing_fraction: float = 0.0,
+    seed: int = 0,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Simulate prices and a factor that predicts their next-bar returns.
+
+    Each asset has a latent score that evolves as an AR(1) process with unit variance. The return
+    over the next bar is a fixed multiple of the score plus independent noise, scaled so that the
+    population correlation between the score and the next-bar return is `ic`. Longer horizons
+    inherit part of that relationship through `persistence`. Prices are positive and
+    start at 100.
+
+    Args:
+        n_assets: Number of assets.
+        n_bars: Number of bars (rows).
+        freq: A pandas frequency alias for the bars, such as `B` (business days), `D` or `h`.
+        start: First timestamp. The index is timezone-naive.
+        ic: Target correlation between the score and the next-bar return, in `[0, 1)`.
+        persistence: Autocorrelation of each asset's score from one bar to the next, in `[0, 1)`.
+        missing_fraction: Fraction of prices set to `NaN` at random.
+        seed: Seed of the random number generator.
+
+    Returns:
+        `(factor, prices)`: two tables of the same shape, indexed by timestamp, with the assets
+        `A000`, `A001`, ... as columns.
+    """
+    if not 0 <= ic < 1 or not 0 <= persistence < 1 or not 0 <= missing_fraction < 1:
+        raise ValueError("ic, persistence and missing_fraction must be in [0, 1)")
+    rng = np.random.default_rng(seed)
+    index = pd.date_range(start, periods=n_bars, freq=freq)
+    columns = [f"A{i:03d}" for i in range(n_assets)]
+    score = np.empty((n_bars, n_assets))
+    score[0] = rng.normal(size=n_assets)
+    shocks = rng.normal(size=(n_bars, n_assets)) * np.sqrt(1 - persistence**2)
+    for t in range(1, n_bars):
+        score[t] = persistence * score[t - 1] + shocks[t]
+    slope = ic / np.sqrt(1 - ic**2)
+    noise = rng.normal(size=(n_bars, n_assets))
+    returns = np.zeros((n_bars, n_assets))
+    returns[1:] = 0.01 * (slope * score[:-1] + noise[1:])
+    prices = 100 * np.cumprod(1 + np.clip(returns, -0.5, None), axis=0)
+    if missing_fraction:
+        prices[rng.random(prices.shape) < missing_fraction] = np.nan
+    return (
+        pd.DataFrame(score, index=index, columns=columns),
+        pd.DataFrame(prices, index=index, columns=columns),
+    )