rule_id stringlengths 14 43 | label stringlengths 9 65 | family stringclasses 5
values | code stringlengths 21 163 |
|---|---|---|---|
train_rank_odd | odd ranks | static_rank | return card.rank % 2 == 1 |
train_suit_hearts | hearts only | static_suit_color | return card.suit == "hearts" |
train_combo_black_low | black ranks ace through 7 | static_combo | return card.color == "black" and card.rank <= 7 |
train_seq_same_color | same color as previous card | previous_card | if not mainline:
return True
return card.color == mainline[-1].color |
train_pair_colors | colors appear in pairs and each pair changes color | pair_position | if not mainline:
return True
if len(mainline) % 2 == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color |
train_rank_low_1_6 | ranks ace through 6 | static_rank | return card.rank <= 6 |
train_suit_no_diamonds | anything except diamonds | static_suit_color | return card.suit != "diamonds" |
train_combo_red_face | red face cards | static_combo | return card.color == "red" and card.rank >= 11 |
train_pair_parity | rank parity appears in pairs and each pair changes parity | pair_position | if not mainline:
return True
if len(mainline) % 2 == 0:
return (card.rank % 2) != (mainline[-1].rank % 2)
return (card.rank % 2) == (mainline[-1].rank % 2) |
train_rank_high_8_13 | ranks 8 through king | static_rank | return card.rank >= 8 |
train_suit_black | black cards | static_suit_color | return card.color == "black" |
train_combo_red_odd_black_even | red odd cards and black even cards | static_combo | if card.color == "red":
return card.rank % 2 == 1
return card.rank % 2 == 0 |
train_seq_same_suit | same suit as previous card | previous_card | if not mainline:
return True
return card.suit == mainline[-1].suit |
train_rank_middle_4_10 | ranks 4 through 10 | static_rank | return 4 <= card.rank <= 10 |
train_suit_hearts_or_clubs | hearts or clubs | static_suit_color | return card.suit in {"hearts", "clubs"} |
train_rank_non_prime | non-prime ranks | static_rank | primes = {2, 3, 5, 7, 11, 13}
return card.rank not in primes |
train_seq_same_rank | same rank as previous card | previous_card | if not mainline:
return True
return card.rank == mainline[-1].rank |
train_rank_kings | only kings | static_rank | return card.rank == 13 |
train_seq_same_parity | same rank parity as previous card | previous_card | if not mainline:
return True
return (card.rank % 2) == (mainline[-1].rank % 2) |
train_seq_strict_increase | rank strictly increases | previous_card | if not mainline:
return True
return card.rank > mainline[-1].rank |
train_seq_strict_decrease | rank strictly decreases | previous_card | if not mainline:
return True
return card.rank < mainline[-1].rank |
train_seq_non_increasing | rank does not increase | previous_card | if not mainline:
return True
return card.rank <= mainline[-1].rank |
train_seq_rank_diff_exactly_one | rank changes by exactly 1 | previous_card | if not mainline:
return True
return abs(card.rank - mainline[-1].rank) == 1 |
train_seq_rank_diff_at_most_one | rank changes by at most 1 | previous_card | if not mainline:
return True
return abs(card.rank - mainline[-1].rank) <= 1 |
train_seq_rank_diff_at_most_two | rank changes by at most 2 | previous_card | if not mainline:
return True
return abs(card.rank - mainline[-1].rank) <= 2 |
train_seq_rank_diff_at_least_three | rank changes by at least 3 | previous_card | if not mainline:
return True
return abs(card.rank - mainline[-1].rank) >= 3 |
train_seq_same_low_high_group | same low/high rank group as previous card | previous_card | if not mainline:
return True
return (card.rank >= 8) == (mainline[-1].rank >= 8) |
train_seq_different_low_high_group | different low/high rank group than previous card | previous_card | if not mainline:
return True
return (card.rank >= 8) != (mainline[-1].rank >= 8) |
train_seq_same_face_status | same face/number status as previous card | previous_card | if not mainline:
return True
return (card.rank >= 11) == (mainline[-1].rank >= 11) |
train_seq_red_down_black_up | red previous goes down, black previous goes up | previous_card | if not mainline:
return 5 <= card.rank <= 9
prev = mainline[-1]
if prev.color == "red":
return card.rank <= prev.rank
return card.rank >= prev.rank |
train_seq_suit_cycle_dchs | suits cycle diamonds, clubs, hearts, spades | previous_card | if not mainline:
return True
order = ["diamonds", "clubs", "hearts", "spades"]
idx = order.index(mainline[-1].suit)
return card.suit == order[(idx + 1) % 4] |
train_seq_face_diff_color_number_same_color | faces require different color, numbers require same color | previous_card | if not mainline:
return True
prev = mainline[-1]
if prev.rank >= 11:
return card.color != prev.color
return card.color == prev.color |
train_seq_share_suit_or_parity | same suit or same rank parity as previous card | previous_card | if not mainline:
return True
prev = mainline[-1]
return card.suit == prev.suit or (card.rank % 2) == (prev.rank % 2) |
train_suit_clubs | clubs only | static_suit_color | return card.suit == "clubs" |
train_suit_diamonds | diamonds only | static_suit_color | return card.suit == "diamonds" |
train_suit_no_hearts | no hearts | static_suit_color | return card.suit != "hearts" |
train_suit_hearts_or_spades | hearts or spades | static_suit_color | return card.suit in {"hearts", "spades"} |
train_rank_even_low_set | even ranks up to eight | static_rank | return card.rank in {2, 4, 6, 8} |
train_rank_low_1_3 | ranks one to three | static_rank | return card.rank <= 3 |
train_rank_high_10_13 | ranks ten and up | static_rank | return card.rank >= 10 |
train_rank_band_7_11 | ranks seven to eleven | static_rank | return 7 <= card.rank <= 11 |
train_combo_black_high | black high cards | static_combo | return card.color == "black" and card.rank >= 10 |
train_seq_different_mid_group | alternate low and mid-high vs previous (threshold five) | previous_card | if not mainline:
return True
return (card.rank >= 5) != (mainline[-1].rank >= 5) |
train_pair_suits | pairs share suit (opposite phase) | pair_position | if not mainline:
return True
if len(mainline) % 2 == 0:
return card.suit == mainline[-1].suit
return card.suit != mainline[-1].suit |
train_pair_ranks | pairs share rank (opposite phase) | pair_position | if not mainline:
return True
if len(mainline) % 2 == 0:
return card.rank == mainline[-1].rank
return card.rank != mainline[-1].rank |
train_rank_even_red | red even ranks | static_combo | return card.color == "red" and card.rank % 2 == 0 |
train_rank_even_black | black even ranks | static_combo | return card.color == "black" and card.rank % 2 == 0 |
train_rank_even_or_king | even ranks or kings | static_rank | return card.rank % 2 == 0 or card.rank == 13 |
train_rank_odd_primes | odd primes | static_rank | return card.rank in {3, 5, 7, 11, 13} |
train_seq_different_high_group_10 | alternate low and high vs previous (threshold ten) | previous_card | if not mainline:
return True
return (card.rank >= 10) != (mainline[-1].rank >= 10) |
train_seq_group_hc_ds | alternate between hearts+clubs and diamonds+spades | previous_card | if not mainline:
return True
group_a = {"hearts", "clubs"}
return (card.suit in group_a) != (mainline[-1].suit in group_a) |
train_seq_face_same_color_number_diff_color | after a face card same color, after a number card different color | previous_card | if not mainline:
return True
prev = mainline[-1]
if prev.is_face:
return card.color == prev.color
return card.color != prev.color |
eleusis-hf-rules
Rule library for the eleusis
inductive-reasoning environment. Each rule is a Python predicate over
(card, mainline).
- test (26 rules): the rules of the HF eleusis benchmark, verified behaviorally identical to the benchmark repository's library.
- train (52 rules): a training set matched to the test split — exactly 2x its family mix and closely matched acceptance-rate distribution — with zero behavioral overlap with the test rules (verified by extension-signature comparison over a probe battery).
Columns: rule_id, label, family, code.
- Downloads last month
- 194