README.md

---
license: mit
language:
- en
pretty_name: "HOB — Heuristic Override Benchmark"
size_categories:
- n<1K
task_categories:
- question-answering
- text-classification
tags:
- reasoning
- benchmark
- heuristics
- llm-evaluation
- constraint-satisfaction
- cognitive-biases
- decision-making
configs:
- config_name: default
  data_files:
  - split: test
    path: hob.parquet
dataset_info:
  features:
  - name: id
    dtype: string
  - name: cell
    dtype: string
  - name: heuristic_type
    dtype: string
  - name: constraint_type
    dtype: string
  - name: goal
    dtype: string
  - name: question
    dtype: string
  - name: shortcut_cue
    dtype: string
  - name: hidden_constraint
    dtype: string
  - name: shortcut_answer
    dtype: string
  - name: gold_answer
    dtype: string
  - name: conflict_type
    dtype: string
  - name: explanation
    dtype: string
  - name: pair_id
    dtype: string
  - name: pair_type
    dtype: string
  - name: heuristic_strength
    dtype: string
  - name: constraint_explicitness
    dtype: string
  - name: domain
    dtype: string
  - name: instance_type
    dtype: string
  - name: control_subtype
    dtype: string
  splits:
  - name: test
    num_bytes: 440482
    num_examples: 500
---

# HOB — Heuristic Override Benchmark

**HOB** tests whether large language models can override a salient surface heuristic
when it conflicts with an implicit feasibility constraint. A canonical example:

> *I need to get my car washed. The car wash is only 5 minutes away. Should I walk or drive?*

The short distance cues **Walk**, but the car itself has to physically be at the car
wash — so the correct answer is **Drive**. HOB is a collection of ~500 such items,
organised along a two-axis taxonomy (heuristic × constraint), with minimal pairs,
strength variants, and explicitness variants so that failures can be diagnosed rather
than merely counted.

- 📄 **Paper:** *The Model Says Walk: How Surface Heuristics Override Implicit Constraints in LLM Reasoning* (COLM 2026, under review) · [arXiv:2603.29025](https://arxiv.org/abs/2603.29025)
- 💻 **Code:** to be released upon acceptance
- 🌐 **Website:** <https://yubol-bobo.github.io/heuristic_override_benchmark/>

## Quick use

```python
from datasets import load_dataset

ds = load_dataset("yubol/Heuristic_Override_Benchmark", split="test")
print(ds)
print(ds[0])
```

The dataset is a single `test` split of 500 rows — it is a benchmark, not a
training corpus. Filter by column to recover sub-views:

```python
# Just the conflict instances that trip frontier models on HOB
conflicts = ds.filter(lambda r: r["instance_type"] == "base")

# All items that use the proximity heuristic against a presence constraint
a1 = ds.filter(lambda r: r["cell"] == "A1")

# Minimal-pair companions (constraint removed) for every base instance
pairs = ds.filter(lambda r: r["instance_type"] == "pair")
```

## Taxonomy

Every instance lives in exactly one **heuristic × constraint** cell. Four heuristic
families describe *what misleads the model*; five constraint families describe
*what the model overlooks*.

| | C-pres (Presence) | C-cap (Capability) | C-val (Validity) | C-scope (Scope) | C-proc (Procedural) |
|---|---|---|---|---|---|
| **H-prox** (Proximity)  | **A1** · 40 | **A2** · 35 | **A3** · 35 | **A4** · 20 | **A5** · 30 |
| **H-eff** (Efficiency)  | **B1** · 20 | **B2** · 40 | **B3** · 35 | **B4** · 30 | **B5** · 30 |
| **H-cost** (Cost)       | —           | **C2** · 30 | **C3** · 25 | **C4** · 40 | **C5** · 20 |
| **H-sem** (Semantic)    | —           | —           | —           | **D4** · 40 | —           |

15 of 20 cells are populated (5 are omitted because no natural scenario instantiates
the pairing — e.g. a pure "cheap > presence" conflict). A separate **control** cell of
30 items contains no conflict and acts as a ceiling check.

## Design logic

For every conflict instance we ship structured companions that isolate the override
behaviour from surface comprehension and memorised solutions:

1. **Minimal pair.** A near-identical item in which the constraint is removed (e.g.
   "get my car washed" → "pick up a car wash gift card"). The shortcut answer now
   *becomes* correct, so the pair exposes whether a model loses on constraint
   reasoning or just on reading comprehension.
2. **Strength gradient.** Variants that dial the heuristic up or down
   (`strong / medium / weak / inverted`) trace a model's heuristic-sensitivity
   curve. The `inverted` variant aligns heuristic with constraint — an easy sanity
   check.
3. **Explicitness gradient.** Variants in which the hidden constraint is
   progressively spelled out (`implicit / hint / explicit`). The gap between
   *implicit* and *hint* is one of HOB's sharpest diagnostics: the knowledge is
   present, the bottleneck is inference.

## Fields

| Field | Type | Description |
|---|---|---|
| `id` | string | Stable instance identifier (e.g. `A1-001`, `B2-001-str-strong`). |
| `cell` | string | `A1`…`D4` or `control`. |
| `heuristic_type` | string | `H-prox`, `H-eff`, `H-cost`, `H-sem`. |
| `constraint_type` | string | `C-pres`, `C-cap`, `C-val`, `C-scope`, `C-proc`, or `none` for controls. |
| `goal` | string | User's underlying task (e.g. "Get the car washed"). |
| `question` | string | Natural-language prompt presented to the model. |
| `shortcut_cue` | string | The salient surface feature that tempts the wrong answer. |
| `hidden_constraint` | string | The implicit feasibility requirement the model must respect. |
| `shortcut_answer` | string *(nullable)* | What the heuristic would suggest. `null` when the pair removes the shortcut. |
| `gold_answer` | string | Correct answer. |
| `conflict_type` | string | `goal_substitution`, `missing_precondition`, `service_mismatch`, or `none`. |
| `explanation` | string | One-sentence rationale for the gold answer. |
| `pair_id` | string *(nullable)* | Cross-reference to the matched conflict/pair companion. Not a split key. |
| `pair_type` | string | `constraint_active`, `constraint_removed`, or `none`. |
| `heuristic_strength` | string | `strong`, `medium`, `weak`, `very_weak`, or `inverted`. |
| `constraint_explicitness` | string | `implicit`, `hint`, `semi-explicit`, `explicit`, or `none`. |
| `domain` | string | `transportation`, `home`, `work`, `shopping`, `medical`, `digital`, `travel`. |
| `instance_type` | string | `base`, `pair`, `strength_variant`, `explicitness_variant`, or `control`. |
| `control_subtype` | string *(nullable)* | Only populated for control instances. |

## Splits

The dataset ships as a single `test` split. `instance_type` is retained as a
*column* rather than exposed as HF splits, because benchmarks are typically loaded
in full and sub-views are created by filtering.

## Statistics

### Heuristic × Constraint (non-control rows: 470)

| | C-pres | C-cap | C-val | C-scope | C-proc | total |
|---|---:|---:|---:|---:|---:|---:|
| H-prox  | 40 | 35 | 35 | 20 | 30 | **160** |
| H-eff   | 20 | 40 | 35 | 30 | 30 | **155** |
| H-cost  | —  | 30 | 25 | 40 | 20 | **115** |
| H-sem   | —  | —  | —  | 40 | —  | **40**  |
| **total** | **60** | **105** | **95** | **130** | **80** | **470** |

### Instance-type mix

| instance_type | count |
|---|---:|
| base                  | 142 |
| pair                  | 141 |
| explicitness_variant  | 97  |
| strength_variant      | 90  |
| control               | 30  |
| **total**             | **500** |

### Domain distribution

| domain | count |
|---|---:|
| transportation | 133 |
| home           | 90  |
| work           | 89  |
| shopping       | 79  |
| medical        | 43  |
| digital        | 42  |
| travel         | 24  |

## Intended use & limitations

**Intended use.** Evaluate whether language models produce goal-consistent answers
when surface heuristics conflict with implicit feasibility constraints. HOB is
designed for *benchmarking* and *diagnostic analysis* (via the minimal pair and
gradient variants). It is not a training set.

**Evaluation protocol used in the paper.** Each instance is queried `N=10` times
per model. A model is considered *correct on an instance* only if **all 10** trials
match the `gold_answer` under an LLM-judge (strict 10/10 criterion). See the paper
for judge prompts and per-model details.

**Limitations.**
- **Language:** English only.
- **Judge dependence:** strict accuracy is computed with a model-based judge; the
  dataset itself is judge-agnostic but headline numbers in the paper depend on the
  specific judge used.
- **Coverage:** 15 of 20 taxonomy cells are populated; 5 are intentionally omitted
  for low naturalness rather than exhaustively included.
- **Naturalness vs. adversariality:** items are drawn from everyday scenarios, not
  from worst-case adversarial constructions. Models that pass HOB may still fail
  harder constraint-reasoning tasks.

## Citation

If you use HOB, please cite:

```bibtex
@article{li2026hob,
  title   = {The Model Says Walk: How Surface Heuristics Override Implicit Constraints in LLM Reasoning},
  author  = {Li, Yubo and Zhang, Lu and Jiang, Tianchong and Krishnan, Ramayya and Padman, Rema},
  journal = {arXiv preprint arXiv:2603.29025},
  year    = {2026}
}
```

## License

The dataset is released under the MIT License. See `LICENSE` in the code
repository.

## Changelog

- **v2.0** (2026-04) — Initial public release on Hugging Face. 500 instances,
  15 populated cells, minimal pair + strength + explicitness variants, 30 controls.