README.md

---
license: mit
task_categories:
- question-answering
- text-generation
language:
- en
tags:
- forecasting
- benchmark
- llm-evaluation
- reasoning
- temporal-reasoning
- contamination-control
- leakage-control
- prediction
- agent
size_categories:
- n<1K
pretty_name: OracleProto Forecasting Eval Set
---

# OracleProto: Forecasting Evaluation Set

**Chinese doc:** [[`中文文档`](https://huggingface.co/datasets/MaYiding/OracleProto/blob/main/README-ZH.md)]

**GitHub repo:** [[`MaYiding/OracleProto`](https://github.com/MaYiding/OracleProto)]

**Visit Our Leaderboards:** [[`Website`](https://oracleproto.pages.dev)]

**View Our Paper:** [[arXiv](http://arxiv.org/abs/2605.03762)]

A SQLite-packaged evaluation set of 80 hand-curated forecasting questions on real-world events, with resolution dates between 2026-03-12 and 2026-04-14, released alongside the [GitHub Repo](https://github.com/MaYiding/OracleProto). Both the rows and the byte-stable prompt-reconstruction recipe are packaged in a single file, `forecast_eval_set_example.db`, which exposes two tables: `forecast_eval_set_example` (the 80 rows) and `dataset_metadata` (the recipe).

---

## 1. Dataset at a glance

| Field                  | Value                                                                  |
| ---------------------- | ---------------------------------------------------------------------- |
| Release date           | `2026-04-29`                                                           |
| Rows                   | 80                                                                     |
| Splits                 | `train` (80); single split, intended as a held-out evaluation set      |
| Resolution-date range  | `2026-03-12` → `2026-04-14`                                            |
| Question types         | `yes_no`, `binary_named`, `multiple_choice`                            |
| Choice types           | `single` (one correct letter), `multi` (one or more correct letters)   |
| Database file          | `forecast_eval_set_example.db` (SQLite 3, ~52 KB)                      |
| Tables in the file     | `forecast_eval_set_example` (80 rows), `dataset_metadata` (1 row)      |
| License                | MIT                                                                    |
| Upstream source        | HuggingFace forecasting questions (levels 1+2), 322 raw → 80 curated   |

### Type distribution

| `question_type`     | `choice_type` | Rows   |
| ------------------- | ------------- | ------ |
| `yes_no`            | `single`      | 37     |
| `binary_named`      | `single`      | 3      |
| `multiple_choice`   | `single`      | 32     |
| `multiple_choice`   | `multi`       | 8      |
| **Total**           |               | **80** |

`yes_no` is binary Yes/No. `binary_named` is a binary choice between two named entities such as two teams, two contestants, or two competing parties. `multiple_choice` has at least three labelled options, one or more of which are correct; "None of the above" is a valid answer when it appears in the option list. Each row stores the exact option labels: letter `A` maps to `options[0]`, `B` to `options[1]`, and so on (§3.4 covers labels beyond `Z`).

---

## 2. Files

```text
OracleProto/
├── forecast_eval_set_example.db   # SQLite database file (the dataset; ~52 KB)
├── forecast_eval_set_example.csv  # CSV export of the rows table; 80 rows + header (~18 KB)
├── README.md                      # this file
├── LICENSE                        # MIT
└── .gitattributes                 # standard HF binary attributes
```

The dataset is published as a single SQLite file, not as Parquet or JSONL, because the prompt-reconstruction recipe and per-row provenance share the same file as the rows (in `dataset_metadata.features_json`). A loader that converts the rows to a `datasets.Dataset` is shown in §6.3.

The CSV is a row-table export of `forecast_eval_set_example`; it does not include `dataset_metadata`, so the prompt template is reachable only via the SQLite file. Use the CSV when a downstream pipeline needs only the 80 rows (pandas, a spreadsheet, or a `grep` filter) and reconstructs prompts on its own. The `options` column is preserved as a JSON-encoded array string, escaped per RFC 4180.

---

## 3. Database schema

Two tables: `forecast_eval_set_example` holds the 80 rows; `dataset_metadata` holds the canonical recipe. The file takes its name from the primary table.

### 3.1 Table `forecast_eval_set_example` (the rows)

```sql
CREATE TABLE forecast_eval_set_example (
    id            TEXT PRIMARY KEY,
    choice_type   TEXT NOT NULL CHECK (choice_type IN ('single','multi')),
    question_type TEXT NOT NULL,    -- yes_no | binary_named | multiple_choice
    event         TEXT NOT NULL,    -- the event being predicted
    options       TEXT NOT NULL,    -- JSON array of option labels
    answer        TEXT NOT NULL,    -- canonical correct answer as letter(s)
    end_time      TEXT NOT NULL     -- 'YYYY-MM-DD'
);

CREATE INDEX idx_forecast_eval_set_example_choice_type   ON forecast_eval_set_example(choice_type);
CREATE INDEX idx_forecast_eval_set_example_question_type ON forecast_eval_set_example(question_type);
CREATE INDEX idx_forecast_eval_set_example_end_time      ON forecast_eval_set_example(end_time);
```

### 3.2 Table `dataset_metadata` (the recipe)

A one-row table whose `features_json` blob stores the prompt template, the four output formats, the outcomes-block rule, the agent role, and curation provenance. The full recipe is documented in §5.

```sql
CREATE TABLE dataset_metadata (
    dataset_name      TEXT NOT NULL,
    split_name        TEXT NOT NULL,
    table_name        TEXT NOT NULL,
    row_count         INTEGER NOT NULL,
    imported_at_utc   TEXT NOT NULL,
    features_json     TEXT NOT NULL
);
```

### 3.3 Column semantics

| Column          | Type    | Description                                                                                                                                                                                                                                       |
| --------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id`            | TEXT    | Stable source-side question ID inherited from the upstream HuggingFace forecasting set; primary join key.                                                                                                                                          |
| `choice_type`   | TEXT    | `'single'` if exactly one letter is correct, `'multi'` if one or more letters are correct. Derived from the number of letters in `answer`. Selects between the single-answer and multi-select templates in §5.4.                                    |
| `question_type` | TEXT    | One of `yes_no`, `binary_named`, `multiple_choice`. Selects which prompt template is rendered (§5).                                                                                                                                                |
| `event`         | TEXT    | Natural-language description of the event being predicted, author-edited to make the time anchor, the units, and the binary framing explicit.                                                                                                       |
| `options`       | TEXT    | JSON array of option labels. For `yes_no` it is fixed to `["Yes","No"]`. For `binary_named` it is the two named entities. For `multiple_choice` it is the list of choice labels, where each letter is given by its position (`A=options[0]`, `B=options[1]`, …). |
| `answer`        | TEXT    | Canonical correct answer encoded as letters. For `yes_no` and `binary_named` it is `'A'` or `'B'`. For `multiple_choice` it is a comma-separated letter list in option order, e.g. `'A'` or `'A, B'`.                                                |
| `end_time`      | TEXT    | Resolution date in `YYYY-MM-DD`. The column stores a calendar date only; the prompt template (§5.2) attaches the GMT+8 reading at render time. If finer-grained admissibility is needed, treat each resolution as covering the whole calendar day.    |

### 3.4 Letter-to-index encoding

Letters map to option indices via `index = ord(letter) - ord('A')`. Beyond `Z` (≥27 options) the labels continue along the contiguous ASCII range that starts at `A`: `[`, `\`, `]`, `^`, `_`, `` ` ``, `a`, `b`, …. The reference renderer wraps any non-`A`–`Z` label in backticks to keep the label intact under Markdown rendering. None of the 80 rows exceed 26 options; the encoding is documented because the framework's parser supports it.

---

## 4. Sample rows

```json
{
  "id": "699d9ffc098cca008728b6f0",
  "choice_type": "single",
  "question_type": "yes_no",
  "event": "Will the US PCE annual inflation be greater than 2.9% in January 2026?",
  "options": ["Yes", "No"],
  "answer": "B",
  "end_time": "2026-03-13"
}
```

```json
{
  "id": "69a2e39e5692ef005cdbf2d3",
  "choice_type": "single",
  "question_type": "binary_named",
  "event": "Will US or Israel strike Iran first?",
  "options": ["US", "Israel"],
  "answer": "B",
  "end_time": "2026-03-31"
}
```

```json
{
  "id": "6995b1073ea64b005b11f285",
  "choice_type": "single",
  "question_type": "multiple_choice",
  "event": "Which men's basketball team will win the Big 12 Conference Championship tournament in the 2025-26 season?",
  "options": ["Arizona", "Baylor", "Brigham Young University (BYU)",
              "Houston", "Iowa State", "Kansas", "Kansas State"],
  "answer": "A",
  "end_time": "2026-03-14"
}
```

```json
{
  "id": "698f198bda7a8b006575444c",
  "choice_type": "multi",
  "question_type": "multiple_choice",
  "event": "Which movies will win multiple Oscars? (2026)",
  "options": ["One Battle After Another", "Sinners", "Frankenstein",
              "KPop Demon Hunters", "F1", "Sentimental Value", "Hamnet",
              "Marty Supreme", "The Secret Agent", "Avatar: Fire and Ash",
              "Train Dreams", "Bugonia", "Blue Moon", "It Was Just An Accident"],
  "answer": "A, B, C, D",
  "end_time": "2026-03-15"
}
```

---

## 5. Prompt reconstruction (canonical recipe)

Every row is rendered into a single user message via the recipe stored in `dataset_metadata.features_json.prompt_reconstruction`. The recipe is byte-stable and is the source of truth for the OracleProto evaluator; downstream users who reconstruct prompts themselves should follow it exactly to keep results comparable.

### 5.1 Static fragments

```text
agent_role: "You are an agent that can predict future events."

guidance: "Do not use any other format. Do not refuse to make a prediction.
           Do not say \"I cannot predict the future.\" You must make a clear
           prediction based on the best data currently available, using the
           box format specified above."
```

### 5.2 Master template

```text
{agent_role} The event to be predicted: "{event} (resolved around {end_time} (GMT+8)).{outcomes_block}"

IMPORTANT: Your final answer MUST end with this exact format:
{output_format}
{guidance}
```

The literal `(GMT+8)` inside the user-visible string is what attaches a timezone to the resolution date at render time.

### 5.3 `outcomes_block`

For `yes_no` and `binary_named`: empty, since the option labels are embedded directly in `output_format`.
For `multiple_choice`: a leading newline followed by one line per option in `A. <label>` form, for example `\nA. Arizona\nB. Baylor\nC. Brigham Young University (BYU)\n…`. Labels whose derived letter falls outside `A`–`Z` are wrapped in backticks.

### 5.4 `output_format` (one of four, chosen by `question_type` × `choice_type`)

**`yes_no`:**
```text
Your task is to predict whether the event will occur based on your analysis.
Your prediction will be scored based on its accuracy. You will only receive points if your answer is correct.
Your final answer MUST end with this exact format:
\boxed{Yes} or \boxed{No}
```

**`binary_named`** (the literals `<options[0]>` and `<options[1]>` are replaced by the two named entities from `options`):
```text
Your task is to predict which of the two outcomes will occur based on your analysis.
Your prediction will be scored based on its accuracy. You will only receive points if your answer is correct.
Your final answer MUST end with this exact format:
\boxed{<options[0]>} or \boxed{<options[1]>}
```

**`multiple_choice` with `choice_type='single'`:**
```text
This is a SINGLE-ANSWER question: exactly ONE of the listed options is correct.
Your prediction will be scored on strict equality with the unique correct letter; choosing the wrong letter, or selecting more than one letter, scores zero.
Your final answer MUST end with this exact format:
the single correct letter inside the box, e.g. \boxed{A}.
Do NOT list more than one letter, even if you believe two outcomes are tied — pick the one you find most likely.
```

**`multiple_choice` with `choice_type='multi'`:**
```text
This is a MULTI-SELECT question: ONE OR MORE of the listed options can be correct.
Your prediction will be scored on strict equality with the FULL set of correct letters: any extra letter, any missing letter, or any wrong letter scores zero. You must include ALL correct options and NO incorrect options.
Your final answer MUST end with this exact format:
listing all correct option(s) you have identified, separated by commas, within the box.
For example: \boxed{A} for a single correct option, or \boxed{B, C} for multiple correct options.
```

### 5.5 Answer parsing

The reference parser ([`forecast_eval/parser.py::parse_answer`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/parser.py)) applies these rules:

1. Take the **last** `\boxed{...}` substring in the model's reply; everything else is reasoning or scratchpad and is ignored.
2. For `yes_no` (case-insensitive): `Yes` → `A`, `No` → `B`. Anything else is unparsed.
3. For `binary_named` (case-insensitive): match the boxed payload against `options[0]` or `options[1]`. Anything else is unparsed.
4. For `multiple_choice`: split the boxed payload on commas and whitespace, validate that each token is a single letter, and check that each letter resolves to a valid option index. Out-of-range letters or multi-character tokens are unparsed.
5. Score by strict set equality against the canonical letter set parsed from `answer`. A missing or unparsed boxed answer is recorded as `parse_ok = 0` rather than raised as an error, and the run continues without halting.

Reusing the framework's parser is the simplest way to get bit-identical scores across implementations.

---

## 6. Loading the dataset

### 6.1 With raw `sqlite3` (no extra dependencies)

```python
import sqlite3
import json

conn = sqlite3.connect("forecast_eval_set_example.db")
conn.row_factory = sqlite3.Row

# Read the rows.
rows = conn.execute("SELECT * FROM forecast_eval_set_example").fetchall()
print(f"loaded {len(rows)} rows")
sample = dict(rows[0])
sample["options"] = json.loads(sample["options"])  # JSON-decode option list
print(sample)

# Read the canonical prompt-reconstruction recipe.
meta_row = conn.execute("SELECT features_json FROM dataset_metadata").fetchone()
meta = json.loads(meta_row["features_json"])
prompt_template = meta["prompt_reconstruction"]["prompt_template"]
print(prompt_template)
```

### 6.2 With `huggingface_hub`

```python
from huggingface_hub import hf_hub_download
import sqlite3, json

db_path = hf_hub_download(
    repo_id="MaYiding/OracleProto",
    filename="forecast_eval_set_example.db",
    repo_type="dataset",
)
conn = sqlite3.connect(db_path)
rows = conn.execute("SELECT * FROM forecast_eval_set_example").fetchall()
```

### 6.3 Convert to a `datasets.Dataset`

```python
import sqlite3, json
from datasets import Dataset

conn = sqlite3.connect("forecast_eval_set_example.db")
cur = conn.execute("SELECT * FROM forecast_eval_set_example")
cols = [c[0] for c in cur.description]

def _row(r):
    d = dict(zip(cols, r))
    d["options"] = json.loads(d["options"])         # list[str]
    d["answer_letters"] = [
        s.strip() for s in d["answer"].split(",") if s.strip()
    ]                                               # list[str]
    return d

ds = Dataset.from_list([_row(r) for r in cur.fetchall()])
print(ds)
print(ds[0])
```

### 6.4 Render a prompt (minimal, faithful to the canonical recipe)

```python
def render_prompt(row, meta):
    rcp = meta["prompt_reconstruction"]
    options = row["options"]
    qt, ct = row["question_type"], row["choice_type"]

    if qt == "yes_no":
        outcomes_block = ""
        out_fmt = rcp["yes_no_output_format"]
    elif qt == "binary_named":
        outcomes_block = ""
        out_fmt = (
            rcp["binary_named_output_format"]
            .replace("<options[0]>", options[0])
            .replace("<options[1]>", options[1])
        )
    elif qt == "multiple_choice":
        outcomes_block = "\n" + "\n".join(
            f"{chr(ord('A') + i)}. {label}" for i, label in enumerate(options)
        )
        key = (
            "multiple_choice_single_output_format" if ct == "single"
            else "multiple_choice_multi_output_format"
        )
        out_fmt = rcp[key]
    else:
        raise ValueError(qt)

    return rcp["prompt_template"].format(
        agent_role=rcp["agent_role"],
        event=row["event"],
        end_time=row["end_time"],
        outcomes_block=outcomes_block,
        output_format=out_fmt,
        guidance=rcp["guidance"],
    )
```

The full reference renderer, which extends the example above with the >26-option backtick rule and an optional reflection / belief-elicitation tail, is implemented in [`forecast_eval/prompts.py`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/prompts.py); reusing it produces byte-identical prompts.

### 6.5 With the CSV export (stdlib `csv`, no prompt template)

```python
import csv, json

with open("forecast_eval_set_example.csv", encoding="utf-8", newline="") as f:
    rows = [
        {**r, "options": json.loads(r["options"])}
        for r in csv.DictReader(f)
    ]
print(f"loaded {len(rows)} rows; first event: {rows[0]['event']!r}")
```

The CSV path skips `dataset_metadata` entirely. To pair the rows with the prompt template, either follow §5 by hand or switch back to the SQLite path in §6.1.

---

## 7. Recommended evaluation protocol

Pair the dataset with the OracleProto evaluation harness, which layers information-boundary discipline on top of a plain prompt-and-score loop. Five concrete recommendations:

1. **Declare a knowledge cutoff $\kappa_M$ for every model.** A question is admissible for model $M$ only when $\kappa_M \le \chi_i < \tau_i$, where $\chi_i$ is the per-question prediction cutoff and $\tau_i$ is its resolution date. Inadmissible questions are filtered upstream rather than counted as model errors. A model with no declared cutoff cannot be fairly compared against a model that has one.

2. **Time-mask any retrieval or browsing tool.** If the harness lets the model issue web searches, pin the search-side `end_date` to $\chi_i + \delta$ with a conservative offset; OracleProto defaults to $\delta = -1$ day. The mechanism behind this barrier (L2) is documented in the framework's DESIGN and FRAME notes.

3. **Run an independent retrieval-content auditor.** Each retrieved snippet is passed to a separate LLM auditor that decides whether the snippet leaks the resolution. This is the L3 barrier in the framework's threat model.

4. **Forbid provider-native browsing.** OracleProto refuses model slugs ending in `:online` and similar hosted-browsing variants on three layers: config validation, on-the-wire client, and detector client. This is the L4 barrier, the final check that any billable LLM call must clear before it leaves the process.

5. **Score with strict set equality on letter sets**, per §5.5. Optional probability-calibration metrics (Brier, NLL, ECE, Murphy decomposition) are supported when the model emits an additional `<belief>{ ... }</belief>` JSON block following the framework's belief-elicitation protocol; the schema is documented in [`forecast_eval/prompts.py::BELIEF_PROTOCOL`](https://github.com/MaYiding/OracleProto/blob/main/forecast_eval/prompts.py).

Without the OracleProto harness in place, treat the resulting numbers as upper bounds on forecasting ability: any model that can browse the open web, or that was trained past a question's `end_time`, may have memorised the answer. The dataset makes the admissibility check possible; it does not enforce it on its own.

---

## 8. Provenance and curation

* **Source.** Upstream HuggingFace forecasting questions, restricted to *levels 1+2* (the easier two of the upstream difficulty bands). The raw set was harvested as 322 candidate questions.
* **Curation pipeline (5 passes).**
  1. Source-side broken-row removal and column flattening.
  2. `end_time` / answer-encoding / option-label normalization: `end_time` reduced to a `YYYY-MM-DD` calendar date; `Yes/No` mapped to `A/B`; option labels stripped of stray markdown.
  3. Down-sampling 322 → 200 → 100 → 80 with placeholder removal, deduplication, and an ambiguity audit.
  4. Final HIGH+MEDIUM ambiguity remediation: 4 rows reworded to make their time anchor, units, or binary framing explicit.
  5. CRITICAL fix on one S&P 500 multi-select truth set so it satisfies the monotonic-threshold logic implied by the option ladder.
* **Verification.** All 80 ground-truths verified end-to-end via parser round-trip (the rendered prompt is parsed and re-encoded back to the canonical letter set). Final tally: 0 critical / 0 high / 0 medium ambiguity issues remaining.

---

## 9. Intended uses and limitations

### 9.1 Intended uses

* **Forecasting benchmark for LLMs and LLM agents**, particularly tool-using agents that combine parametric knowledge with time-masked web retrieval.
* **Reproducibility testbed for forecasting harnesses.** The `dataset_metadata` table makes every prompt byte-stable; pairing it with the OracleProto framework yields a run unit whose scoring artefacts are bit-identical when the configuration matches.
* **Calibration and proper-scoring research.** The 80-row size is small enough that per-question analysis (belief evolution, source attribution, calibration plots) stays tractable.

### 9.2 Out-of-scope uses

* **Long-horizon forecasting.** All resolutions land in a one-month window (2026-03-12 → 2026-04-14); the set does not represent multi-quarter or multi-year forecasting.
* **Open-ended generation.** Every question has a closed answer set, so this is not a generation benchmark.

---

## 10. License

Released under the **MIT License** (see `LICENSE`). The upstream questions originate from a public HuggingFace forecasting set; the curation work, schema, prompt-reconstruction recipe, and answer encodings in this release are the contribution of this project.

---

## 11. Contact

For questions about code usage, dataset construction, or reproducing results, please reach out to the developers directly:
- **Yiding Ma**: [yidingma@bupt.edu.cn](mailto:yidingma@bupt.edu.cn)
- **Chengyun Ruan**: [ruanchengyun815@bupt.edu.cn](mailto:ruanchengyun815@bupt.edu.cn)

For joint research, dataset and benchmark co-development, or paper collaboration, please contact the principal investigators:
- **Kaibo Huang** (corresponding author): [huangkaibo@bupt.edu.cn](mailto:huangkaibo@bupt.edu.cn)
- **Zhongliang Yang** (corresponding author): [yangzl@bupt.edu.cn](mailto:yangzl@bupt.edu.cn)

---

## 12. Paper

View Our Paper: [arXiv](http://arxiv.org/abs/2605.03762)

---

## 13. Citation

If you use this project in your research, please cite our paper:

```
@article{OracleProto,
  title={OracleProto: A Reproducible Framework for Benchmarking LLM Native Forecasting via Knowledge Cutoff and Temporal Masking},
  author={Yiding Ma, Chengyun Ruan, Kaibo Huang, Zhongliang Yang, Linna Zhou},
  journal={arXiv preprint arXiv:2605.03762},
  year={2026}
}
```

---