rule_id stringlengths 54 83 | label stringlengths 35 160 | family stringclasses 8
values | code stringlengths 70 421 |
|---|---|---|---|
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0000_00000 | inverse policy: chunks of 7 alternate same-color and opposite-parity policies [training variant 1/20] | chunk_run | train_variant_marker = (len(mainline) + 0) % 2
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 7
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0001_00001 | inverse policy: chunks of 6 alternate same-color and opposite-parity policies [training variant 2/20] | chunk_run | train_variant_marker = (len(mainline) + 1) % 3
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 6
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0002_00002 | inverse policy: chunks of 5 alternate same-color and opposite-parity policies [training variant 3/20] | chunk_run | train_variant_marker = (len(mainline) + 2) % 4
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 5
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0003_00003 | inverse policy: chunks of 3 alternate same-color and opposite-parity policies [training variant 4/20] | chunk_run | train_variant_marker = (len(mainline) + 3) % 5
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 3
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0004_00004 | inverse policy: chunks of 4 alternate same-color and opposite-parity policies [training variant 5/20] | chunk_run | train_variant_marker = (len(mainline) + 4) % 6
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 4
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0005_00005 | inverse policy: chunks of 7 alternate same-color and opposite-parity policies [training variant 6/20] | chunk_run | train_variant_marker = (len(mainline) + 5) % 7
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 7
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0006_00006 | inverse policy: chunks of 6 alternate same-color and opposite-parity policies [training variant 7/20] | chunk_run | train_variant_marker = (len(mainline) + 6) % 8
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 6
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0007_00007 | inverse policy: chunks of 5 alternate same-color and opposite-parity policies [training variant 8/20] | chunk_run | train_variant_marker = (len(mainline) + 7) % 9
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 5
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
re... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0008_00008 | inverse policy: chunks of 3 alternate same-color and opposite-parity policies [training variant 9/20] | chunk_run | train_variant_marker = (len(mainline) + 8) % 10
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 3
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
r... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0009_00009 | inverse policy: chunks of 4 alternate same-color and opposite-parity policies [training variant 10/20] | chunk_run | train_variant_marker = (len(mainline) + 9) % 11
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 4
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
r... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0010_00010 | inverse policy: chunks of 7 alternate same-color and opposite-parity policies [training variant 11/20] | chunk_run | train_variant_marker = (len(mainline) + 10) % 12
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 7
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0011_00011 | inverse policy: chunks of 6 alternate same-color and opposite-parity policies [training variant 12/20] | chunk_run | train_variant_marker = (len(mainline) + 11) % 13
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 6
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0012_00012 | inverse policy: chunks of 5 alternate same-color and opposite-parity policies [training variant 13/20] | chunk_run | train_variant_marker = (len(mainline) + 12) % 14
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 5
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0013_00013 | inverse policy: chunks of 3 alternate same-color and opposite-parity policies [training variant 14/20] | chunk_run | train_variant_marker = (len(mainline) + 13) % 15
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 3
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0014_00014 | inverse policy: chunks of 4 alternate same-color and opposite-parity policies [training variant 15/20] | chunk_run | train_variant_marker = (len(mainline) + 14) % 16
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 4
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0015_00015 | inverse policy: chunks of 7 alternate same-color and opposite-parity policies [training variant 16/20] | chunk_run | train_variant_marker = (len(mainline) + 15) % 17
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 7
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0016_00016 | inverse policy: chunks of 6 alternate same-color and opposite-parity policies [training variant 17/20] | chunk_run | train_variant_marker = (len(mainline) + 16) % 18
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 6
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0017_00017 | inverse policy: chunks of 5 alternate same-color and opposite-parity policies [training variant 18/20] | chunk_run | train_variant_marker = (len(mainline) + 17) % 19
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 5
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0018_00018 | inverse policy: chunks of 3 alternate same-color and opposite-parity policies [training variant 19/20] | chunk_run | train_variant_marker = (len(mainline) + 18) % 20
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 3
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_alternating_chunk_policy_0019_00019 | inverse policy: chunks of 4 alternate same-color and opposite-parity policies [training variant 20/20] | chunk_run | train_variant_marker = (len(mainline) + 19) % 21
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
chunk = len(mainline) // 4
if chunk % 2 == 0:
return card.color == prev.color
return card.rank % 2 != prev.rank % 2
if not mainline:
return True
... |
train_earlyfilter_v072_chunk_run_boundary_exception_0000_00020 | suits repeat in chunks of 2 and rank moves down at boundaries [training variant 1/84] | chunk_run | train_variant_marker = (len(mainline) + 20) % 22
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 2 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0001_00021 | suits repeat in chunks of 3 and rank moves down at boundaries [training variant 2/84] | chunk_run | train_variant_marker = (len(mainline) + 21) % 23
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 3 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0002_00022 | suit matches within chunks of 8; rank within 6 at boundaries [training variant 3/84] | chunk_run | train_variant_marker = (len(mainline) + 22) % 24
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0003_00023 | suit matches within chunks of 6; rank within 5 at boundaries [training variant 4/84] | chunk_run | train_variant_marker = (len(mainline) + 23) % 25
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0004_00024 | suit matches within chunks of 5; rank within 6 at boundaries [training variant 5/84] | chunk_run | train_variant_marker = (len(mainline) + 24) % 26
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0005_00025 | suit matches within chunks of 7; rank within 4 at boundaries [training variant 6/84] | chunk_run | train_variant_marker = (len(mainline) + 25) % 27
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0006_00026 | suit matches within chunks of 5; rank within 4 at boundaries [training variant 7/84] | chunk_run | train_variant_marker = (len(mainline) + 26) % 28
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0007_00027 | suit matches within chunks of 7; rank within 7 at boundaries [training variant 8/84] | chunk_run | train_variant_marker = (len(mainline) + 27) % 29
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0008_00028 | suit matches within chunks of 6; rank within 3 at boundaries [training variant 9/84] | chunk_run | train_variant_marker = (len(mainline) + 28) % 30
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0009_00029 | suit matches within chunks of 4; rank within 4 at boundaries [training variant 10/84] | chunk_run | train_variant_marker = (len(mainline) + 29) % 31
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0010_00030 | suit matches within chunks of 7; rank within 5 at boundaries [training variant 11/84] | chunk_run | train_variant_marker = (len(mainline) + 30) % 32
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0011_00031 | suit matches within chunks of 6; rank within 7 at boundaries [training variant 12/84] | chunk_run | train_variant_marker = (len(mainline) + 31) % 33
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0012_00032 | suit matches within chunks of 8; rank within 4 at boundaries [training variant 13/84] | chunk_run | train_variant_marker = (len(mainline) + 32) % 34
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0013_00033 | suit matches within chunks of 6; rank within 6 at boundaries [training variant 14/84] | chunk_run | train_variant_marker = (len(mainline) + 33) % 35
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0014_00034 | suit matches within chunks of 5; rank within 5 at boundaries [training variant 15/84] | chunk_run | train_variant_marker = (len(mainline) + 34) % 36
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0015_00035 | suit matches within chunks of 5; rank within 7 at boundaries [training variant 16/84] | chunk_run | train_variant_marker = (len(mainline) + 35) % 37
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0016_00036 | suit matches within chunks of 4; rank within 7 at boundaries [training variant 17/84] | chunk_run | train_variant_marker = (len(mainline) + 36) % 38
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0017_00037 | suit matches within chunks of 7; rank within 6 at boundaries [training variant 18/84] | chunk_run | train_variant_marker = (len(mainline) + 37) % 39
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0018_00038 | suit matches within chunks of 6; rank within 4 at boundaries [training variant 19/84] | chunk_run | train_variant_marker = (len(mainline) + 38) % 40
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0019_00039 | suit matches within chunks of 8; rank within 5 at boundaries [training variant 20/84] | chunk_run | train_variant_marker = (len(mainline) + 39) % 41
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0020_00040 | suit matches within chunks of 4; rank within 6 at boundaries [training variant 21/84] | chunk_run | train_variant_marker = (len(mainline) + 40) % 42
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0021_00041 | suit matches within chunks of 5; rank within 3 at boundaries [training variant 22/84] | chunk_run | train_variant_marker = (len(mainline) + 41) % 43
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0022_00042 | suit matches within chunks of 8; rank within 7 at boundaries [training variant 23/84] | chunk_run | train_variant_marker = (len(mainline) + 42) % 44
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0023_00043 | suit matches within chunks of 7; rank within 3 at boundaries [training variant 24/84] | chunk_run | train_variant_marker = (len(mainline) + 43) % 45
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0024_00044 | inverse policy: within chunks of 2: same color and rank within 7; boundaries unrestricted [training variant 25/84] | chunk_run | train_variant_marker = (len(mainline) + 44) % 46
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 7
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0025_00045 | inverse policy: within chunks of 2: same color and rank within 8; boundaries unrestricted [training variant 26/84] | chunk_run | train_variant_marker = (len(mainline) + 45) % 47
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 8
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0026_00046 | inverse policy: color matches within chunks of 3 with rank distance at most 5; alternates at boundaries [training variant 27/84] | chunk_run | train_variant_marker = (len(mainline) + 46) % 48
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 3
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0027_00047 | inverse policy: color matches within chunks of 4 with rank distance at most 6; alternates at boundaries [training variant 28/84] | chunk_run | train_variant_marker = (len(mainline) + 47) % 49
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 6
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0028_00048 | inverse policy: rank parity is different within chunks of 7 and matches at boundaries [training variant 29/84] | chunk_run | train_variant_marker = (len(mainline) + 48) % 50
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 7 == 0:
return card.rank % 2 == mainline[-1].rank % 2
return card.rank % 2 != mainline[-1].rank % 2
if not mainline:
return True
return not train_base_rul... |
train_earlyfilter_v072_chunk_run_boundary_exception_0029_00049 | inverse policy: rank is different within chunks of 3 and matches at boundaries [training variant 30/84] | chunk_run | train_variant_marker = (len(mainline) + 49) % 51
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 3 == 0:
return card.rank == mainline[-1].rank
return card.rank != mainline[-1].rank
if not mainline:
return True
return not train_base_rule(card, mainline... |
train_earlyfilter_v072_chunk_run_boundary_exception_0030_00050 | inverse policy: suits repeat in chunks of 4 and rank moves down at boundaries [training variant 31/84] | chunk_run | train_variant_marker = (len(mainline) + 50) % 52
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 4 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit
if not mainline:
return True
return ... |
train_earlyfilter_v072_chunk_run_boundary_exception_0031_00051 | inverse policy: rank is same within chunks of 5 and changes at boundaries [training variant 32/84] | chunk_run | train_variant_marker = (len(mainline) + 51) % 53
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 5 == 0:
return card.rank != mainline[-1].rank
return card.rank == mainline[-1].rank
if not mainline:
return True
return not train_base_rule(card, mainline... |
train_earlyfilter_v072_chunk_run_boundary_exception_0032_00052 | inverse policy: suit matches within chunks of 4; rank within 3 at boundaries [training variant 33/84] | chunk_run | train_variant_marker = (len(mainline) + 52) % 54
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit
if not m... |
train_earlyfilter_v072_chunk_run_boundary_exception_0033_00053 | inverse policy: suit matches within chunks of 4; rank within 5 at boundaries [training variant 34/84] | chunk_run | train_variant_marker = (len(mainline) + 53) % 55
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit
if not m... |
train_earlyfilter_v072_chunk_run_boundary_exception_0034_00054 | inverse policy: within chunks of 2: same color and rank within 5; boundaries unrestricted [training variant 35/84] | chunk_run | train_variant_marker = (len(mainline) + 54) % 56
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0035_00055 | inverse policy: color matches within chunks of 4 with rank distance at most 7; alternates at boundaries [training variant 36/84] | chunk_run | train_variant_marker = (len(mainline) + 55) % 57
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 7
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0036_00056 | inverse policy: rank parity is different within chunks of 5 and matches at boundaries [2->4] [training variant 37/84] | chunk_run | train_variant_marker = (len(mainline) + 56) % 58
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 5 == 0:
return card.rank % 4 == mainline[-1].rank % 4
return card.rank % 4 != mainline[-1].rank % 4
if not mainline:
return True
return not train_base_rul... |
train_earlyfilter_v072_chunk_run_boundary_exception_0037_00057 | inverse policy: suit matches within chunks of 8; rank within 3 at boundaries [training variant 38/84] | chunk_run | train_variant_marker = (len(mainline) + 57) % 59
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit
if not m... |
train_earlyfilter_v072_chunk_run_boundary_exception_0038_00058 | inverse policy: within chunks of 4: same color and rank within 6; boundaries unrestricted [training variant 39/84] | chunk_run | train_variant_marker = (len(mainline) + 58) % 60
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 4 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 6
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0039_00059 | inverse policy: color matches within chunks of 6 with rank distance at most 5; alternates at boundaries [training variant 40/84] | chunk_run | train_variant_marker = (len(mainline) + 59) % 61
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 6
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0040_00060 | inverse policy: rank parity is different within chunks of 5 and matches at boundaries [2->3] [training variant 41/84] | chunk_run | train_variant_marker = (len(mainline) + 60) % 62
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 5 == 0:
return card.rank % 3 == mainline[-1].rank % 3
return card.rank % 3 != mainline[-1].rank % 3
if not mainline:
return True
return not train_base_rul... |
train_earlyfilter_v072_chunk_run_boundary_exception_0041_00061 | inverse policy: color matches within chunks of 4 with rank distance at most 3; alternates at boundaries [training variant 42/84] | chunk_run | train_variant_marker = (len(mainline) + 61) % 63
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 3
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0042_00062 | inverse policy: within chunks of 3: same color and rank within 6; boundaries unrestricted [training variant 43/84] | chunk_run | train_variant_marker = (len(mainline) + 62) % 64
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 3 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 6
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0043_00063 | inverse policy: color matches within chunks of 2 with rank distance at most 5; alternates at boundaries [training variant 44/84] | chunk_run | train_variant_marker = (len(mainline) + 63) % 65
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 2
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0044_00064 | suits repeat in chunks of 2 and rank moves down at boundaries [training variant 45/84] | chunk_run | train_variant_marker = (len(mainline) + 64) % 66
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 2 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0045_00065 | suits repeat in chunks of 3 and rank moves down at boundaries [training variant 46/84] | chunk_run | train_variant_marker = (len(mainline) + 65) % 67
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 3 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0046_00066 | suit matches within chunks of 8; rank within 6 at boundaries [training variant 47/84] | chunk_run | train_variant_marker = (len(mainline) + 66) % 68
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0047_00067 | suit matches within chunks of 6; rank within 5 at boundaries [training variant 48/84] | chunk_run | train_variant_marker = (len(mainline) + 67) % 69
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0048_00068 | suit matches within chunks of 5; rank within 6 at boundaries [training variant 49/84] | chunk_run | train_variant_marker = (len(mainline) + 68) % 70
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0049_00069 | suit matches within chunks of 7; rank within 4 at boundaries [training variant 50/84] | chunk_run | train_variant_marker = (len(mainline) + 69) % 71
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0050_00070 | suit matches within chunks of 5; rank within 4 at boundaries [training variant 51/84] | chunk_run | train_variant_marker = (len(mainline) + 70) % 72
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0051_00071 | suit matches within chunks of 7; rank within 7 at boundaries [training variant 52/84] | chunk_run | train_variant_marker = (len(mainline) + 71) % 73
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0052_00072 | suit matches within chunks of 6; rank within 3 at boundaries [training variant 53/84] | chunk_run | train_variant_marker = (len(mainline) + 72) % 74
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0053_00073 | suit matches within chunks of 4; rank within 4 at boundaries [training variant 54/84] | chunk_run | train_variant_marker = (len(mainline) + 73) % 75
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0054_00074 | suit matches within chunks of 7; rank within 5 at boundaries [training variant 55/84] | chunk_run | train_variant_marker = (len(mainline) + 74) % 76
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0055_00075 | suit matches within chunks of 6; rank within 7 at boundaries [training variant 56/84] | chunk_run | train_variant_marker = (len(mainline) + 75) % 77
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0056_00076 | suit matches within chunks of 8; rank within 4 at boundaries [training variant 57/84] | chunk_run | train_variant_marker = (len(mainline) + 76) % 78
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0057_00077 | suit matches within chunks of 6; rank within 6 at boundaries [training variant 58/84] | chunk_run | train_variant_marker = (len(mainline) + 77) % 79
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0058_00078 | suit matches within chunks of 5; rank within 5 at boundaries [training variant 59/84] | chunk_run | train_variant_marker = (len(mainline) + 78) % 80
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0059_00079 | suit matches within chunks of 5; rank within 7 at boundaries [training variant 60/84] | chunk_run | train_variant_marker = (len(mainline) + 79) % 81
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0060_00080 | suit matches within chunks of 4; rank within 7 at boundaries [training variant 61/84] | chunk_run | train_variant_marker = (len(mainline) + 80) % 82
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0061_00081 | suit matches within chunks of 7; rank within 6 at boundaries [training variant 62/84] | chunk_run | train_variant_marker = (len(mainline) + 81) % 83
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0062_00082 | suit matches within chunks of 6; rank within 4 at boundaries [training variant 63/84] | chunk_run | train_variant_marker = (len(mainline) + 82) % 84
if not mainline:
return True
phase = (len(mainline)-1) % 6
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 4
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0063_00083 | suit matches within chunks of 8; rank within 5 at boundaries [training variant 64/84] | chunk_run | train_variant_marker = (len(mainline) + 83) % 85
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0064_00084 | suit matches within chunks of 4; rank within 6 at boundaries [training variant 65/84] | chunk_run | train_variant_marker = (len(mainline) + 84) % 86
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 6
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0065_00085 | suit matches within chunks of 5; rank within 3 at boundaries [training variant 66/84] | chunk_run | train_variant_marker = (len(mainline) + 85) % 87
if not mainline:
return True
phase = (len(mainline)-1) % 5
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0066_00086 | suit matches within chunks of 8; rank within 7 at boundaries [training variant 67/84] | chunk_run | train_variant_marker = (len(mainline) + 86) % 88
if not mainline:
return True
phase = (len(mainline)-1) % 8
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 7
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0067_00087 | suit matches within chunks of 7; rank within 3 at boundaries [training variant 68/84] | chunk_run | train_variant_marker = (len(mainline) + 87) % 89
if not mainline:
return True
phase = (len(mainline)-1) % 7
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit |
train_earlyfilter_v072_chunk_run_boundary_exception_0068_00088 | inverse policy: within chunks of 2: same color and rank within 7; boundaries unrestricted [training variant 69/84] | chunk_run | train_variant_marker = (len(mainline) + 88) % 90
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 7
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0069_00089 | inverse policy: within chunks of 2: same color and rank within 8; boundaries unrestricted [training variant 70/84] | chunk_run | train_variant_marker = (len(mainline) + 89) % 91
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 8
if not mainline:
return True
return not train_... |
train_earlyfilter_v072_chunk_run_boundary_exception_0070_00090 | inverse policy: color matches within chunks of 3 with rank distance at most 5; alternates at boundaries [training variant 71/84] | chunk_run | train_variant_marker = (len(mainline) + 90) % 92
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 3
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0071_00091 | inverse policy: color matches within chunks of 4 with rank distance at most 6; alternates at boundaries [training variant 72/84] | chunk_run | train_variant_marker = (len(mainline) + 91) % 93
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 6
if n... |
train_earlyfilter_v072_chunk_run_boundary_exception_0072_00092 | inverse policy: rank parity is different within chunks of 7 and matches at boundaries [training variant 73/84] | chunk_run | train_variant_marker = (len(mainline) + 92) % 94
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 7 == 0:
return card.rank % 2 == mainline[-1].rank % 2
return card.rank % 2 != mainline[-1].rank % 2
if not mainline:
return True
return not train_base_rul... |
train_earlyfilter_v072_chunk_run_boundary_exception_0073_00093 | inverse policy: rank is different within chunks of 3 and matches at boundaries [training variant 74/84] | chunk_run | train_variant_marker = (len(mainline) + 93) % 95
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 3 == 0:
return card.rank == mainline[-1].rank
return card.rank != mainline[-1].rank
if not mainline:
return True
return not train_base_rule(card, mainline... |
train_earlyfilter_v072_chunk_run_boundary_exception_0074_00094 | inverse policy: suits repeat in chunks of 4 and rank moves down at boundaries [training variant 75/84] | chunk_run | train_variant_marker = (len(mainline) + 94) % 96
def train_base_rule(card, mainline):
if not mainline:
return True
prev = mainline[-1]
if len(mainline) % 4 == 0:
return card.suit != prev.suit and card.rank < prev.rank
return card.suit == prev.suit
if not mainline:
return True
return ... |
train_earlyfilter_v072_chunk_run_boundary_exception_0075_00095 | inverse policy: rank is same within chunks of 5 and changes at boundaries [training variant 76/84] | chunk_run | train_variant_marker = (len(mainline) + 95) % 97
def train_base_rule(card, mainline):
if not mainline:
return True
if len(mainline) % 5 == 0:
return card.rank != mainline[-1].rank
return card.rank == mainline[-1].rank
if not mainline:
return True
return not train_base_rule(card, mainline... |
train_earlyfilter_v072_chunk_run_boundary_exception_0076_00096 | inverse policy: suit matches within chunks of 4; rank within 3 at boundaries [training variant 77/84] | chunk_run | train_variant_marker = (len(mainline) + 96) % 98
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 3
return card.suit == prev.suit
if not m... |
train_earlyfilter_v072_chunk_run_boundary_exception_0077_00097 | inverse policy: suit matches within chunks of 4; rank within 5 at boundaries [training variant 78/84] | chunk_run | train_variant_marker = (len(mainline) + 1) % 2
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
prev = mainline[-1]
if phase == 0:
return card.suit != prev.suit and abs(card.rank - prev.rank) <= 5
return card.suit == prev.suit
if not mai... |
train_earlyfilter_v072_chunk_run_boundary_exception_0078_00098 | inverse policy: within chunks of 2: same color and rank within 5; boundaries unrestricted [training variant 79/84] | chunk_run | train_variant_marker = (len(mainline) + 2) % 3
def train_base_rule(card, mainline):
if not mainline:
return True
if (len(mainline)-1) % 2 == 0:
return True
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 5
if not mainline:
return True
return not train_ba... |
train_earlyfilter_v072_chunk_run_boundary_exception_0079_00099 | inverse policy: color matches within chunks of 4 with rank distance at most 7; alternates at boundaries [training variant 80/84] | chunk_run | train_variant_marker = (len(mainline) + 3) % 4
def train_base_rule(card, mainline):
if not mainline:
return True
phase = (len(mainline)-1) % 4
if phase == 0:
return card.color != mainline[-1].color
return card.color == mainline[-1].color and abs(card.rank - mainline[-1].rank) <= 7
if not... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.