Hugging Face's logo

Datasets:
nph4rd
/
eleusis-small-rules

Modalities:
Text
Formats:
parquet
Size:
1K - 10K
Tags:
eleusis
induction
reasoning
rules
card-games
Libraries:
Datasets
pandas
Polars
License:
Dataset card Data Studio Files
xet
 Community
1
Dataset Viewer
Auto-converted to Parquet Duplicate
rule
stringlengths
18
75
(value + prev_value) % 6 == 0
(abs(value - prev_value) > 4) or (value % 3 == n % 3)
(color != prev_color) or (abs(value - prev_value) == 5)
(value < prev_value) or (value % 2 == prev_value % 2)
(value - prev_value) % 5 == 2
(value > prev_value) or (value % 3 != prev_value % 3)
(value % 2 != prev_value % 2) and (value != min(values))
(abs(value - prev_value) != 4) or (value < max(values))
(color != prev_color) and (abs(value - prev_value) < 4)
(value >= prev_value) and (value % 2 == prev_value % 2)
(abs(value - prev_value) > 5) or (value % 4 == n % 4)
(value <= max(values)) and (value % 3 == n % 3)
(value > min(values)) or (value >= max(values))
(value % 4 == prev_value % 4) or (value <= min(values))
(color == prev_color) and (value % 6 != prev_value % 6)
(color == prev_color) and (value % 3 != prev_value % 3)
(color == prev_color) or (value == max(values))
(abs(value - prev_value) < 5) or (value <= min(values))
(abs(value - prev_value) > 6) or (value >= min(values))
(abs(value - prev_value) == 4) or (value % 5 == n % 5)
(color == prev_color) or (value > min(values))
abs(value - prev_value) == 3
(abs(value - prev_value) == 2) or (value < min(values))
value <= prev_value if color == prev_color else value < prev_value
(abs(value - prev_value) != 5) and (value != max(values))
value >= prev_value if color == prev_color else value != prev_value
(value + prev_value) % 6 == 5
(color == prev_color) or (abs(value - prev_value) < 1)
(value % 3 != prev_value % 3) or (value != max(values))
(abs(value - prev_value) != 1) and (value % 2 == n % 2)
(color == prev_color) or (value % 4 == prev_value % 4)
(value != max(values)) and (value % 2 == n % 2)
(value % 6 != prev_value % 6) or (value == max(values))
(value != prev_value) and (value % 5 == n % 5)
(value % 2 == prev_value % 2) or (value != min(values))
(value + sum(values)) % 3 == 2
value > prev_value if color == prev_color else value != prev_value
(value % 4 != prev_value % 4) or (value < min(values))
value == prev_value if color == prev_color else value > prev_value
(value % 3 != prev_value % 3) or (value < max(values))
(value % 4 == n % 4) or (value == prev_value + 1)
(abs(value - prev_value) != 3) and (value % 4 == n % 4)
(value % 5 == prev_value % 5) or (value % 6 == prev_value % 6)
(value % 3 == n % 3) or (value == prev_value + 2)
(abs(value - prev_value) > 2) or (value == max(values))
abs(value - prev_value) < 4
(value % 5 == prev_value % 5) or (value % 4 == n % 4)
(abs(value - prev_value) == 2) or (value >= max(values))
(value > prev_value) or (value % 5 == n % 5)
(value != max(values)) or (value == prev_value + 1)
(abs(value - prev_value) > 2) or (value == min(values))
value != min(values)
(abs(value - prev_value) != 2) and (abs(value - prev_value) < 5)
(value >= min(values)) and (value <= max(values))
(value == min(values)) or (value == prev_value + 1)
(value < max(values)) or (value % 3 == n % 3)
(abs(value - prev_value) > 4) or (value != min(values))
(value % 4 == prev_value % 4) or (value >= prev_value + 2)
(abs(value - prev_value) != 1) and (value >= max(values))
(abs(value - prev_value) < 4) or (value != max(values))
(value > prev_value) or (value % 4 != prev_value % 4)
(value % 2 != prev_value % 2) or (value % 5 == n % 5)
(value < prev_value) or (value % 3 == n % 3)
(value % 4 == prev_value % 4) or (abs(value - prev_value) == 3)
(abs(value - prev_value) != 4) and (value == min(values))
(abs(value - prev_value) > 2) and (value != min(values))
(abs(value - prev_value) > 1) and (value % 2 == n % 2)
(abs(value - prev_value) == 1) and (value >= min(values))
(value % 3 != prev_value % 3) or (value == prev_value + 3)
(abs(value - prev_value) < 2) or (value % 4 == n % 4)
(abs(value - prev_value) != 4) and (value >= min(values))
(color != prev_color) and (abs(value - prev_value) != 5)
(value + sum(values)) % 5 == 4
(abs(value - prev_value) == 4) or (value >= prev_value + 2)
(color != prev_color) and (abs(value - prev_value) == 1)
(value <= min(values)) or (value == prev_value + 1)
(value < prev_value) or (abs(value - prev_value) == 5)
(value != prev_value) and (abs(value - prev_value) < 3)
(abs(value - prev_value) == 6) or (value != max(values))
(abs(value - prev_value) == 2) or (abs(value - prev_value) > 3)
(value >= min(values)) or (value % 4 == n % 4)
(abs(value - prev_value) < 1) or (value > max(values))
(abs(value - prev_value) == 1) and (value % 5 == n % 5)
(value % 3 != prev_value % 3) or (value % 4 == n % 4)
(abs(value - prev_value) != 2) or (value > min(values))
(abs(value - prev_value) != 3) or (value <= min(values))
(value > prev_value) or (abs(value - prev_value) == 6)
(value == min(values)) or (value >= prev_value + 3)
(color != prev_color) and (abs(value - prev_value) == 3)
(abs(value - prev_value) < 5) and (value % 4 == n % 4)
(value % 6 == prev_value % 6) or (value > max(values))
(value < prev_value) or (value == prev_value + 1)
(value % 2 == prev_value % 2) or (value % 2 == n % 2)
(value - prev_value) % 6 == 5
(abs(value - prev_value) != 6) and (value <= min(values))
(abs(value - prev_value) > 4) or (value >= prev_value + 3)
(value % 4 != prev_value % 4) and (value != max(values))
(value < prev_value) or (abs(value - prev_value) != 6)
(abs(value - prev_value) == 3) or (value == prev_value + 2)
(abs(value - prev_value) > 5) or (value == max(values))
End of preview. Expand in Data Studio

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

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.
Downloads last month
43
Number of rows:
1,730
Total file size:
32.5 kB