README.md

metadata

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
• 💻 Code: to be released upon acceptance
• 🌐 Website: https://yubol-bobo.github.io/heuristic_override_benchmark/

Quick use

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:

# 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:

@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.