---
pretty_name: STEER
license: cc-by-4.0
language:
- en
task_categories:
- multiple-choice
- question-answering
tags:
- economics
- rationality
- decision-making
- game-theory
- social-choice
- reasoning
- benchmark
size_categories:
- 10K<n<100K
configs:
- config_name: default
  default: true
  data_files:
  - split: test
    path: data/*/test.parquet
  - split: few_shot
    path: data/*/few_shot.parquet
- config_name: add_sub
  data_files:
  - split: test
    path: data/add_sub/test.parquet
  - split: few_shot
    path: data/add_sub/few_shot.parquet
- config_name: mult_div
  data_files:
  - split: test
    path: data/mult_div/test.parquet
  - split: few_shot
    path: data/mult_div/few_shot.parquet
- config_name: compute_expectations
  data_files:
  - split: test
    path: data/compute_expectations/test.parquet
  - split: few_shot
    path: data/compute_expectations/few_shot.parquet
- config_name: micro_utility
  data_files:
  - split: test
    path: data/micro_utility/test.parquet
  - split: few_shot
    path: data/micro_utility/few_shot.parquet
- config_name: optimize_continuous
  data_files:
  - split: test
    path: data/optimize_continuous/test.parquet
  - split: few_shot
    path: data/optimize_continuous/few_shot.parquet
- config_name: constrained_optimization
  data_files:
  - split: test
    path: data/constrained_optimization/test.parquet
  - split: few_shot
    path: data/constrained_optimization/few_shot.parquet
- config_name: prob_basic
  data_files:
  - split: test
    path: data/prob_basic/test.parquet
  - split: few_shot
    path: data/prob_basic/few_shot.parquet
- config_name: complement_rule
  data_files:
  - split: test
    path: data/complement_rule/test.parquet
  - split: few_shot
    path: data/complement_rule/few_shot.parquet
- config_name: bayes_rule
  data_files:
  - split: test
    path: data/bayes_rule/test.parquet
  - split: few_shot
    path: data/bayes_rule/few_shot.parquet
- config_name: categorical_syllogism
  data_files:
  - split: test
    path: data/categorical_syllogism/test.parquet
  - split: few_shot
    path: data/categorical_syllogism/few_shot.parquet
- config_name: conditional_syllogism
  data_files:
  - split: test
    path: data/conditional_syllogism/test.parquet
  - split: few_shot
    path: data/conditional_syllogism/few_shot.parquet
- config_name: equiv_contrapositive
  data_files:
  - split: test
    path: data/equiv_contrapositive/test.parquet
  - split: few_shot
    path: data/equiv_contrapositive/few_shot.parquet
- config_name: first_order_false_belief
  data_files:
  - split: test
    path: data/first_order_false_belief/test.parquet
  - split: few_shot
    path: data/first_order_false_belief/few_shot.parquet
- config_name: second_order_false_belief
  data_files:
  - split: test
    path: data/second_order_false_belief/test.parquet
  - split: few_shot
    path: data/second_order_false_belief/few_shot.parquet
- config_name: completeness
  data_files:
  - split: test
    path: data/completeness/test.parquet
  - split: few_shot
    path: data/completeness/few_shot.parquet
- config_name: transitivity
  data_files:
  - split: test
    path: data/transitivity/test.parquet
  - split: few_shot
    path: data/transitivity/few_shot.parquet
- config_name: independence
  data_files:
  - split: test
    path: data/independence/test.parquet
  - split: few_shot
    path: data/independence/few_shot.parquet
- config_name: sunk_cost
  data_files:
  - split: test
    path: data/sunk_cost/test.parquet
  - split: few_shot
    path: data/sunk_cost/few_shot.parquet
- config_name: endowment_effect
  data_files:
  - split: test
    path: data/endowment_effect/test.parquet
  - split: few_shot
    path: data/endowment_effect/few_shot.parquet
- config_name: time_inconsistency
  data_files:
  - split: test
    path: data/time_inconsistency/test.parquet
  - split: few_shot
    path: data/time_inconsistency/few_shot.parquet
- config_name: completeness_risk
  data_files:
  - split: test
    path: data/completeness_risk/test.parquet
  - split: few_shot
    path: data/completeness_risk/few_shot.parquet
- config_name: transitivity_risk
  data_files:
  - split: test
    path: data/transitivity_risk/test.parquet
  - split: few_shot
    path: data/transitivity_risk/few_shot.parquet
- config_name: independence_risk
  data_files:
  - split: test
    path: data/independence_risk/test.parquet
  - split: few_shot
    path: data/independence_risk/few_shot.parquet
- config_name: compute_expected_utility
  data_files:
  - split: test
    path: data/compute_expected_utility/test.parquet
  - split: few_shot
    path: data/compute_expected_utility/few_shot.parquet
- config_name: maximize_expected_utility
  data_files:
  - split: test
    path: data/maximize_expected_utility/test.parquet
  - split: few_shot
    path: data/maximize_expected_utility/few_shot.parquet
- config_name: loss_aversion
  data_files:
  - split: test
    path: data/loss_aversion/test.parquet
  - split: few_shot
    path: data/loss_aversion/few_shot.parquet
- config_name: gamblers_fallacy
  data_files:
  - split: test
    path: data/gamblers_fallacy/test.parquet
  - split: few_shot
    path: data/gamblers_fallacy/few_shot.parquet
- config_name: certainty_effect
  data_files:
  - split: test
    path: data/certainty_effect/test.parquet
  - split: few_shot
    path: data/certainty_effect/few_shot.parquet
- config_name: reflection_effect
  data_files:
  - split: test
    path: data/reflection_effect/test.parquet
  - split: few_shot
    path: data/reflection_effect/few_shot.parquet
- config_name: ambiguity_aversion
  data_files:
  - split: test
    path: data/ambiguity_aversion/test.parquet
  - split: few_shot
    path: data/ambiguity_aversion/few_shot.parquet
- config_name: interpret_games
  data_files:
  - split: test
    path: data/interpret_games/test.parquet
  - split: few_shot
    path: data/interpret_games/few_shot.parquet
- config_name: best_response
  data_files:
  - split: test
    path: data/best_response/test.parquet
- config_name: dominant_strategies
  data_files:
  - split: test
    path: data/dominant_strategies/test.parquet
  - split: few_shot
    path: data/dominant_strategies/few_shot.parquet
- config_name: dominated_strategies
  data_files:
  - split: test
    path: data/dominated_strategies/test.parquet
  - split: few_shot
    path: data/dominated_strategies/few_shot.parquet
- config_name: iterated_removal
  data_files:
  - split: test
    path: data/iterated_removal/test.parquet
- config_name: pure_nash
  data_files:
  - split: test
    path: data/pure_nash/test.parquet
  - split: few_shot
    path: data/pure_nash/few_shot.parquet
- config_name: backward_induction
  data_files:
  - split: test
    path: data/backward_induction/test.parquet
  - split: few_shot
    path: data/backward_induction/few_shot.parquet
- config_name: subgame_nash
  data_files:
  - split: test
    path: data/subgame_nash/test.parquet
  - split: few_shot
    path: data/subgame_nash/few_shot.parquet
- config_name: feasibility
  data_files:
  - split: test
    path: data/feasibility/test.parquet
  - split: few_shot
    path: data/feasibility/few_shot.parquet
- config_name: enforceability
  data_files:
  - split: test
    path: data/enforceability/test.parquet
  - split: few_shot
    path: data/enforceability/few_shot.parquet
- config_name: trigger
  data_files:
  - split: test
    path: data/trigger/test.parquet
  - split: few_shot
    path: data/trigger/few_shot.parquet
- config_name: bayes_nash
  data_files:
  - split: test
    path: data/bayes_nash/test.parquet
  - split: few_shot
    path: data/bayes_nash/few_shot.parquet
- config_name: pareto_sc
  data_files:
  - split: test
    path: data/pareto_sc/test.parquet
  - split: few_shot
    path: data/pareto_sc/few_shot.parquet
- config_name: sc_monotonicity_rules
  data_files:
  - split: test
    path: data/sc_monotonicity_rules/test.parquet
  - split: few_shot
    path: data/sc_monotonicity_rules/few_shot.parquet
- config_name: sc_transitivity_rules
  data_files:
  - split: test
    path: data/sc_transitivity_rules/test.parquet
  - split: few_shot
    path: data/sc_transitivity_rules/few_shot.parquet
- config_name: sc_nondictatorship
  data_files:
  - split: test
    path: data/sc_nondictatorship/test.parquet
  - split: few_shot
    path: data/sc_nondictatorship/few_shot.parquet
- config_name: plurality_voting
  data_files:
  - split: test
    path: data/plurality_voting/test.parquet
  - split: few_shot
    path: data/plurality_voting/few_shot.parquet
- config_name: borda_count
  data_files:
  - split: test
    path: data/borda_count/test.parquet
  - split: few_shot
    path: data/borda_count/few_shot.parquet
- config_name: copeland_method
  data_files:
  - split: test
    path: data/copeland_method/test.parquet
  - split: few_shot
    path: data/copeland_method/few_shot.parquet
- config_name: fair_division
  data_files:
  - split: test
    path: data/fair_division/test.parquet
  - split: few_shot
    path: data/fair_division/few_shot.parquet
- config_name: condorcet_criterion
  data_files:
  - split: test
    path: data/condorcet_criterion/test.parquet
  - split: few_shot
    path: data/condorcet_criterion/few_shot.parquet
- config_name: dsic_mechanism
  data_files:
  - split: test
    path: data/dsic_mechanism/test.parquet
  - split: few_shot
    path: data/dsic_mechanism/few_shot.parquet
- config_name: bic_mechanism
  data_files:
  - split: test
    path: data/bic_mechanism/test.parquet
  - split: few_shot
    path: data/bic_mechanism/few_shot.parquet
- config_name: ir_mechanism
  data_files:
  - split: test
    path: data/ir_mechanism/test.parquet
  - split: few_shot
    path: data/ir_mechanism/few_shot.parquet
- config_name: budget_balance
  data_files:
  - split: test
    path: data/budget_balance/test.parquet
  - split: few_shot
    path: data/budget_balance/few_shot.parquet
- config_name: top_trading
  data_files:
  - split: test
    path: data/top_trading/test.parquet
  - split: few_shot
    path: data/top_trading/few_shot.parquet
- config_name: auctions_risk
  data_files:
  - split: test
    path: data/auctions_risk/test.parquet
  - split: few_shot
    path: data/auctions_risk/few_shot.parquet
- config_name: auctions_affiliated
  data_files:
  - split: test
    path: data/auctions_affiliated/test.parquet
  - split: few_shot
    path: data/auctions_affiliated/few_shot.parquet
---

# STEER

STEER measures how well large language models reason about economic decisions, from arithmetic and probability through single-agent choice under certainty and risk, strategic reasoning in games, and decisions made on behalf of others (social choice and mechanism design). Each *element* of the paper's taxonomy is one skill, for example applying Bayes' rule or finding a pure-strategy Nash equilibrium; some elements test for behavioural biases (certainty effect, sunk cost, endowment effect) by checking that related answers are consistent.

- Paper: STEER: Assessing the Economic Rationality of Large Language Models (ICML 2024), [2402.09552](https://arxiv.org/abs/2402.09552)
- Website, with element pages and sample questions: https://steer-benchmark.cs.ubc.ca/steer
- Evaluation code: [narunraman/STEER](https://github.com/narunraman/STEER)

The companion benchmark STEER-ME is [`narunraman/steer_me`](https://huggingface.co/datasets/narunraman/steer_me).

## Contents

58 elements; `test` has 16,300 questions (20,735 rows), `few_shot` 705 questions (805 rows). A row is one question part: most questions have one part; consistency-graded questions have several.

## Loading

```python
from datasets import load_dataset

ds = load_dataset("narunraman/steer", "add_sub")   # one element: splits test and few_shot
everything = load_dataset("narunraman/steer")          # all elements (config "default")
```

There is one config per element, named after the element, and a `default` config with all of them. Every row carries its `setting` and `module`, so a setting or module is a filter: `everything["test"].filter(lambda r: r["module"] == "...")`.

## How the questions are generated

Each element has a set of question templates written for it, which vary the question type, the domain (subject matter of the story), the difficulty and, where relevant, the perspective (first person, a named third person, ...). A filler program for the element draws the numbers or other content for a template, computes the correct option, and builds the distractors from typical mistakes; options are then shuffled (unless an option refers to others by position, such as 'none of the above'). Every question is determined by `element`, `template_id` and `seed`, so it can be regenerated. This release was generated by `autosteer@0.1.0+4bf3f71`; [ELEMENTS.md](ELEMENTS.md) describes each element's templates, answer key and distractors.

Sample size: a *cell* is one combination of type, domain and difficulty within an element. Each cell has 20 test questions, and every element has at least 200 (when there are fewer than 10 cells, the floor is spread evenly over them). Questions that fail automatic checks (no or several correct options, duplicate options, unfilled placeholders) or repeat an earlier question are discarded and redrawn.

## Splits

- `test`: the benchmark.
- `few_shot`: 5 questions per question type of each element, for use as in-context examples. They come from templates that are never used for `test`: the element's own example templates where it has them, otherwise templates held out of `test` (only templates whose removal leaves every test cell covered). No `few_shot` question or template text occurs in `test`, and no `few_shot` template has the text of a template used for `test`.
  2 elements have no `few_shot` split because each of their templates is the only one of some test cell: `best_response`, `iterated_removal`.

## Fields

| field | type | meaning |
|---|---|---|
| `element` | string | element id; also the config name |
| `question_id` | string | `<element>/<base_id>/<part>`, unique in the dataset |
| `base_id` | string | one question (16 hex digits of a content hash); shared by its parts |
| `part` | int32 | 0-based part index within `base_id`; most questions have one part |
| `template_id` | string | `<element>/<pool>/<n>`: the template the question was filled from |
| `question_text` | string | the prompt |
| `options` | list<string> | answer options in presentation order, without letter labels |
| `grading` | string | `answer` or `consistency` |
| `correct_index` | int32 | 0-based index of the correct option; null for consistency-graded rows |
| `consistency_group` | string | rows scored together (`<element>/<base_id>`); null for answer-graded rows |
| `consistency_rule` | string | `<rule_id>:<allowed>`; null for answer-graded rows |
| `type` | string | question type within the element (`default` if the element has one) |
| `domain` | string | subject matter of the wording (e.g. `consumer_goods`) |
| `perspective` | string | `first_person`, `second_person`, `anon`, `man`, `woman`, `ai_assistant`; null if none |
| `tags` | list<string> | other template descriptors (may be empty) |
| `difficulty` | int32 | difficulty level within the element: 1 is its easiest, up to its number of levels; not comparable across elements |
| `setting` | string | setting of the taxonomy |
| `module` | string | module of the taxonomy |
| `generator` | string | `autosteer@<version>+<commit>` that generated the row |
| `seed` | int64 | with `element` and `template_id`, regenerates the question |

`difficulty` is relative to the element: its levels are numbered from 1 (the element's easiest) up to its number of levels, and many elements have a single level. Levels can be compared within an element, not across elements.

## Grading

**Answer-graded** rows (`grading == "answer"`) have one correct option, `options[correct_index]`. The score of an element is accuracy over its questions; a model's answer is the index of the option it chooses.

**Consistency-graded** rows (`grading == "consistency"`) have no correct option. They test for a behavioural bias: the parts of one question (rows with the same `consistency_group`) are presented separately, and the choices count as consistent if the tuple of chosen option indices, in `part` order, is one of the allowed tuples listed in `consistency_rule` (`<rule_id>:<allowed>`, tuples written as digit strings separated by commas). The score is the share of consistent groups.

```python
def consistent(choices, rule):  # choices: chosen option index per part, in part order
    allowed = rule.split(":", 1)[1].split(",")
    return "".join(map(str, choices)) in allowed
```

Example: `same_brand:02,11` means choosing option 0 in part 0 and option 2 in part 1, or option 1 in both, is consistent.

`pairwise_complete` (completeness, completeness_risk) is the exception: its comma-separated tokens are not allowed tuples but one token per part, in `part` order, of six digits `abpqic`: the part compares alternatives `a` and `b` (0-based, in the order the question describes them), and `p`, `q`, `i`, `c` are the option indices of "prefer a", "prefer b", "indifferent" and "cannot decide". The group is consistent (complete) if no part's choice is its `c`; the transitivity of the answered pairs is a secondary measure (`autosteer.release.consistency.score_transitivity`).

The rules:

| rule | elements | consistent when |
|---|---|---|
| `common_ratio_same_side` | `certainty_effect` (type two_part) | the sure option and its scaled-down version, or the lottery in both parts. |
| `ellsberg_seu` | `ambiguity_aversion` | the pairs that one subjective probability can explain (the known-odds bet in exactly one part, or indifferent in both). |
| `mirror_trade` | `endowment_effect` | Yes in exactly one part, or indifferent in both. |
| `pairwise_complete` | `completeness`, `completeness_risk` | no pair answered "cannot decide" (the answers are complete). Reported besides: whether the answered pairs are transitive. |
| `reflection_same_side` | `reflection_effect` (type two_part) | the same side in both parts. |
| `same_brand` | `independence` | the same brand in both parts, or no preference in both. |

In type `stated_prior` the question states which option the reader chose in an earlier, related choice; the keyed option is the one on the same side.

## Elements

Per setting, in paper order. [ELEMENTS.md](ELEMENTS.md) has the full description of every element (how its questions are generated, what varies, how the answer and distractors are computed, how it is graded); `elements.csv` and `elements.jsonl` have the same information for programs.

**Foundations**

| id | config | element | grading | test questions |
|---|---|---|---|---|
| 1.1.a | `add_sub` | Addition and Subtraction | answer | 200 |
| 1.1.b | `mult_div` | Multiplication and Division | answer | 240 |
| 1.1.c | `compute_expectations` | Compute Expectations | answer | 200 |
| 1.2.a | `micro_utility` | Optimize over a Discrete Set | answer | 200 |
| 1.2.b | `optimize_continuous` | Optimize a Continuous Function | answer | 200 |
| 1.2.c | `constrained_optimization` | Constrained Optimization | answer | 240 |
| 1.3.a | `prob_basic` | Compute Probabilities of Outcomes | answer | 280 |
| 1.3.b | `complement_rule` | Complement Rule | answer | 200 |
| 1.3.c | `bayes_rule` | Bayes' Rule | answer | 200 |
| 1.4.a | `categorical_syllogism` | Categorical Syllogism | answer | 200 |
| 1.4.b | `conditional_syllogism` | Conditional Syllogism | answer | 640 |
| 1.4.c | `equiv_contrapositive` | Logical Equivalence of Contrapositive | answer | 200 |
| 1.5.a | `first_order_false_belief` | First-Order False Belief | answer | 320 |
| 1.5.b | `second_order_false_belief` | Second-Order False Belief | answer | 320 |

**Decisions in Single-Agent Environments**

| id | config | element | grading | test questions |
|---|---|---|---|---|
| 2.1.a | `completeness` | Completeness | consistency | 240 |
| 2.1.b | `transitivity` | Transitivity | answer | 200 |
| 2.1.c | `independence` | Independence | consistency | 200 |
| 2.2.a | `sunk_cost` | Avoidance of the Sunk Cost Fallacy | answer | 320 |
| 2.2.b | `endowment_effect` | Avoidance of the Endowment Effect | consistency | 200 |
| 2.2.c | `time_inconsistency` | Avoidance of Time Inconsistency | answer | 200 |
| 2.3.a | `completeness_risk` | Completeness over Lotteries | consistency | 240 |
| 2.3.b | `transitivity_risk` | Transitivity over Lotteries | answer | 200 |
| 2.3.c | `independence_risk` | Independence over Lotteries | answer | 200 |
| 2.4.a | `compute_expected_utility` | Compute Expected Utility | answer | 200 |
| 2.4.b | `maximize_expected_utility` | Maximize Expected Utility | answer | 200 |
| 2.4.e | `loss_aversion` | Avoidance of Loss Averse Behavior | answer | 200 |
| 2.5.a | `gamblers_fallacy` | Avoidance of the Gambler's Fallacy | answer | 200 |
| 2.5.b | `certainty_effect` | Avoidance of the Certainty Effect | mixed | 200 |
| 2.5.c | `reflection_effect` | Avoidance of the Reflection Effect | mixed | 200 |
| 2.5.d | `ambiguity_aversion` | Avoidance of Ambiguity Aversion | consistency | 200 |

**Decisions in Multi-Agent Environments**

| id | config | element | grading | test questions |
|---|---|---|---|---|
| 3.1.a | `interpret_games` | Interpret Games | answer | 200 |
| 3.1.b | `best_response` | Best Response | answer | 200 |
| 3.1.c | `dominant_strategies` | Dominant Strategies | answer | 200 |
| 3.1.d | `dominated_strategies` | Avoidance of Dominated Strategies | answer | 200 |
| 3.1.e | `iterated_removal` | Iterated Removal of Dominated Strategies | answer | 240 |
| 3.1.f | `pure_nash` | Pure Nash Equilibrium | answer | 200 |
| 3.2.a | `backward_induction` | Backward Induction | answer | 200 |
| 3.2.b | `subgame_nash` | Subgame-Perfect Nash Equilibrium | answer | 480 |
| 3.4.a | `feasibility` | Feasibility in Infinitely Repeated Games | answer | 240 |
| 3.4.b | `enforceability` | Enforceability in Infinitely Repeated Games | answer | 200 |
| 3.4.c | `trigger` | Trigger Strategies | answer | 200 |
| 3.5.a | `bayes_nash` | Bayes-Nash Equilibrium | answer | 200 |

**Decisions on Behalf of Other Agents**

| id | config | element | grading | test questions |
|---|---|---|---|---|
| 4.1.a | `pareto_sc` | Pareto Efficiency in Social Welfare Functions | answer | 240 |
| 4.1.b | `sc_monotonicity_rules` | Monotonicity in Social Welfare Functions | answer | 240 |
| 4.1.c | `sc_transitivity_rules` | Transitivity in Social Welfare Functions | answer | 240 |
| 4.1.d | `sc_nondictatorship` | Non-Dictatorial Social Welfare Function | answer | 360 |
| 4.2.a | `plurality_voting` | Plurality Vote | answer | 200 |
| 4.2.b | `borda_count` | Borda Count | answer | 200 |
| 4.2.c | `copeland_method` | Copeland's Method | answer | 480 |
| 4.2.d | `fair_division` | Fair Division Algorithms | answer | 200 |
|  | `condorcet_criterion` | Condorcet Winner | answer | 200 |
| 4.3.a | `dsic_mechanism` | Dominant Strategy Incentive Compatibility | answer | 380 |
| 4.3.b | `bic_mechanism` | Bayesian Incentive Compatibility | answer | 800 |
| 4.3.c | `ir_mechanism` | Individual Rationality | answer | 640 |
| 4.3.d | `budget_balance` | Budget Balanced | answer | 480 |
| 4.4.a | `top_trading` | Top Trading Cycles | answer | 400 |
| 4.4.b | `auctions_risk` | Optimal Auction for Bidders with Differing Risk Attitudes | answer | 480 |
| 4.4.c | `auctions_affiliated` | Optimal Auction for Bidders with Affiliated Values | answer | 960 |

## License

Creative Commons Attribution 4.0 International (CC BY 4.0). You may share and adapt the data with attribution; please cite the paper below.

## Citation

```bibtex
@inproceedings{ramansteer,
  author    = {Narun Krishnamurthi Raman and Taylor Lundy and
               Samuel Joseph Amouyal and Yoav Levine and
               Kevin Leyton{-}Brown and Moshe Tennenholtz},
  title     = {{STEER:} {A}ssessing the {E}conomic {R}ationality of
               {L}arge {L}anguage {M}odels},
  booktitle = {Forty-first International Conference on Machine Learning,
               {ICML} 2024, Vienna, Austria, July 21-27, 2024},
  publisher = {OpenReview.net},
  year      = {2024},
  url       = {https://openreview.net/forum?id=nU1mtFDtMX}
}
```