README.md

---
pretty_name: Eleusis Rules (52-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
  - name: difficulty
    dtype: string
  splits:
  - name: train
    num_bytes: 23075
    num_examples: 359
  - name: test
    num_bytes: 5697
    num_examples: 90
  download_size: 9490
  dataset_size: 28772
---

# Eleusis Rules

Secret **induction rules** for the `eleusis` single-agent environment — a faithful,
full **52-card** implementation of the card game *Eleusis Express*, where a model discovers a hidden
card-sequence rule by playing (with mainline/sideline, No-Play, rule-guessing, and authentic scoring).
This dataset is the rule bank the environment draws its secret rules from.

Each row is one rule over a **standard 52-card deck**: suits C/D/H/S × ranks 1–13 (A=1, J=11, Q=12,
K=13), with color derived from suit (D,H = Red; C,S = Black).

## Splits

| split | rows |
|---|---|
| `train` | 1873 |
| `test` | 465 |

An **80/20 stratified** split: rules are bucketed by a label-free structural signature (which card
attributes and operator classes they use — suit/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%).

## 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-rules", split="train")
test  = load_dataset("nph4rd/eleusis-rules", split="test")
test[0]   # {'rule': 'suit != prev_suit'}
```

## 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` (=rank), `rank`, `suit`, `color`, `prev_value`, `prev_rank`, `prev_suit`, `prev_color`,
`values`, `ranks`, `suits`, `colors`, `n` (plus `abs/len/min/max/sum`). Examples:

```text
suit != prev_suit
color != prev_color
value >= prev_value
value % 3 == prev_value % 3
abs(value - prev_value) <= 3
value == prev_value if color != prev_color else value > prev_value
```

## How the rules were produced

1. **Enumerate** a broad space of relational rule expressions over the 52-card DSL (suit/color patterns,
   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) — Express's "the rule should at some point
   encompass every card, with no condition that terminates the sequence". Impossible and purely
   card-intrinsic rules are removed; only genuinely sequence-dependent rules survive.
3. **Deduplicate by behavioral signature** (legality over a fixed probe set of histories), so
   functionally-identical surface forms collapse to a single canonical entry.

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

## Related

- `nph4rd/eleusis-small-rules` — the analogous bank on an abstract 16-card deck, used as a single-agent
  induction **benchmark**.
- Used by the `eleusis` verifiers environment; see its README for the full game
  protocol (play / No-Play / guess), the draw-from-stock mechanic, and the authentic
  `12 − cards_left + 6·guess + 3·empty` scoring.