README.md

---
pretty_name: Eleusis-Small Rules (16-card)
license: mit
tags:
- eleusis
- induction
- reasoning
- rules
- card-games
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: test
    path: data/test-*
dataset_info:
  features:
  - name: rule
    dtype: string
  splits:
  - name: train
    num_bytes: 79203
    num_examples: 1384
  - name: test
    num_bytes: 19674
    num_examples: 346
  download_size: 26385
  dataset_size: 98877
---

# Eleusis-Small Rules

Secret **induction rules** for the `eleusis-small` single-agent benchmark — a verifiers environment
where a model discovers a hidden card-sequence rule by playing. This dataset is the rule bank the
environment draws its secret rules from.

Each row is one rule on the **abstract 16-card deck** (`color ∈ {R, B}` × `value ∈ 1..8`).

## Splits

| split | rows |
|---|---|
| `train` | 1384 |
| `test` | 346 |

An **80/20 stratified** split: rules are bucketed by a label-free structural signature (which card
attributes and operator classes they use — color, modular, absolute-difference, history aggregates,
boolean compounds, conditionals) and each bucket is split 80/20, so **train and test share the same
structural distribution** (per-bucket shares match within ~0.1%). Use `train` for training a solver and
`test` as the held-out benchmark.

## Schema

| column | type | description |
|---|---|---|
| `rule` | string | a Python boolean expression deciding whether a card may legally follow the previous card |

```python
from datasets import load_dataset
train = load_dataset("nph4rd/eleusis-small-rules", split="train")
test  = load_dataset("nph4rd/eleusis-small-rules", split="test")
test[0]   # {'rule': 'value % 2 == n % 2'}
```

## The rule DSL

A rule is a sandboxed boolean Python expression over a fixed namespace describing the candidate card,
the legal sequence so far, and the previous card:

`value`, `color`, `prev_value`, `prev_color`, `values`, `colors`, `n`
(plus `abs/len/min/max/sum`). Examples:

```text
color != prev_color
value >= prev_value
value % 3 == prev_value % 3
abs(value - prev_value) <= 2
value > prev_value if color == prev_color else value < prev_value
(value + sum(values)) % 2 == 0
```

## How the rules were produced

1. **Enumerate** a broad space of relational rule expressions (alternation, order, parity/modular,
   absolute-difference, products, history aggregates, boolean compounds, conditionals).
2. **Validate** each against the faithfulness guard: *every* card in the deck must be legal in some
   reachable sequence state (no card permanently excluded, no terminating condition) **and** the rule
   must discriminate (reject some card in some state). This removes impossible and purely card-intrinsic
   ("even cards only") rules — only genuinely sequence-dependent rules survive.
3. **Deduplicate by behavioral signature** (legality over a fixed probe set of histories), so
   functionally-identical surface forms (`a != b` vs `b != a`, redundant parentheses, …) collapse to a
   single canonical entry.

The result is **1730 functionally-distinct, guaranteed-playable rules**. Difficulty coverage is
emergent — from trivial color alternation to compound conditional and history-dependent rules — with no
manual difficulty/family labels.

## Related

- `nph4rd/eleusis-rules` — the analogous bank for the **standard 52-card** authentic game.
- Used by the `eleusis-small` verifiers environment (single-agent benchmark); see its README for the
  full game protocol and the chance-corrected-skill metric.