Dataset Viewer
Auto-converted to Parquet Duplicate
id
stringlengths
35
42
source
stringclasses
1 value
family
stringclasses
15 values
group
stringclasses
1 value
split
stringclasses
1 value
input
stringlengths
60
5.47k
answer
stringlengths
2
2.42k
options
listlengths
tier
stringclasses
1 value
label_source
stringclasses
1 value
audit_accuracy
float32
provenance
stringlengths
83
99
record
stringlengths
127
9.04k
code2.bitvec:1000000000:59d98b6ce40b
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(38275 * x + 48021) & 0xFFFF", "target": 4009, "derivation": "38275 is odd, so it has an inverse mod 65536: 38275 * 8491 = 324993025 = 4959 * 65536 + 1. Then x = 8491 * (4009 - 48021) mod 65536 = 45916."}
{"count": 1, "solutions": [45916]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000000, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(38275 * x + 48021) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000001:824c256f60b7
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 7) ^ 56799", "target": 58248, "derivation": "XOR with 56799 again gives rotl(x, 7) = 15959; rotating that right by 7 gives x = 44668."}
{"count": 1, "solutions": [44668]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000001, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "((((x << 7) | (x >> 9)) & 0xFFFF) ^ 56799)", "bits": 16}}
code2.bitvec:1000000002:686f80207327
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 38 and x ^ y == 67", "s": 38, "t": 67, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 0."}
{"count": 0, "solutions": []}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000002, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000003:4e7f07aad3e4
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(6435 * x + 65098) & 0xFFFF", "target": 21669, "derivation": "6435 is odd, so it has an inverse mod 65536: 6435 * 56971 = 366608385 = 5594 * 65536 + 1. Then x = 56971 * (21669 - 65098) mod 65536 = 52585."}
{"count": 1, "solutions": [52585]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000003, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(6435 * x + 65098) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000004:f8c614e49578
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(128 * x + 154) & 0xFF", "target": 26, "derivation": "128 is even, so multiplication by it is not invertible mod 256: gcd(128, 256) = 128. A solution exists only if 128 divides (26 - 154) mod 256 = 128, and then there are 128 of them."}
{"count": 128, "solutions": [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000004, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(128 * x + 154) & 0xFF", "bits": 8}}
code2.bitvec:1000000005:4ded9a612ba6
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(13385 * x + 56185) & 0xFFFF", "target": 33360, "derivation": "13385 is odd, so it has an inverse mod 65536: 13385 * 65017 = 870252545 = 13279 * 65536 + 1. Then x = 65017 * (33360 - 56185) mod 65536 = 49695."}
{"count": 1, "solutions": [49695]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000005, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(13385 * x + 56185) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000006:0770a75c60e2
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 2)", "target": 24608, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 24608....
{"count": 1, "solutions": [32725]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000006, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000007:6d94caa3ea04
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 10) ^ 61089", "target": 18471, "derivation": "XOR with 61089 again gives rotl(x, 10) = 42630; rotating that right by 10 gives x = 41385."}
{"count": 1, "solutions": [41385]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000007, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 10) | (x >> 6)) & 0xFFFF) ^ 61089)", "bits": 16}}
code2.bitvec:1000000008:dd955f27a2ec
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(93 * x + 169) & 0xFF", "target": 223, "derivation": "93 is odd, so it has an inverse mod 256: 93 * 245 = 22785 = 89 * 256 + 1. Then x = 245 * (223 - 169) mod 256 = 174."}
{"count": 1, "solutions": [174]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000008, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(93 * x + 169) & 0xFF", "bits": 8}}
code2.bitvec:1000000010:53d2a5d1e8eb
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 4)", "target": 9, "derivation": "Shifting right by 4 only mixes higher bits into lower ones, so the top 4 bits of x equal the top 4 bits of the target, and each lower group of 4 bits follows from the bits above it: x = t ^ (t >> 4) ^ (t >> 8) ^ ... with t = 9."}
{"count": 1, "solutions": [9]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000010, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(x ^ (x >> 4)) & 0xFF", "bits": 8}}
code2.bitvec:1000000011:66d6c19efa9f
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 8)", "target": 39805, "derivation": "Shifting right by 8 only mixes higher bits into lower ones, so the top 8 bits of x equal the top 8 bits of the target, and each lower group of 8 bits follows from the bits above it: x = t ^ (t >> 8) ^ (t >> 16) ^ ... with t = 39805...
{"count": 1, "solutions": [39910]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000011, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 8)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000014:c6e049535d18
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(3293 * x + 6976) & 0xFFFF", "target": 15425, "derivation": "3293 is odd, so it has an inverse mod 65536: 3293 * 11125 = 36634625 = 559 * 65536 + 1. Then x = 11125 * (15425 - 6976) mod 65536 = 16501."}
{"count": 1, "solutions": [16501]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000014, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(3293 * x + 6976) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000015:70f836bb418e
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(193 * x + 84) & 0xFF", "target": 64, "derivation": "193 is odd, so it has an inverse mod 256: 193 * 65 = 12545 = 49 * 256 + 1. Then x = 65 * (64 - 84) mod 256 = 236."}
{"count": 1, "solutions": [236]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000015, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(193 * x + 84) & 0xFF", "bits": 8}}
code2.bitvec:1000000016:854085a2e34f
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 10) ^ 3486", "target": 3320, "derivation": "XOR with 3486 again gives rotl(x, 10) = 358; rotating that right by 10 gives x = 22912."}
{"count": 1, "solutions": [22912]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000016, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "((((x << 10) | (x >> 6)) & 0xFFFF) ^ 3486)", "bits": 16}}
code2.bitvec:1000000017:c5bf0266b825
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 3)", "target": 150, "derivation": "Shifting right by 3 only mixes higher bits into lower ones, so the top 3 bits of x equal the top 3 bits of the target, and each lower group of 3 bits follows from the bits above it: x = t ^ (t >> 3) ^ (t >> 6) ^ ... with t = 150."}
{"count": 1, "solutions": [134]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000017, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(x ^ (x >> 3)) & 0xFF", "bits": 8}}
code2.bitvec:1000000018:13f252a2a416
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(55101 * x + 38212) & 0xFFFF", "target": 46417, "derivation": "55101 is odd, so it has an inverse mod 65536: 55101 * 14357 = 791085057 = 12071 * 65536 + 1. Then x = 14357 * (46417 - 38212) mod 65536 = 30993."}
{"count": 1, "solutions": [30993]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000018, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(55101 * x + 38212) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000019:3e3021ef2b21
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 7)", "target": 7255, "derivation": "Shifting right by 7 only mixes higher bits into lower ones, so the top 7 bits of x equal the top 7 bits of the target, and each lower group of 7 bits follows from the bits above it: x = t ^ (t >> 7) ^ (t >> 14) ^ ... with t = 7255."...
{"count": 1, "solutions": [7279]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000019, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(x ^ (x >> 7)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000020:85275c446365
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 10) ^ 56128", "target": 51613, "derivation": "XOR with 56128 again gives rotl(x, 10) = 4829; rotating that right by 10 gives x = 46916."}
{"count": 1, "solutions": [46916]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000020, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "((((x << 10) | (x >> 6)) & 0xFFFF) ^ 56128)", "bits": 16}}
code2.bitvec:1000000021:8e882d794bf1
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 1)", "target": 52049, "derivation": "Shifting right by 1 only mixes higher bits into lower ones, so the top 1 bits of x equal the top 1 bits of the target, and each lower group of 1 bits follows from the bits above it: x = t ^ (t >> 1) ^ (t >> 2) ^ ... with t = 52049....
{"count": 1, "solutions": [36254]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000021, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 1)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000022:673f61273dc7
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 8, "expr": "rotl8(x, 6) ^ 77", "target": 200, "derivation": "XOR with 77 again gives rotl(x, 6) = 133; rotating that right by 6 gives x = 22."}
{"count": 1, "solutions": [22]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000022, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 6) | (x >> 2)) & 0xFF) ^ 77)", "bits": 8}}
code2.bitvec:1000000023:afe49be283e3
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(239 * x + 192) & 0xFF", "target": 255, "derivation": "239 is odd, so it has an inverse mod 256: 239 * 15 = 3585 = 14 * 256 + 1. Then x = 15 * (255 - 192) mod 256 = 177."}
{"count": 1, "solutions": [177]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000023, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(239 * x + 192) & 0xFF", "bits": 8}}
code2.bitvec:1000000024:08b3820df28a
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(46787 * x + 46400) & 0xFFFF", "target": 51655, "derivation": "46787 is odd, so it has an inverse mod 65536: 46787 * 10731 = 502071297 = 7661 * 65536 + 1. Then x = 10731 * (51655 - 46400) mod 65536 = 30445."}
{"count": 1, "solutions": [30445]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000024, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(46787 * x + 46400) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000025:97865ba38437
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(38316 * x + 41066) & 0xFFFF", "target": 2882, "derivation": "38316 is even, so multiplication by it is not invertible mod 65536: gcd(38316, 65536) = 4. A solution exists only if 4 divides (2882 - 41066) mod 65536 = 27352, and then there are 4 of them."}
{"count": 4, "solutions": [1954, 18338, 34722, 51106]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000025, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(38316 * x + 41066) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000027:11508addfb63
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 14 and x ^ y == 204", "s": 14, "t": 204, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 16."}
{"count": 16, "solutions": [[33, 237], [37, 233], [41, 229], [45, 225], [97, 173], [101, 169], [105, 165], [109, 161], [161, 109], [165, 105], [169, 101], [173, 97], [225, 45], [229, 41], [233, 37], [237, 33]]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000027, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000028:baf9727c57a5
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(45412 * x + 46592) & 0xFFFF", "target": 18756, "derivation": "45412 is even, so multiplication by it is not invertible mod 65536: gcd(45412, 65536) = 4. A solution exists only if 4 divides (18756 - 46592) mod 65536 = 37700, and then there are 4 of them."}
{"count": 4, "solutions": [3385, 19769, 36153, 52537]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000028, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(45412 * x + 46592) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000030:df85d615a41a
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 2)", "target": 229, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 229."}
{"count": 1, "solutions": [209]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000030, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFF", "bits": 8}}
code2.bitvec:1000000031:49fc0fcfd5e0
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 8) ^ 19059", "target": 21562, "derivation": "XOR with 19059 again gives rotl(x, 8) = 7753; rotating that right by 8 gives x = 18718."}
{"count": 1, "solutions": [18718]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000031, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "((((x << 8) | (x >> 8)) & 0xFFFF) ^ 19059)", "bits": 16}}
code2.bitvec:1000000032:b6673ef1b213
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 2)", "target": 206, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 206."}
{"count": 1, "solutions": [242]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000032, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFF", "bits": 8}}
code2.bitvec:1000000033:25d880e2edc0
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 2)", "target": 43, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 43."}
{"count": 1, "solutions": [35]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000033, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFF", "bits": 8}}
code2.bitvec:1000000034:db1cc6e643af
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(130 * x + 156) & 0xFF", "target": 20, "derivation": "130 is even, so multiplication by it is not invertible mod 256: gcd(130, 256) = 2. A solution exists only if 2 divides (20 - 156) mod 256 = 120, and then there are 2 of them."}
{"count": 2, "solutions": [60, 188]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000034, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(130 * x + 156) & 0xFF", "bits": 8}}
code2.bitvec:1000000035:eb54fbde3096
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 3)", "target": 59, "derivation": "Shifting right by 3 only mixes higher bits into lower ones, so the top 3 bits of x equal the top 3 bits of the target, and each lower group of 3 bits follows from the bits above it: x = t ^ (t >> 3) ^ (t >> 6) ^ ... with t = 59."}
{"count": 1, "solutions": [60]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000035, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(x ^ (x >> 3)) & 0xFF", "bits": 8}}
code2.bitvec:1000000036:378c68e596f2
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(237 * x + 19) & 0xFF", "target": 117, "derivation": "237 is odd, so it has an inverse mod 256: 237 * 229 = 54273 = 212 * 256 + 1. Then x = 229 * (117 - 19) mod 256 = 170."}
{"count": 1, "solutions": [170]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000036, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(237 * x + 19) & 0xFF", "bits": 8}}
code2.bitvec:1000000038:c4160e3b7702
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(10309 * x + 12413) & 0xFFFF", "target": 12760, "derivation": "10309 is odd, so it has an inverse mod 65536: 10309 * 43661 = 450101249 = 6868 * 65536 + 1. Then x = 43661 * (12760 - 12413) mod 65536 = 11551."}
{"count": 1, "solutions": [11551]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000038, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(10309 * x + 12413) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000039:620b5e52bc25
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 2)", "target": 49130, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 49130....
{"count": 1, "solutions": [39304]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000039, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000040:9de70e763f40
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(251 * x + 3) & 0xFF", "target": 135, "derivation": "251 is odd, so it has an inverse mod 256: 251 * 51 = 12801 = 50 * 256 + 1. Then x = 51 * (135 - 3) mod 256 = 76."}
{"count": 1, "solutions": [76]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000040, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(251 * x + 3) & 0xFF", "bits": 8}}
code2.bitvec:1000000041:4f9d247b0a31
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(15402 * x + 61714) & 0xFFFF", "target": 20862, "derivation": "15402 is even, so multiplication by it is not invertible mod 65536: gcd(15402, 65536) = 2. A solution exists only if 2 divides (20862 - 61714) mod 65536 = 24684, and then there are 2 of them."}
{"count": 2, "solutions": [13022, 45790]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000041, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(15402 * x + 61714) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000042:6a3e128f1990
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 8, "expr": "rotl8(x, 6) ^ 202", "target": 44, "derivation": "XOR with 202 again gives rotl(x, 6) = 230; rotating that right by 6 gives x = 155."}
{"count": 1, "solutions": [155]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000042, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 6) | (x >> 2)) & 0xFF) ^ 202)", "bits": 8}}
code2.bitvec:1000000043:b36e332b6cef
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 2)", "target": 62927, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 62927....
{"count": 1, "solutions": [50419]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000043, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000044:a6d80e9a7150
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 206 and x ^ y == 58", "s": 206, "t": 58, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 0."}
{"count": 0, "solutions": []}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000044, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000045:ad487ebfaf07
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 8, "expr": "rotl8(x, 2) ^ 56", "target": 102, "derivation": "XOR with 56 again gives rotl(x, 2) = 94; rotating that right by 2 gives x = 151."}
{"count": 1, "solutions": [151]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000045, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "((((x << 2) | (x >> 6)) & 0xFF) ^ 56)", "bits": 8}}
code2.bitvec:1000000046:9f5a40abe321
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(64427 * x + 37975) & 0xFFFF", "target": 8812, "derivation": "64427 is odd, so it has an inverse mod 65536: 64427 * 9987 = 643432449 = 9818 * 65536 + 1. Then x = 9987 * (8812 - 37975) mod 65536 = 56639."}
{"count": 1, "solutions": [56639]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000046, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(64427 * x + 37975) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000047:0d191774bf2b
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 249 and x ^ y == 241", "s": 249, "t": 241, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 32."}
{"count": 32, "solutions": [[4, 245], [5, 244], [20, 229], [21, 228], [36, 213], [37, 212], [52, 197], [53, 196], [68, 181], [69, 180], [84, 165], [85, 164], [100, 149], [101, 148], [116, 133], [117, 132]]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000047, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000048:21cf8ae09dc3
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(183 * x + 45) & 0xFF", "target": 104, "derivation": "183 is odd, so it has an inverse mod 256: 183 * 7 = 1281 = 5 * 256 + 1. Then x = 7 * (104 - 45) mod 256 = 157."}
{"count": 1, "solutions": [157]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000048, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(183 * x + 45) & 0xFF", "bits": 8}}
code2.bitvec:1000000049:97a738073d06
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(61413 * x + 60842) & 0xFFFF", "target": 63085, "derivation": "61413 is odd, so it has an inverse mod 65536: 61413 * 46573 = 2860187649 = 43643 * 65536 + 1. Then x = 46573 * (63085 - 60842) mod 65536 = 64391."}
{"count": 1, "solutions": [64391]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000049, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(61413 * x + 60842) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000050:27a23608cb87
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 79 and x ^ y == 90", "s": 79, "t": 90, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 0."}
{"count": 0, "solutions": []}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000050, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000051:788d4e14c842
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(31767 * x + 42029) & 0xFFFF", "target": 51262, "derivation": "31767 is odd, so it has an inverse mod 65536: 31767 * 31655 = 1005584385 = 15344 * 65536 + 1. Then x = 31655 * (51262 - 42029) mod 65536 = 45591."}
{"count": 1, "solutions": [45591]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000051, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(31767 * x + 42029) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000052:eb2f12713c21
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(148 * x + 147) & 0xFF", "target": 131, "derivation": "148 is even, so multiplication by it is not invertible mod 256: gcd(148, 256) = 4. A solution exists only if 4 divides (131 - 147) mod 256 = 240, and then there are 4 of them."}
{"count": 4, "solutions": [12, 76, 140, 204]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000052, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(148 * x + 147) & 0xFF", "bits": 8}}
code2.bitvec:1000000053:ef223fb9ec55
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 2)", "target": 179, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 179."}
{"count": 1, "solutions": [150]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000053, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFF", "bits": 8}}
code2.bitvec:1000000054:eac66af2ca09
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 1) ^ 47375", "target": 3594, "derivation": "XOR with 47375 again gives rotl(x, 1) = 46853; rotating that right by 1 gives x = 56194."}
{"count": 1, "solutions": [56194]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000054, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "((((x << 1) | (x >> 15)) & 0xFFFF) ^ 47375)", "bits": 16}}
code2.bitvec:1000000055:a78f14fb39e2
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(134 * x + 187) & 0xFF", "target": 219, "derivation": "134 is even, so multiplication by it is not invertible mod 256: gcd(134, 256) = 2. A solution exists only if 2 divides (219 - 187) mod 256 = 32, and then there are 2 of them."}
{"count": 2, "solutions": [48, 176]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000055, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(134 * x + 187) & 0xFF", "bits": 8}}
code2.bitvec:1000000056:c7207c59f0ab
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 5)", "target": 3862, "derivation": "Shifting right by 5 only mixes higher bits into lower ones, so the top 5 bits of x equal the top 5 bits of the target, and each lower group of 5 bits follows from the bits above it: x = t ^ (t >> 5) ^ (t >> 10) ^ ... with t = 3862."...
{"count": 1, "solutions": [3949]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000056, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 5)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000057:644c9323932d
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(98 * x + 22) & 0xFF", "target": 154, "derivation": "98 is even, so multiplication by it is not invertible mod 256: gcd(98, 256) = 2. A solution exists only if 2 divides (154 - 22) mod 256 = 132, and then there are 2 of them."}
{"count": 2, "solutions": [98, 226]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000057, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(98 * x + 22) & 0xFF", "bits": 8}}
code2.bitvec:1000000058:e6786cf0b7f7
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 8) ^ 45044", "target": 28706, "derivation": "XOR with 45044 again gives rotl(x, 8) = 57302; rotating that right by 8 gives x = 55007."}
{"count": 1, "solutions": [55007]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000058, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "((((x << 8) | (x >> 8)) & 0xFFFF) ^ 45044)", "bits": 16}}
code2.bitvec:1000000059:1d17ee974947
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 3) ^ 2937", "target": 38769, "derivation": "XOR with 2937 again gives rotl(x, 3) = 39944; rotating that right by 3 gives x = 4993."}
{"count": 1, "solutions": [4993]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000059, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "((((x << 3) | (x >> 13)) & 0xFFFF) ^ 2937)", "bits": 16}}
code2.bitvec:1000000060:b1e06e9a1ddf
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(251 * x + 56) & 0xFF", "target": 107, "derivation": "251 is odd, so it has an inverse mod 256: 251 * 51 = 12801 = 50 * 256 + 1. Then x = 51 * (107 - 56) mod 256 = 41."}
{"count": 1, "solutions": [41]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000060, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(251 * x + 56) & 0xFF", "bits": 8}}
code2.bitvec:1000000061:26166d0d84ad
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(211 * x + 162) & 0xFF", "target": 239, "derivation": "211 is odd, so it has an inverse mod 256: 211 * 91 = 19201 = 75 * 256 + 1. Then x = 91 * (239 - 162) mod 256 = 95."}
{"count": 1, "solutions": [95]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000061, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(211 * x + 162) & 0xFF", "bits": 8}}
code2.bitvec:1000000062:e83b99d4b7b1
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(34 * x + 142) & 0xFF", "target": 20, "derivation": "34 is even, so multiplication by it is not invertible mod 256: gcd(34, 256) = 2. A solution exists only if 2 divides (20 - 142) mod 256 = 134, and then there are 2 of them."}
{"count": 2, "solutions": [19, 147]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000062, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(34 * x + 142) & 0xFF", "bits": 8}}
code2.bitvec:1000000063:6ba21280c3be
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(235 * x + 90) & 0xFF", "target": 54, "derivation": "235 is odd, so it has an inverse mod 256: 235 * 195 = 45825 = 179 * 256 + 1. Then x = 195 * (54 - 90) mod 256 = 148."}
{"count": 1, "solutions": [148]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000063, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(235 * x + 90) & 0xFF", "bits": 8}}
code2.bitvec:1000000064:a91ceab313ab
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 5) ^ 5239", "target": 3313, "derivation": "XOR with 5239 again gives rotl(x, 5) = 6278; rotating that right by 5 gives x = 12484."}
{"count": 1, "solutions": [12484]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000064, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "((((x << 5) | (x >> 11)) & 0xFFFF) ^ 5239)", "bits": 16}}
code2.bitvec:1000000066:c57b60f5759e
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(175 * x + 30) & 0xFF", "target": 157, "derivation": "175 is odd, so it has an inverse mod 256: 175 * 79 = 13825 = 54 * 256 + 1. Then x = 79 * (157 - 30) mod 256 = 49."}
{"count": 1, "solutions": [49]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000066, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(175 * x + 30) & 0xFF", "bits": 8}}
code2.bitvec:1000000067:4c0345c92e38
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 2)", "target": 24529, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 24529....
{"count": 1, "solutions": [19691]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000067, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000068:ecad440772fd
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(74 * x + 246) & 0xFF", "target": 84, "derivation": "74 is even, so multiplication by it is not invertible mod 256: gcd(74, 256) = 2. A solution exists only if 2 divides (84 - 246) mod 256 = 94, and then there are 2 of them."}
{"count": 2, "solutions": [67, 195]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000068, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(74 * x + 246) & 0xFF", "bits": 8}}
code2.bitvec:1000000069:15d063635e1e
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 6) ^ 116", "target": 25698, "derivation": "XOR with 116 again gives rotl(x, 6) = 25622; rotating that right by 6 gives x = 22928."}
{"count": 1, "solutions": [22928]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000069, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "((((x << 6) | (x >> 10)) & 0xFFFF) ^ 116)", "bits": 16}}
code2.bitvec:1000000070:b23349d67be9
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(78 * x + 197) & 0xFF", "target": 21, "derivation": "78 is even, so multiplication by it is not invertible mod 256: gcd(78, 256) = 2. A solution exists only if 2 divides (21 - 197) mod 256 = 80, and then there are 2 of them."}
{"count": 2, "solutions": [24, 152]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000070, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(78 * x + 197) & 0xFF", "bits": 8}}
code2.bitvec:1000000071:eb24ebef606a
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(165 * x + 241) & 0xFF", "target": 233, "derivation": "165 is odd, so it has an inverse mod 256: 165 * 45 = 7425 = 29 * 256 + 1. Then x = 45 * (233 - 241) mod 256 = 152."}
{"count": 1, "solutions": [152]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000071, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(165 * x + 241) & 0xFF", "bits": 8}}
code2.bitvec:1000000072:643b62352ced
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 8, "expr": "rotl8(x, 2) ^ 110", "target": 61, "derivation": "XOR with 110 again gives rotl(x, 2) = 83; rotating that right by 2 gives x = 212."}
{"count": 1, "solutions": [212]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000072, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 2) | (x >> 6)) & 0xFF) ^ 110)", "bits": 8}}
code2.bitvec:1000000073:cc39461daeb9
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(69 * x + 207) & 0xFF", "target": 165, "derivation": "69 is odd, so it has an inverse mod 256: 69 * 141 = 9729 = 38 * 256 + 1. Then x = 141 * (165 - 207) mod 256 = 222."}
{"count": 1, "solutions": [222]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000073, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(69 * x + 207) & 0xFF", "bits": 8}}
code2.bitvec:1000000074:c1d507c8f479
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(55507 * x + 37689) & 0xFFFF", "target": 952, "derivation": "55507 is odd, so it has an inverse mod 65536: 55507 * 16219 = 900268033 = 13737 * 65536 + 1. Then x = 16219 * (952 - 37689) mod 65536 = 15909."}
{"count": 1, "solutions": [15909]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000074, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(55507 * x + 37689) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000075:02a853ec2535
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 4)", "target": 80, "derivation": "Shifting right by 4 only mixes higher bits into lower ones, so the top 4 bits of x equal the top 4 bits of the target, and each lower group of 4 bits follows from the bits above it: x = t ^ (t >> 4) ^ (t >> 8) ^ ... with t = 80."}
{"count": 1, "solutions": [85]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000075, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(x ^ (x >> 4)) & 0xFF", "bits": 8}}
code2.bitvec:1000000076:fbc924f18394
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 2)", "target": 160, "derivation": "Shifting right by 2 only mixes higher bits into lower ones, so the top 2 bits of x equal the top 2 bits of the target, and each lower group of 2 bits follows from the bits above it: x = t ^ (t >> 2) ^ (t >> 4) ^ ... with t = 160."}
{"count": 1, "solutions": [128]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000076, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 2)) & 0xFF", "bits": 8}}
code2.bitvec:1000000077:83bbe1329509
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 9) ^ 57556", "target": 22066, "derivation": "XOR with 57556 again gives rotl(x, 9) = 46822; rotating that right by 9 gives x = 29531."}
{"count": 1, "solutions": [29531]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000077, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 9) | (x >> 7)) & 0xFFFF) ^ 57556)", "bits": 16}}
code2.bitvec:1000000079:929b738382a6
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(23313 * x + 47136) & 0xFFFF", "target": 5542, "derivation": "23313 is odd, so it has an inverse mod 65536: 23313 * 62961 = 1467809793 = 22397 * 65536 + 1. Then x = 62961 * (5542 - 47136) mod 65536 = 18726."}
{"count": 1, "solutions": [18726]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000079, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(23313 * x + 47136) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000080:a2aace8c4638
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(221 * x + 22) & 0xFF", "target": 178, "derivation": "221 is odd, so it has an inverse mod 256: 221 * 117 = 25857 = 101 * 256 + 1. Then x = 117 * (178 - 22) mod 256 = 76."}
{"count": 1, "solutions": [76]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000080, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(221 * x + 22) & 0xFF", "bits": 8}}
code2.bitvec:1000000081:a7dbb9703e11
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(147 * x + 217) & 0xFF", "target": 79, "derivation": "147 is odd, so it has an inverse mod 256: 147 * 155 = 22785 = 89 * 256 + 1. Then x = 155 * (79 - 217) mod 256 = 114."}
{"count": 1, "solutions": [114]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000081, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(147 * x + 217) & 0xFF", "bits": 8}}
code2.bitvec:1000000082:5a5fe591d9f2
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 5)", "target": 53359, "derivation": "Shifting right by 5 only mixes higher bits into lower ones, so the top 5 bits of x equal the top 5 bits of the target, and each lower group of 5 bits follows from the bits above it: x = t ^ (t >> 5) ^ (t >> 10) ^ ... with t = 53359...
{"count": 1, "solutions": [55001]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000082, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(x ^ (x >> 5)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000083:122de6ab1bd0
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(4986 * x + 58680) & 0xFFFF", "target": 53724, "derivation": "4986 is even, so multiplication by it is not invertible mod 65536: gcd(4986, 65536) = 2. A solution exists only if 2 divides (53724 - 58680) mod 65536 = 60580, and then there are 2 of them."}
{"count": 2, "solutions": [8122, 40890]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000083, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(4986 * x + 58680) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000084:661fb31b6f50
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(50626 * x + 20797) & 0xFFFF", "target": 33983, "derivation": "50626 is even, so multiplication by it is not invertible mod 65536: gcd(50626, 65536) = 2. A solution exists only if 2 divides (33983 - 20797) mod 65536 = 13186, and then there are 2 of them."}
{"count": 2, "solutions": [29409, 62177]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000084, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(50626 * x + 20797) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000085:bc85118637a0
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 201 and x ^ y == 1", "s": 201, "t": 1, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 4."}
{"count": 4, "solutions": [[100, 101], [101, 100], [228, 229], [229, 228]]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000085, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000086:db97e8fdee77
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 1)", "target": 251, "derivation": "Shifting right by 1 only mixes higher bits into lower ones, so the top 1 bits of x equal the top 1 bits of the target, and each lower group of 1 bits follows from the bits above it: x = t ^ (t >> 1) ^ (t >> 2) ^ ... with t = 251."}
{"count": 1, "solutions": [173]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000086, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 1)) & 0xFF", "bits": 8}}
code2.bitvec:1000000087:d35c6389ce8c
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(77 * x + 124) & 0xFF", "target": 9, "derivation": "77 is odd, so it has an inverse mod 256: 77 * 133 = 10241 = 40 * 256 + 1. Then x = 133 * (9 - 124) mod 256 = 65."}
{"count": 1, "solutions": [65]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000087, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(77 * x + 124) & 0xFF", "bits": 8}}
code2.bitvec:1000000088:b91312b6d4fa
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 14) ^ 55902", "target": 42333, "derivation": "XOR with 55902 again gives rotl(x, 14) = 32515; rotating that right by 14 gives x = 64525."}
{"count": 1, "solutions": [64525]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000088, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "((((x << 14) | (x >> 2)) & 0xFFFF) ^ 55902)", "bits": 16}}
code2.bitvec:1000000089:d34747597cf8
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 16, "expr": "(18198 * x + 496) & 0xFFFF", "target": 6286, "derivation": "18198 is even, so multiplication by it is not invertible mod 65536: gcd(18198, 65536) = 2. A solution exists only if 2 divides (6286 - 496) mod 65536 = 5790, and then there are 2 of them."}
{"count": 2, "solutions": [24525, 57293]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000089, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(18198 * x + 496) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000090:760e815b44a5
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(228 * x + 48) & 0xFF", "target": 176, "derivation": "228 is even, so multiplication by it is not invertible mod 256: gcd(228, 256) = 4. A solution exists only if 4 divides (176 - 48) mod 256 = 128, and then there are 4 of them."}
{"count": 4, "solutions": [32, 96, 160, 224]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000090, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(228 * x + 48) & 0xFF", "bits": 8}}
code2.bitvec:1000000091:7b6656eb457b
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 4)", "target": 239, "derivation": "Shifting right by 4 only mixes higher bits into lower ones, so the top 4 bits of x equal the top 4 bits of the target, and each lower group of 4 bits follows from the bits above it: x = t ^ (t >> 4) ^ (t >> 8) ^ ... with t = 239."}
{"count": 1, "solutions": [225]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000091, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 4)) & 0xFF", "bits": 8}}
code2.bitvec:1000000092:266eecf811f4
code2
code2.bitvec
code
test
{"kind": "sumxor", "bits": 8, "statement": "(x + y) & 0xFF == 7 and x ^ y == 247", "s": 7, "t": 247, "derivation": "For each x, y is forced by the sum: y = (s - x) mod 256. Checking the XOR condition on those 256 pairs leaves 128."}
{"count": 128, "solutions": [[8, 255], [9, 254], [10, 253], [11, 252], [12, 251], [13, 250], [14, 249], [15, 248], [24, 239], [25, 238], [26, 237], [27, 236], [28, 235], [29, 234], [30, 233], [31, 232]]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000092, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": null, "bits": 8}}
code2.bitvec:1000000093:7f2f4edd0578
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(62905 * x + 24444) & 0xFFFF", "target": 14112, "derivation": "62905 is odd, so it has an inverse mod 65536: 62905 * 32905 = 2069889025 = 31584 * 65536 + 1. Then x = 32905 * (14112 - 24444) mod 65536 = 26308."}
{"count": 1, "solutions": [26308]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000093, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(62905 * x + 24444) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000094:68de5ab88d4f
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 3)", "target": 61, "derivation": "Shifting right by 3 only mixes higher bits into lower ones, so the top 3 bits of x equal the top 3 bits of the target, and each lower group of 3 bits follows from the bits above it: x = t ^ (t >> 3) ^ (t >> 6) ^ ... with t = 61."}
{"count": 1, "solutions": [58]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000094, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(x ^ (x >> 3)) & 0xFF", "bits": 8}}
code2.bitvec:1000000095:0d7361eb5aa9
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 13) ^ 39828", "target": 64550, "derivation": "XOR with 39828 again gives rotl(x, 13) = 26546; rotating that right by 13 gives x = 15763."}
{"count": 1, "solutions": [15763]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000095, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "((((x << 13) | (x >> 3)) & 0xFFFF) ^ 39828)", "bits": 16}}
code2.bitvec:1000000096:73277eed237f
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 16, "expr": "x ^ (x >> 8)", "target": 62450, "derivation": "Shifting right by 8 only mixes higher bits into lower ones, so the top 8 bits of x equal the top 8 bits of the target, and each lower group of 8 bits follows from the bits above it: x = t ^ (t >> 8) ^ (t >> 16) ^ ... with t = 62450...
{"count": 1, "solutions": [62209]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000096, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 8)) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000097:f4afb35c031a
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(108 * x + 204) & 0xFF", "target": 36, "derivation": "108 is even, so multiplication by it is not invertible mod 256: gcd(108, 256) = 4. A solution exists only if 4 divides (36 - 204) mod 256 = 88, and then there are 4 of them."}
{"count": 4, "solutions": [34, 98, 162, 226]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000097, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(108 * x + 204) & 0xFF", "bits": 8}}
code2.bitvec:1000000098:7e918d616075
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(45141 * x + 60896) & 0xFFFF", "target": 39547, "derivation": "45141 is odd, so it has an inverse mod 65536: 45141 * 52477 = 2368864257 = 36146 * 65536 + 1. Then x = 52477 * (39547 - 60896) mod 65536 = 6447."}
{"count": 1, "solutions": [6447]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000098, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(45141 * x + 60896) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000100:fd81bfe3d8d4
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(233 * x + 234) & 0xFF", "target": 6, "derivation": "233 is odd, so it has an inverse mod 256: 233 * 89 = 20737 = 81 * 256 + 1. Then x = 89 * (6 - 234) mod 256 = 188."}
{"count": 1, "solutions": [188]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000100, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(233 * x + 234) & 0xFF", "bits": 8}}
code2.bitvec:1000000101:2b0a93c17b23
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 16, "expr": "rotl16(x, 5) ^ 39677", "target": 52733, "derivation": "XOR with 39677 again gives rotl(x, 5) = 22272; rotating that right by 5 gives x = 696."}
{"count": 1, "solutions": [696]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000101, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "((((x << 5) | (x >> 11)) & 0xFFFF) ^ 39677)", "bits": 16}}
code2.bitvec:1000000102:6761fb57d3f8
code2
code2.bitvec
code
test
{"kind": "rotate", "bits": 8, "expr": "rotl8(x, 2) ^ 235", "target": 38, "derivation": "XOR with 235 again gives rotl(x, 2) = 205; rotating that right by 2 gives x = 115."}
{"count": 1, "solutions": [115]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000102, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "((((x << 2) | (x >> 6)) & 0xFF) ^ 235)", "bits": 8}}
code2.bitvec:1000000103:8faaf356eed3
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(203 * x + 171) & 0xFF", "target": 219, "derivation": "203 is odd, so it has an inverse mod 256: 203 * 227 = 46081 = 180 * 256 + 1. Then x = 227 * (219 - 171) mod 256 = 144."}
{"count": 1, "solutions": [144]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000103, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(203 * x + 171) & 0xFF", "bits": 8}}
code2.bitvec:1000000104:f1165d5471ee
code2
code2.bitvec
code
test
{"kind": "affine_even", "bits": 8, "expr": "(202 * x + 185) & 0xFF", "target": 14, "derivation": "202 is even, so multiplication by it is not invertible mod 256: gcd(202, 256) = 2. A solution exists only if 2 divides (14 - 185) mod 256 = 85, and then there are 2 of them."}
{"count": 0, "solutions": []}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000104, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 5, "check": {"pyexpr": "(202 * x + 185) & 0xFF", "bits": 8}}
code2.bitvec:1000000105:b4c314b4332b
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 8, "expr": "(175 * x + 57) & 0xFF", "target": 115, "derivation": "175 is odd, so it has an inverse mod 256: 175 * 79 = 13825 = 54 * 256 + 1. Then x = 79 * (115 - 57) mod 256 = 230."}
{"count": 1, "solutions": [230]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000105, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 1, "check": {"pyexpr": "(175 * x + 57) & 0xFF", "bits": 8}}
code2.bitvec:1000000106:8e223a0a2ef6
code2
code2.bitvec
code
test
{"kind": "xorshift", "bits": 8, "expr": "x ^ (x >> 1)", "target": 127, "derivation": "Shifting right by 1 only mixes higher bits into lower ones, so the top 1 bits of x equal the top 1 bits of the target, and each lower group of 1 bits follows from the bits above it: x = t ^ (t >> 1) ^ (t >> 2) ^ ... with t = 127."}
{"count": 1, "solutions": [85]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000106, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 2, "check": {"pyexpr": "(x ^ (x >> 1)) & 0xFF", "bits": 8}}
code2.bitvec:1000000107:b193f4ee4e1f
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(53507 * x + 27132) & 0xFFFF", "target": 23555, "derivation": "53507 is odd, so it has an inverse mod 65536: 53507 * 8619 = 461176833 = 7037 * 65536 + 1. Then x = 8619 * (23555 - 27132) mod 65536 = 37293."}
{"count": 1, "solutions": [37293]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000107, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 3, "check": {"pyexpr": "(53507 * x + 27132) & 0xFFFF", "bits": 16}}
code2.bitvec:1000000108:af252763a4d0
code2
code2.bitvec
code
test
{"kind": "affine", "bits": 16, "expr": "(12807 * x + 2818) & 0xFFFF", "target": 27961, "derivation": "12807 is odd, so it has an inverse mod 65536: 12807 * 39863 = 510525441 = 7790 * 65536 + 1. Then x = 39863 * (27961 - 2818) mod 65536 = 33361."}
{"count": 1, "solutions": [33361]}
null
verified
sandbox execution + independent oracle
null
{"generator": "openllema.code2.surfaces.bitvec", "seed": 1000000108, "kernel": null}
{"evidence": {"exhaustive_search_agrees": true, "derivation_arithmetic_ok": true}, "topic": "bit-vectors", "difficulty": 4, "check": {"pyexpr": "(12807 * x + 2818) & 0xFFFF", "bits": 16}}
End of preview. Expand in Data Studio

OpenLemma v0.2: evaluation

Held-out items, never in the training data (split test):

  • code: every code surface on held-out seeds; kernel-based surfaces use 12 kernels that never appear in training;
  • code_llm: the 259 verified exercises of the gpt-6-luna pilot, for sandboxed pass@1 (run the tests in input against a model's function);
  • formats: every formats family on held-out seeds.

Training documents whose content matches a held-out item were removed.

Config Rows
code 4,254
code_llm 259
formats 2,365

Provenance and verification

Built by OpenLemma (code: MIT) from the plan in docs/FORMATS-CODE-V2-PLAN.md; release notes in docs/RELEASE-V0.2.md. This is a new release beside v0.1, which is unchanged.

  • Generation: deterministic procedural generators (seeded; no randomness at build time) and, for code2-llm only, gpt-6-luna (OpenAI, flex tier, reasoning effort low). No other model wrote any row.
  • Every row is verified (fail-closed: anything unchecked or failing was dropped):
    • code: every program ran in a sandbox (bubblewrap: no network, read-only system, private /tmp, CPU/memory/time limits, an audit hook refusing sockets, subprocesses and writes) and was compared, on the host, with an independent oracle: a brute-force implementation written differently, gcc for C, exhaustive search over a bounded domain, recompiled bytecode, finite differences or exact rationals. Test suites must fail on most single-point mutants;
    • formats: each answer is re-parsed or recomputed with an independent library (json, PyYAML, tomllib, ElementTree, jsonschema, jsonpatch, jsonpath-ng, sqlite3, csv).
  • Negative controls: for a sample of items a wrong answer (a mutant, a flipped verdict, an unfixed bug, a changed value) was run through the same checker; the rejection rates are in manifest.json.
  • Anti-template rules: sentences are composed from many alternatives, code-block and heading styles rotate, and a monitor over the finished text keeps every opening line, label and prose line at or below 1% of documents. Surfaces used by ALEA's evaluations are never emitted.
  • k-shot: formats documents hold 1-3 items (60/30/10%) of one family, with pairwise-distinct answers; labelled items are balanced. Copy-last and majority-label baselines are reported per family.
  • Decontamination: documents were checked against ALEA's evaluation sets (knowledge probe, ICL v1/v2, OOD-ICL, likelihood suite, general-facts probe, judge prompts, structured-formats baseline, chat probe, QA rounds), SHELF validation and test, OpenLemma v0.1's eval release, and this release's held-out items; overlapping documents were removed.

Token counts use the ALEA tokenizer alea-p1-prefix-16k (as in v0.1).

Licence and attribution

CC-BY-4.0. Attribute OpenLemma (https://github.com/mjbommar/openlemma). The value_pool rows and the values inside formats items come from Wikidata (2025-11 dump), which is CC0. No WordNet-derived material is included. gpt-6-luna output is subject to the provider's terms.

Known limitations

  • Kernel-based code surfaces reuse a 118-function library (with renames and varied text); synthesized surfaces and the LLM exercises supply the breadth. 12 kernels are held out for evaluation only.
  • decompile listings are pinned to CPython 3.14; other versions print different bytecode.
  • Decontamination against HumanEval/MBPP/APPS was not run (no local copy); the code is generated, not scraped.
  • Published before any model was trained on it; no claim about downstream gains.

Citation

@misc{openlemma2026,
  title  = {OpenLemma: verified, bottom-up synthetic data for logic, reasoning, algorithms and language},
  author = {Bommarito, Michael J.},
  year   = {2026},
  note   = {Version 0.2: formats v2 and verified code v2},
  url    = {https://github.com/mjbommar/openlemma}
}
Downloads last month
39