Datasets:
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... |
End of preview. Expand in Data Studio
Eleusis calibrated rules — protocol v0.7.2
This release contains 2,048 train and 512 test rules.
Both splits intentionally expose only the runtime-facing columns used by prior
Eleusis datasets: rule_id, label, family, and code. Calibration,
selection, quality, and lineage metadata remain in the files under
calibration/v072/ rather than being repeated on every rule row.
Split construction
- Eight rule families contribute 256 train and 64 test rules each.
- The 60 family/concept cells have exactly four times as many train examples as test examples in every cell.
- Test contains 512 unique behavioral signatures and 215 AST skeletons, with no more than 13 rules sharing a skeleton.
- Train contains 1,151 distinct behaviors. Semantics-preserving functional variants fill thin cells only after all distinct eligible bases are used.
- Train and test have zero behavioral-signature overlap.
- All 2,048 train rules and all 512 test rules accept a valid starter. The current revision repairs the empty-mainline guard on complemented training variants without changing their non-empty behavior or any test rule.
Quality and calibration
Every test rule passes the deterministic 16-seed, 100-turn reachable-trajectory and 48-neighbor information-gain audit. Selection uses 371 compatible GLM-5.2 episodes covering 141 measured rules as an inexpensive approximation layer. Forty rules observed to solve in turns 1–20 are excluded exactly. Ranking uses cross-validated early-solve risk, delayed local revelation, and deep-unsolved affinity; direct late-solve prediction was rejected because it did not transfer out of sample.
The attempted 16-rule, previously unmeasured GLM-5.2 release audit was inconclusive. GLM-5.2 emitted exceptionally large private-reasoning histories and the provider rejected long requests around turns 26–34. These provider failures are not scored as model failures. A context-guarded retry produced one usable result—a solve at turn 30 with reward 0.71—but was stopped because it could not deliver a statistically meaningful result within the remaining time and budget. This limitation is disclosed rather than imputed.
Release is based on the deterministic gates above and the construction ledger of 371 prior compatible GLM-5.2 episodes covering 141 rules. Absolute GLM-5.2 difficulty should be re-estimated when a provider can reliably serve the full long-horizon transcript.
See calibration/v072/release_manifest.json for machine-readable split and
diversity facts.
- Downloads last month
- 128