# Benchmark Design

## Design Goal

FUTURE-TS exists to make benchmark integrity a property of the evaluation process rather than a claim about careful dataset curation. The benchmark is designed around time of availability, frozen submissions, and explicit adaptation constraints.

The current codebase enforces this through:

- evaluator-issued run manifests (`platform_issued_at`, `platform_received_at`)
- deterministic `prediction_hash` and `manifest_hash` checks
- first-publication auditing on realized labels (`first_published_at`)

## Tier Model

### `public_dev`

Open-label tasks for development, debugging, and reproducible baselines. These tasks are fully inspectable and intentionally not sufficient for a final ranking.

### `blind_archive`

Historical windows whose labels are hidden from participants. The evaluator can score them, but the submission contract still requires training and retrieval cutoffs to precede those labels.

### `live`

Truly future windows. Predictions are submitted before outcomes are available. Scoring only becomes possible when the realized labels arrive.

## Why Task Cards Matter

The benchmark does not rank model families against dataset names alone. It ranks behavior under declared operating conditions. A task card should answer:

- What is being predicted?
- At what issue time?
- Over what horizon?
- Which covariates are known, forecast, delayed, or unavailable?
- Is the task revision-aware?
- What is the latency and memory budget?
- Which metric actually matters in deployment?

## Data Preparation Boundary

Core evaluation code should score benchmark artifacts; it should not depend on
third-party API uptime. The empirical suite now keeps public-source fetchers
under `scripts/data_prep/`, while `future_ts.empirical_suite` consumes cached
source files and delegates cache misses to that data-prep module. This keeps
runner/scorer tests isolated from FRED, NOAA, USGS, Melbourne, CDC, MTA, and
NYC Open Data schema or rate-limit changes.

For strict benchmark releases, prefer materializing versioned task cards
and actuals from static cache snapshots. Live API fetching is a data-prep step,
not part of the scoring contract.

## OOD Tagging

Each task carries OOD tags so evaluation can be sliced beyond domain labels. v0 uses a simple tag list, but the intended interpretation includes:

- time OOD
- entity OOD
- regime OOD
- structure OOD
- covariate OOD

## Adaptation

Tasks declare which adaptation budgets are legal. The current scaffold assumes ordered budgets and reports:

- skill at each supported budget
- adaptation AUC across the supported budget path

This separates generalization from tunability.

## Aggregation Philosophy

v0 computes:

- per-task raw metric
- anchor-normalized skill
- uncertainty and efficiency side metrics
- tier-level weighted means
- a capability vector
- a Pareto-friendly leaderboard summary

The decision-utility (`D`) dimension supports newsvendor-style tasks where a
point forecast can be interpreted as an action. When quantile predictions are
available, the expected holding/stockout metric uses the critical fractile
`p / (h + p)` and scores the scaled pinball loss at that quantile. This keeps
probabilistic submissions aligned with the decision that the user would
actually make under asymmetric costs.

The robustness (`R`) dimension intentionally uses the least-adapted score for
event or OOD-tagged tasks. Adapted performance still contributes to adaptation
AUC (`A`), but it cannot dominate both `R` and `A` through the same improved
few-shot budget.

The overall score is included for convenience, but the benchmark is intentionally not “lowest average error wins.”

The scorer also assumes comparable coverage. A report is only produced when the submission covers the full visible evaluation set for each task-budget pair represented in the realized labels. This avoids inflating overall score by skipping difficult tasks, series, or budgets.

## What Is Still Not Implemented

- remote submission execution
- cryptographic signature verification against external key infrastructure
- wave-based ranking for cross-date comparability
- revision snapshots for inputs beyond realized labels
- large-scale hierarchical bootstrap over domains, datasets, and series

Those remain service concerns. This repo establishes and validates the local benchmark contract first.