p-to-q/aleph-bench

Aleph Bench — historical M0/v0.1 snapshot

The model rows under evidence/ are deterministic mock pipeline outputs, not hosted model evaluations. This historical snapshot distributes the M0/v0.1 benchmark dataset and procedure. Do not cite numbers from evidence/mock_*.csv as a model leaderboard.

Aleph Bench Frozen Ladder is a historical M0/v0.1 procedure snapshot for comparing how much non-leaking prompt coordinate length a model needs to reproduce synthetic target outputs. It is not the current Aleph Bench protocol release. Version: 0.1.0 (m0). Evidence mode: mock (the included evidence contains no hosted model rows).

The construct is elicitation efficiency: fix the target output, then search for the shortest non-leaking prompt that regenerates it. Lower AURC means the model reaches the target with fewer prompt tokens.

Release identity and public surfaces

• Immutable historical snapshot: v0.1.0-m0, fixed at Hub commit 3bccb9d20b4bf4c180e93dc2480c4b8943f5c14c.
• Standalone source and release engineering: p-to-q/aleph-benchmark. This historical package does not record the exact source commit or generator version that produced its bytes; those values are unknown and are not inferred from the maintained repository.
• Public execution and leaderboard: jahyee/aleph-bench. Kaggle is a distinct execution surface, not a semantically equivalent copy of this dataset.

These surfaces have different jobs. The immutable Hub tag preserves the published M0/v0.1 bytes; the standalone repository carries reviewed protocol and release engineering; Kaggle executes model runs. A future v0.2 Hub cutover must be generated and verified by the standalone release path. Until then, this card intentionally remains a clearly labeled historical snapshot.

Contents

Dataset (data/)

• public_s2_items.jsonl (30 rows): S2 compositional BenchItems with target text, frozen ladder, canary GUID, provenance.
• public_s2_prompts.jsonl (240 rows): every frozen-ladder prompt, with leakage-gate measurements and a disqualified flag.
• public_s2_items.csv / public_s2_prompts.csv: flat preview tables for the Kaggle Dataset page.
• submission_format.csv (180 rows): the public output shape (row_id,model_id,item_id,prompt_id,output_text) restricted to non-leaking prompts.

Mock evidence (evidence/)

• mock_model_summary.csv / mock_item_metrics.csv: deterministic mock-adapter rows. Pipeline evidence only, never to be cited as model rankings.
• m0-first-run.json: the full mock BenchResult (3 mock models, 30 items).
• m0-report.md: pre-rendered tables for the mock result.
• m0-audit.json / m0-bundle.json / m0-call-manifest.json / m0-evidence.md: acceptance-gate receipt, bundle digest manifest, no-call prompt manifest, and evidence note.

Metadata, schemas, and platform scaffolding

• schemas/: JSON Schemas validating items, prompts, results, audit, bundle, manifest, and the platform package itself.
• croissant.json: MLCommons Croissant 1.1 metadata with RecordSet for items and prompts.
• dataset-metadata.json: Kaggle Dataset metadata with per-CSV field schemas.
• huggingface/: Hugging Face upload preparation (dry-run + optional --execute).
• kaggle/: Kaggle Community Benchmark task scaffold, vendored scorer, output-scoring helper, and I/O smoke test.
• PLATFORM_LAUNCH_CHECKLIST.md: staged launch gates separating prepared, blocked, and not-yet-run work.

How to evaluate

A Kaggle notebook (or any local runner) can score outputs against the frozen ladder without cloning the Aleph repository — the scorer is vendored in kaggle/:

import csv, json
from pathlib import Path

# 1) Load the non-leaking prompts (180 of 240).
prompts = [json.loads(line) for line in Path("data/public_s2_prompts.jsonl").read_text().splitlines()]
non_leaking = [row for row in prompts if not row["disqualified"]]

# 2) Generate outputs (replace with your model call). Submission shape is documented in
#    data/submission_format.csv and must contain row_id, model_id, item_id, prompt_id, output_text.
submission = [{"row_id": f"{r['item_id']}:{r['prompt_id']}",
               "model_id": "my-model",
               "item_id": r["item_id"],
               "prompt_id": r["prompt_id"],
               "output_text": my_model(r["prompt"])} for r in non_leaking]

# 3) Score with the vendored AURC / ECL@tau / Elicit@k implementation.
import sys; sys.path.insert(0, "kaggle")
from score_outputs import score_submission
result = score_submission(items_path="data/public_s2_items.jsonl",
                          prompts_path="data/public_s2_prompts.jsonl",
                          submission_rows=submission,
                          model_id="my-model")
print(result["aggregate"])

Leakage is a gate, not a penalty. Explicit reconstruction prompts (rung 0) are excluded from compression metrics. AURC is the area under the monotone non-leaking rate-distortion staircase; lower is better. ECL@tau and Elicit@k are interpretable duals.

This snapshot is self-checking without a repository checkout:

shasum -a 256 -c checksums.sha256
python3 huggingface/upload_dataset.py --dry-run
python3 kaggle/api_test_smoke.py

For current protocol and artifact-verification tooling, use the standalone repository above. Do not assume its current default branch generated these historical M0/v0.1 bytes: the exact historical source commit and generator version are not present in this package and remain unknown.

Hosted black-box results must produce their own result, manifest, report, and evidence note. Black-box rows report generated-text behavior only; they do not report logits, token NLL, or other white-box observations. A completed platform task is not, by itself, a benchmark score.

Citation

A versioned citation (with author list, DOI, and venue) will accompany the first hosted-evidence release. For now, please cite as:

@misc{alephbench_m0_2026,
  title  = {Aleph Bench: Historical M0/v0.1 Dataset and Procedure Snapshot},
  author = {AlephBench Maintainers},
  year   = {2026},
  note   = {Historical snapshot; included model evidence is deterministic mock output},
  url    = {https://huggingface.co/datasets/p-to-q/aleph-bench/tree/v0.1.0-m0}
}

A versioned author list, DOI, and venue are not asserted by this historical package. Consult the standalone repository for current citation and release status.

Responsible Use

The targets are rule-generated synthetic English strings with a shared canary GUID stored as metadata, not as target text. The package is meant for benchmark procedure review and community reproduction, not for claims about globally shortest prompts or real model ranking until hosted black-box rows exist. Any aurc / eclAtTau / elicitAtK number sourced from evidence/ is mock pipeline evidence with evidenceMode = mock, and downstream summaries (blog posts, slides, leaderboards) must preserve that label.