---
language:
- en
license: cc-by-4.0
task_categories:
- question-answering
- multiple-choice
task_ids:
- multiple-choice-qa
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
    - split: level_1_easy
      path: level1_easy.jsonl
    - split: level_2_basic
      path: level2_basic.jsonl
    - split: level_3_intermediate
      path: level3_intermediate.jsonl
    - split: level_4_hard
      path: level4_hard.jsonl
    - split: level_5_expert
      path: level5_expert.jsonl
tags:
- benchmark
- evaluation
- reasoning
- graded-difficulty
- llm-evaluation
pretty_name: LadderBench
---

![LadderBench Hero Cover](ladderbench.jpg)

# LadderBench

A **graded capability ladder** for evaluating (large) language models: 150
multiple-choice questions organized in **5 difficulty levels** (30 each),
strictly ordered from *easy* to *expert*. Because every level is scored
separately, LadderBench shows **where a model's abilities break down**, not
just an average score - two models with the same overall accuracy can have
very different level profiles.

## Motivation

Averaged benchmark scores hide useful structure: a model can score 70% by
acing easy questions and guessing on hard ones, or by being uniformly
mediocre. LadderBench's ladder design exposes that difference:

| Level | Name | What it probes | Example |
|---|---|---|---|
| 1 | easy | basic facts, single-step arithmetic | "What is 7 + 8?" |
| 2 | basic | everyday knowledge, word problems, gentle traps | "Which month has at least 28 days?" |
| 3 | intermediate | reading comprehension, applied reasoning, classic traps | bat & ball ($0.05), lily pads (day 29) |
| 4 | hard | multi-step math, sequences, work rates, percentages | clock-angle 7.5°, chicken/rabbit legs |
| 5 | expert | competition math, logic puzzles | 2^50 mod 7, trailing zeros of 100!, knights & knaves |

Expected behavior of a healthy model: a roughly **monotonic decline** from
level 1 to level 5. A model that scores better on level 5 than level 4 is a
signal of noise (too few samples) or a poorly calibrated level - which is
exactly what this design is meant to catch.

## Data format

One JSON object per line (JSONL), identical schema in every file:

```json
{
  "id": "l5_12",
  "level": 5,
  "category": "math",
  "question": "How many trailing zeros does 100! (100 factorial) have?",
  "choices": ["10", "21", "24", "25"],
  "answer": "C"
}
```

Fields:
- `id` - stable unique identifier (`l<level>_<nn>`)
- `level` - 1..5
- `category` - arithmetic / knowledge / common-sense / reading / math /
  logic / sequence / probability / trick / reasoning / safety
- `question` - the prompt shown to the model (passages are embedded in the text)
- `choices` - exactly 4 answer options, presented to the model as (A)-(D)
- `answer` - the gold letter, one of A/B/C/D

## Splits

| File | Rows | Level |
|---|---|---|
| `level1_easy.jsonl` | 30 | 1 easy |
| `level2_basic.jsonl` | 30 | 2 basic |
| `level3_intermediate.jsonl` | 30 | 3 intermediate |
| `level4_hard.jsonl` | 30 | 4 hard |
| `level5_expert.jsonl` | 30 | 5 expert |

## Evaluation protocol

The recommended protocol (implemented in the standalone runner):

1. Present the question with options lettered (A)-(D); instruct the model to
   answer with the letter only.
2. Parse the selected letter from the response (robust to "(B)", "B.", etc.).
3. Score 1.0 for an exact letter match, else 0.0; report per-level accuracy.
4. Use temperature 0 (greedy) for reproducibility.

**Important**: the random-guessing baseline is 25% (4 options). With 30
questions per level, each question is worth ~3.3 percentage points - treat
per-level gaps under ~10 points cautiously and report the guessing baseline
alongside results.

## Standalone runner

This folder ships `run_ladderbench.py`, a **zero-dependency runner** (Python
3.8+ standard library only) so anyone can evaluate any model on LadderBench
without installing anything else. It works with any OpenAI-compatible chat
endpoint:

```bash
# Ollama (default endpoint)
python run_ladderbench.py --model qwen2.5:3b-instruct-q4_K_M

# LM Studio
python run_ladderbench.py --model my-model --base-url http://127.0.0.1:1234/v1 --api-key lmstudio

# llama.cpp llama-server
python run_ladderbench.py --model any-name --base-url http://127.0.0.1:8080/v1

# OpenAI / other hosted APIs
python run_ladderbench.py --model gpt-4o --base-url https://api.openai.com/v1 --api-key sk-...

# Quick pass: only hard levels, 5 questions each
python run_ladderbench.py --model <model> --levels 4,5 --limit 5
```

What it does: letter-answer prompting over every question, robust letter
parsing, per-level accuracy table, and a JSON report
(`results_<model>_<timestamp>.json`) containing a full per-question audit
trail (prediction, gold, raw output) for error analysis.

Protocol notes:
- temperature 0 (greedy) by default for reproducibility;
- prompt asks for the letter only; parsing tolerates "(B)", "B.", etc.;
- report the 25% guessing baseline next to results;
- the audit file lets you compute per-category scores too (see `category`).

## Extending / contributing

Add rows to any level file following the schema above (keep ids unique), or
create a new level file and register it in the loader. When adding questions:
verify the gold answer independently, make distractors plausible, and avoid
answer-letter position bias by distributing correct letters across A-D.

## License

CC-BY-4.0. Questions are original works written for this benchmark; classic
puzzle ideas (bat & ball, lily pads, knights & knaves) are folklore and are
rephrased here.