Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
parquet
Languages:
English
Size:
10K - 100K
License:
id large_stringlengths 17 17 | instruction large_stringlengths 149 154 | code large_stringlengths 195 214 | unit_test large_stringlengths 81 90 |
|---|---|---|---|
py_logic_00000001 | Write a Python function `process_pipeline_v1` that evaluates `state_flag` against boundary `23` using relational operator `>`, returning mutated state. | def process_pipeline_v1(state_flag, value_a):
state_result = 0
if state_flag > 23:
state_result = (state_flag + 25) * 2
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v1(28, 10) == 106
assert process_pipeline_v1(18, 20) == -5 |
py_logic_00000002 | Write a Python function `process_pipeline_v2` that evaluates `state_flag` against boundary `35` using relational operator `>`, returning mutated state. | def process_pipeline_v2(state_flag, value_b):
state_result = 0
if state_flag > 35:
state_result = (state_flag + 22) * 3
else:
state_result = value_b - 22
return state_result | assert process_pipeline_v2(40, 10) == 186
assert process_pipeline_v2(30, 20) == -2 |
py_logic_00000003 | Write a Python function `process_pipeline_v3` that evaluates `state_flag` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v3(state_flag, value_b):
state_result = 0
if state_flag > 46:
state_result = (state_flag + 19) * 3
else:
state_result = value_b - 19
return state_result | assert process_pipeline_v3(51, 10) == 210
assert process_pipeline_v3(41, 20) == 1 |
py_logic_00000004 | Write a Python function `process_pipeline_v4` that evaluates `state_flag` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v4(state_flag, state_flag):
state_result = 0
if state_flag > 54:
state_result = (state_flag + 14) * 4
else:
state_result = state_flag - 14
return state_result | assert process_pipeline_v4(59, 10) == 292
assert process_pipeline_v4(49, 20) == 6 |
py_logic_00000005 | Write a Python function `process_pipeline_v5` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v5(state_flag, state_flag):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 8) * 4
else:
state_result = state_flag - 8
return state_result | assert process_pipeline_v5(63, 10) == 284
assert process_pipeline_v5(53, 20) == 12 |
py_logic_00000006 | Write a Python function `process_pipeline_v6` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v6(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 2) * 4
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v6(64, 10) == 264
assert process_pipeline_v6(54, 20) == 18 |
py_logic_00000007 | Write a Python function `process_pipeline_v7` that evaluates `state_flag` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v7(state_flag, state_flag):
state_result = 0
if state_flag > 57:
state_result = (state_flag + 6) * 5
else:
state_result = state_flag - 6
return state_result | assert process_pipeline_v7(62, 10) == 340
assert process_pipeline_v7(52, 20) == 14 |
py_logic_00000008 | Write a Python function `process_pipeline_v8` that evaluates `state_flag` against boundary `51` using relational operator `>`, returning mutated state. | def process_pipeline_v8(state_flag, value_b):
state_result = 0
if state_flag > 51:
state_result = (state_flag + 12) * 5
else:
state_result = value_b - 12
return state_result | assert process_pipeline_v8(56, 10) == 340
assert process_pipeline_v8(46, 20) == 8 |
py_logic_00000009 | Write a Python function `process_pipeline_v9` that evaluates `state_flag` against boundary `42` using relational operator `>`, returning mutated state. | def process_pipeline_v9(state_flag, value_a):
state_result = 0
if state_flag > 42:
state_result = (state_flag + 17) * 5
else:
state_result = value_a - 17
return state_result | assert process_pipeline_v9(47, 10) == 320
assert process_pipeline_v9(37, 20) == 3 |
py_logic_00000010 | Write a Python function `process_pipeline_v10` that evaluates `state_flag` against boundary `31` using relational operator `>`, returning mutated state. | def process_pipeline_v10(state_flag, value_a):
state_result = 0
if state_flag > 31:
state_result = (state_flag + 21) * 5
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v10(36, 10) == 285
assert process_pipeline_v10(26, 20) == -1 |
py_logic_00000011 | Write a Python function `process_pipeline_v11` that evaluates `state_flag` against boundary `18` using relational operator `>`, returning mutated state. | def process_pipeline_v11(state_flag, value_b):
state_result = 0
if state_flag > 18:
state_result = (state_flag + 24) * 5
else:
state_result = value_b - 24
return state_result | assert process_pipeline_v11(23, 10) == 235
assert process_pipeline_v11(13, 20) == -4 |
py_logic_00000012 | Write a Python function `process_pipeline_v12` that evaluates `state_flag` against boundary `14` using relational operator `>`, returning mutated state. | def process_pipeline_v12(state_flag, value_b):
state_result = 0
if state_flag > 14:
state_result = (state_flag + 25) * 5
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v12(19, 10) == 220
assert process_pipeline_v12(9, 20) == -5 |
py_logic_00000013 | Write a Python function `process_pipeline_v13` that evaluates `state_flag` against boundary `28` using relational operator `>`, returning mutated state. | def process_pipeline_v13(state_flag, state_flag):
state_result = 0
if state_flag > 28:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v13(33, 10) == 290
assert process_pipeline_v13(23, 20) == -5 |
py_logic_00000014 | Write a Python function `process_pipeline_v14` that evaluates `state_flag` against boundary `39` using relational operator `>`, returning mutated state. | def process_pipeline_v14(state_flag, state_flag):
state_result = 0
if state_flag > 39:
state_result = (state_flag + 23) * 5
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v14(44, 10) == 335
assert process_pipeline_v14(34, 20) == -3 |
py_logic_00000015 | Write a Python function `process_pipeline_v15` that evaluates `state_flag` against boundary `49` using relational operator `>`, returning mutated state. | def process_pipeline_v15(state_flag, state_flag):
state_result = 0
if state_flag > 49:
state_result = (state_flag + 20) * 5
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v15(54, 10) == 370
assert process_pipeline_v15(44, 20) == 0 |
py_logic_00000016 | Write a Python function `process_pipeline_v16` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v16(state_flag, state_flag):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 16) * 5
else:
state_result = state_flag - 16
return state_result | assert process_pipeline_v16(61, 10) == 385
assert process_pipeline_v16(51, 20) == 4 |
py_logic_00000017 | Write a Python function `process_pipeline_v17` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v17(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 10) * 4
else:
state_result = state_flag - 10
return state_result | assert process_pipeline_v17(64, 10) == 296
assert process_pipeline_v17(54, 20) == 10 |
py_logic_00000018 | Write a Python function `process_pipeline_v18` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v18(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 4) * 4
else:
state_result = state_flag - 4
return state_result | assert process_pipeline_v18(64, 10) == 272
assert process_pipeline_v18(54, 20) == 16 |
py_logic_00000019 | Write a Python function `process_pipeline_v19` that evaluates `value_b` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v19(value_b, state_flag):
state_result = 0
if value_b > 55:
state_result = (value_b + 3) * 4
else:
state_result = state_flag - 3
return state_result | assert process_pipeline_v19(60, 10) == 252
assert process_pipeline_v19(50, 20) == 17 |
py_logic_00000020 | Write a Python function `process_pipeline_v20` that evaluates `value_b` against boundary `48` using relational operator `>`, returning mutated state. | def process_pipeline_v20(value_b, state_flag):
state_result = 0
if value_b > 48:
state_result = (value_b + 9) * 3
else:
state_result = state_flag - 9
return state_result | assert process_pipeline_v20(53, 10) == 186
assert process_pipeline_v20(43, 20) == 11 |
py_logic_00000021 | Write a Python function `process_pipeline_v21` that evaluates `value_b` against boundary `38` using relational operator `>`, returning mutated state. | def process_pipeline_v21(value_b, state_flag):
state_result = 0
if value_b > 38:
state_result = (value_b + 15) * 3
else:
state_result = state_flag - 15
return state_result | assert process_pipeline_v21(43, 10) == 174
assert process_pipeline_v21(33, 20) == 5 |
py_logic_00000022 | Write a Python function `process_pipeline_v22` that evaluates `value_a` against boundary `26` using relational operator `>`, returning mutated state. | def process_pipeline_v22(value_a, state_flag):
state_result = 0
if value_a > 26:
state_result = (value_a + 20) * 2
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v22(31, 10) == 102
assert process_pipeline_v22(21, 20) == 0 |
py_logic_00000023 | Write a Python function `process_pipeline_v23` that evaluates `value_a` against boundary `13` using relational operator `>`, returning mutated state. | def process_pipeline_v23(value_a, state_flag):
state_result = 0
if value_a > 13:
state_result = (value_a + 23) * 2
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v23(18, 10) == 82
assert process_pipeline_v23(8, 20) == -3 |
py_logic_00000024 | Write a Python function `process_pipeline_v24` that evaluates `value_a` against boundary `19` using relational operator `>`, returning mutated state. | def process_pipeline_v24(value_a, value_b):
state_result = 0
if value_a > 19:
state_result = (value_a + 25) * 2
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v24(24, 10) == 98
assert process_pipeline_v24(14, 20) == -5 |
py_logic_00000025 | Write a Python function `process_pipeline_v25` that evaluates `value_a` against boundary `32` using relational operator `>`, returning mutated state. | def process_pipeline_v25(value_a, value_b):
state_result = 0
if value_a > 32:
state_result = (value_a + 25) * 2
else:
state_result = value_b - 25
return state_result | assert process_pipeline_v25(37, 10) == 124
assert process_pipeline_v25(27, 20) == -5 |
py_logic_00000026 | Write a Python function `process_pipeline_v26` that evaluates `value_b` against boundary `43` using relational operator `>`, returning mutated state. | def process_pipeline_v26(value_b, value_b):
state_result = 0
if value_b > 43:
state_result = (value_b + 24) * 3
else:
state_result = value_b - 24
return state_result | assert process_pipeline_v26(48, 10) == 216
assert process_pipeline_v26(38, 20) == -4 |
py_logic_00000027 | Write a Python function `process_pipeline_v27` that evaluates `value_b` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v27(value_b, value_b):
state_result = 0
if value_b > 52:
state_result = (value_b + 22) * 3
else:
state_result = value_b - 22
return state_result | assert process_pipeline_v27(57, 10) == 237
assert process_pipeline_v27(47, 20) == -2 |
py_logic_00000028 | Write a Python function `process_pipeline_v28` that evaluates `state_flag` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v28(state_flag, value_b):
state_result = 0
if state_flag > 57:
state_result = (state_flag + 17) * 4
else:
state_result = value_b - 17
return state_result | assert process_pipeline_v28(62, 10) == 316
assert process_pipeline_v28(52, 20) == 3 |
py_logic_00000029 | Write a Python function `process_pipeline_v29` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v29(state_flag, value_b):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 12) * 4
else:
state_result = value_b - 12
return state_result | assert process_pipeline_v29(64, 10) == 304
assert process_pipeline_v29(54, 20) == 8 |
py_logic_00000030 | Write a Python function `process_pipeline_v30` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v30(state_flag, value_b):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 6) * 5
else:
state_result = value_b - 6
return state_result | assert process_pipeline_v30(63, 10) == 345
assert process_pipeline_v30(53, 20) == 14 |
py_logic_00000031 | Write a Python function `process_pipeline_v31` that evaluates `state_flag` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v31(state_flag, state_flag):
state_result = 0
if state_flag > 53:
state_result = (state_flag + 1) * 5
else:
state_result = state_flag - 1
return state_result | assert process_pipeline_v31(58, 10) == 295
assert process_pipeline_v31(48, 20) == 19 |
py_logic_00000032 | Write a Python function `process_pipeline_v32` that evaluates `state_flag` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v32(state_flag, state_flag):
state_result = 0
if state_flag > 45:
state_result = (state_flag + 7) * 5
else:
state_result = state_flag - 7
return state_result | assert process_pipeline_v32(50, 10) == 285
assert process_pipeline_v32(40, 20) == 13 |
py_logic_00000033 | Write a Python function `process_pipeline_v33` that evaluates `state_flag` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v33(state_flag, state_flag):
state_result = 0
if state_flag > 34:
state_result = (state_flag + 13) * 5
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v33(39, 10) == 260
assert process_pipeline_v33(29, 20) == 7 |
py_logic_00000034 | Write a Python function `process_pipeline_v34` that evaluates `state_flag` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v34(state_flag, state_flag):
state_result = 0
if state_flag > 22:
state_result = (state_flag + 18) * 5
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v34(27, 10) == 225
assert process_pipeline_v34(17, 20) == 2 |
py_logic_00000035 | Write a Python function `process_pipeline_v35` that evaluates `state_flag` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v35(state_flag, state_flag):
state_result = 0
if state_flag > 11:
state_result = (state_flag + 22) * 5
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v35(16, 10) == 190
assert process_pipeline_v35(6, 20) == -2 |
py_logic_00000036 | Write a Python function `process_pipeline_v36` that evaluates `state_flag` against boundary `24` using relational operator `>`, returning mutated state. | def process_pipeline_v36(state_flag, state_flag):
state_result = 0
if state_flag > 24:
state_result = (state_flag + 24) * 5
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v36(29, 10) == 265
assert process_pipeline_v36(19, 20) == -4 |
py_logic_00000037 | Write a Python function `process_pipeline_v37` that evaluates `state_flag` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v37(state_flag, state_flag):
state_result = 0
if state_flag > 36:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v37(41, 10) == 330
assert process_pipeline_v37(31, 20) == -5 |
py_logic_00000038 | Write a Python function `process_pipeline_v38` that evaluates `state_flag` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v38(state_flag, state_flag):
state_result = 0
if state_flag > 47:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v38(52, 10) == 385
assert process_pipeline_v38(42, 20) == -5 |
py_logic_00000039 | Write a Python function `process_pipeline_v39` that evaluates `state_flag` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v39(state_flag, state_flag):
state_result = 0
if state_flag > 54:
state_result = (state_flag + 23) * 5
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v39(59, 10) == 410
assert process_pipeline_v39(49, 20) == -3 |
py_logic_00000040 | Write a Python function `process_pipeline_v40` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v40(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 19) * 5
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v40(64, 10) == 415
assert process_pipeline_v40(54, 20) == 1 |
py_logic_00000041 | Write a Python function `process_pipeline_v41` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v41(state_flag, value_b):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 14) * 4
else:
state_result = value_b - 14
return state_result | assert process_pipeline_v41(64, 10) == 312
assert process_pipeline_v41(54, 20) == 6 |
py_logic_00000042 | Write a Python function `process_pipeline_v42` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v42(value_b, value_b):
state_result = 0
if value_b > 57:
state_result = (value_b + 9) * 4
else:
state_result = value_b - 9
return state_result | assert process_pipeline_v42(62, 10) == 284
assert process_pipeline_v42(52, 20) == 11 |
py_logic_00000043 | Write a Python function `process_pipeline_v43` that evaluates `value_b` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v43(value_b, value_b):
state_result = 0
if value_b > 50:
state_result = (value_b + 3) * 3
else:
state_result = value_b - 3
return state_result | assert process_pipeline_v43(55, 10) == 174
assert process_pipeline_v43(45, 20) == 17 |
py_logic_00000044 | Write a Python function `process_pipeline_v44` that evaluates `value_b` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v44(value_b, value_b):
state_result = 0
if value_b > 41:
state_result = (value_b + 5) * 3
else:
state_result = value_b - 5
return state_result | assert process_pipeline_v44(46, 10) == 153
assert process_pipeline_v44(36, 20) == 15 |
py_logic_00000045 | Write a Python function `process_pipeline_v45` that evaluates `value_b` against boundary `30` using relational operator `>`, returning mutated state. | def process_pipeline_v45(value_b, value_a):
state_result = 0
if value_b > 30:
state_result = (value_b + 11) * 2
else:
state_result = value_a - 11
return state_result | assert process_pipeline_v45(35, 10) == 92
assert process_pipeline_v45(25, 20) == 9 |
py_logic_00000046 | Write a Python function `process_pipeline_v46` that evaluates `value_a` against boundary `17` using relational operator `>`, returning mutated state. | def process_pipeline_v46(value_a, value_a):
state_result = 0
if value_a > 17:
state_result = (value_a + 16) * 2
else:
state_result = value_a - 16
return state_result | assert process_pipeline_v46(22, 10) == 76
assert process_pipeline_v46(12, 20) == 4 |
py_logic_00000047 | Write a Python function `process_pipeline_v47` that evaluates `value_a` against boundary `16` using relational operator `>`, returning mutated state. | def process_pipeline_v47(value_a, value_a):
state_result = 0
if value_a > 16:
state_result = (value_a + 21) * 2
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v47(21, 10) == 84
assert process_pipeline_v47(11, 20) == -1 |
py_logic_00000048 | Write a Python function `process_pipeline_v48` that evaluates `value_b` against boundary `29` using relational operator `>`, returning mutated state. | def process_pipeline_v48(value_b, value_a):
state_result = 0
if value_b > 29:
state_result = (value_b + 24) * 2
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v48(34, 10) == 116
assert process_pipeline_v48(24, 20) == -4 |
py_logic_00000049 | Write a Python function `process_pipeline_v49` that evaluates `value_b` against boundary `40` using relational operator `>`, returning mutated state. | def process_pipeline_v49(value_b, value_a):
state_result = 0
if value_b > 40:
state_result = (value_b + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v49(45, 10) == 210
assert process_pipeline_v49(35, 20) == -5 |
py_logic_00000050 | Write a Python function `process_pipeline_v50` that evaluates `value_b` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v50(value_b, value_a):
state_result = 0
if value_b > 50:
state_result = (value_b + 25) * 3
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v50(55, 10) == 240
assert process_pipeline_v50(45, 20) == -5 |
py_logic_00000051 | Write a Python function `process_pipeline_v51` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v51(state_flag, value_a):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 24) * 4
else:
state_result = value_a - 24
return state_result | assert process_pipeline_v51(61, 10) == 340
assert process_pipeline_v51(51, 20) == -4 |
py_logic_00000052 | Write a Python function `process_pipeline_v52` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v52(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 21) * 4
else:
state_result = value_a - 21
return state_result | assert process_pipeline_v52(64, 10) == 340
assert process_pipeline_v52(54, 20) == -1 |
py_logic_00000053 | Write a Python function `process_pipeline_v53` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v53(state_flag, value_b):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 16) * 5
else:
state_result = value_b - 16
return state_result | assert process_pipeline_v53(64, 10) == 400
assert process_pipeline_v53(54, 20) == 4 |
py_logic_00000054 | Write a Python function `process_pipeline_v54` that evaluates `state_flag` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v54(state_flag, value_b):
state_result = 0
if state_flag > 55:
state_result = (state_flag + 11) * 5
else:
state_result = value_b - 11
return state_result | assert process_pipeline_v54(60, 10) == 355
assert process_pipeline_v54(50, 20) == 9 |
py_logic_00000055 | Write a Python function `process_pipeline_v55` that evaluates `state_flag` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v55(state_flag, state_flag):
state_result = 0
if state_flag > 47:
state_result = (state_flag + 5) * 5
else:
state_result = state_flag - 5
return state_result | assert process_pipeline_v55(52, 10) == 285
assert process_pipeline_v55(42, 20) == 15 |
py_logic_00000056 | Write a Python function `process_pipeline_v56` that evaluates `state_flag` against boundary `37` using relational operator `>`, returning mutated state. | def process_pipeline_v56(state_flag, state_flag):
state_result = 0
if state_flag > 37:
state_result = (state_flag + 2) * 5
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v56(42, 10) == 220
assert process_pipeline_v56(32, 20) == 18 |
py_logic_00000057 | Write a Python function `process_pipeline_v57` that evaluates `value_b` against boundary `25` using relational operator `>`, returning mutated state. | def process_pipeline_v57(value_b, state_flag):
state_result = 0
if value_b > 25:
state_result = (value_b + 9) * 5
else:
state_result = state_flag - 9
return state_result | assert process_pipeline_v57(30, 10) == 195
assert process_pipeline_v57(20, 20) == 11 |
py_logic_00000058 | Write a Python function `process_pipeline_v58` that evaluates `value_a` against boundary `12` using relational operator `>`, returning mutated state. | def process_pipeline_v58(value_a, state_flag):
state_result = 0
if value_a > 12:
state_result = (value_a + 14) * 5
else:
state_result = state_flag - 14
return state_result | assert process_pipeline_v58(17, 10) == 155
assert process_pipeline_v58(7, 20) == 6 |
py_logic_00000059 | Write a Python function `process_pipeline_v59` that evaluates `value_a` against boundary `21` using relational operator `>`, returning mutated state. | def process_pipeline_v59(value_a, state_flag):
state_result = 0
if value_a > 21:
state_result = (value_a + 19) * 5
else:
state_result = state_flag - 19
return state_result | assert process_pipeline_v59(26, 10) == 225
assert process_pipeline_v59(16, 20) == 1 |
py_logic_00000060 | Write a Python function `process_pipeline_v60` that evaluates `value_b` against boundary `33` using relational operator `>`, returning mutated state. | def process_pipeline_v60(value_b, state_flag):
state_result = 0
if value_b > 33:
state_result = (value_b + 23) * 5
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v60(38, 10) == 305
assert process_pipeline_v60(28, 20) == -3 |
py_logic_00000061 | Write a Python function `process_pipeline_v61` that evaluates `value_b` against boundary `44` using relational operator `>`, returning mutated state. | def process_pipeline_v61(value_b, state_flag):
state_result = 0
if value_b > 44:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v61(49, 10) == 370
assert process_pipeline_v61(39, 20) == -5 |
py_logic_00000062 | Write a Python function `process_pipeline_v62` that evaluates `state_flag` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v62(state_flag, state_flag):
state_result = 0
if state_flag > 52:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v62(57, 10) == 410
assert process_pipeline_v62(47, 20) == -5 |
py_logic_00000063 | Write a Python function `process_pipeline_v63` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v63(state_flag, state_flag):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v63(63, 10) == 440
assert process_pipeline_v63(53, 20) == -5 |
py_logic_00000064 | Write a Python function `process_pipeline_v64` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v64(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 22) * 4
else:
state_result = state_flag - 22
return state_result | assert process_pipeline_v64(64, 10) == 344
assert process_pipeline_v64(54, 20) == -2 |
py_logic_00000065 | Write a Python function `process_pipeline_v65` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v65(state_flag, state_flag):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 18) * 4
else:
state_result = state_flag - 18
return state_result | assert process_pipeline_v65(63, 10) == 324
assert process_pipeline_v65(53, 20) == 2 |
py_logic_00000066 | Write a Python function `process_pipeline_v66` that evaluates `state_flag` against boundary `52` using relational operator `>`, returning mutated state. | def process_pipeline_v66(state_flag, state_flag):
state_result = 0
if state_flag > 52:
state_result = (state_flag + 13) * 3
else:
state_result = state_flag - 13
return state_result | assert process_pipeline_v66(57, 10) == 210
assert process_pipeline_v66(47, 20) == 7 |
py_logic_00000067 | Write a Python function `process_pipeline_v67` that evaluates `state_flag` against boundary `44` using relational operator `>`, returning mutated state. | def process_pipeline_v67(state_flag, value_b):
state_result = 0
if state_flag > 44:
state_result = (state_flag + 7) * 3
else:
state_result = value_b - 7
return state_result | assert process_pipeline_v67(49, 10) == 168
assert process_pipeline_v67(39, 20) == 13 |
py_logic_00000068 | Write a Python function `process_pipeline_v68` that evaluates `value_b` against boundary `33` using relational operator `>`, returning mutated state. | def process_pipeline_v68(value_b, value_a):
state_result = 0
if value_b > 33:
state_result = (value_b + 1) * 2
else:
state_result = value_a - 1
return state_result | assert process_pipeline_v68(38, 10) == 78
assert process_pipeline_v68(28, 20) == 19 |
py_logic_00000069 | Write a Python function `process_pipeline_v69` that evaluates `value_b` against boundary `20` using relational operator `>`, returning mutated state. | def process_pipeline_v69(value_b, value_a):
state_result = 0
if value_b > 20:
state_result = (value_b + 6) * 2
else:
state_result = value_a - 6
return state_result | assert process_pipeline_v69(25, 10) == 62
assert process_pipeline_v69(15, 20) == 14 |
py_logic_00000070 | Write a Python function `process_pipeline_v70` that evaluates `state_flag` against boundary `12` using relational operator `>`, returning mutated state. | def process_pipeline_v70(state_flag, value_a):
state_result = 0
if state_flag > 12:
state_result = (state_flag + 12) * 2
else:
state_result = value_a - 12
return state_result | assert process_pipeline_v70(17, 10) == 58
assert process_pipeline_v70(7, 20) == 8 |
py_logic_00000071 | Write a Python function `process_pipeline_v71` that evaluates `state_flag` against boundary `25` using relational operator `>`, returning mutated state. | def process_pipeline_v71(state_flag, value_b):
state_result = 0
if state_flag > 25:
state_result = (state_flag + 17) * 2
else:
state_result = value_b - 17
return state_result | assert process_pipeline_v71(30, 10) == 94
assert process_pipeline_v71(20, 20) == 3 |
py_logic_00000072 | Write a Python function `process_pipeline_v72` that evaluates `state_flag` against boundary `37` using relational operator `>`, returning mutated state. | def process_pipeline_v72(state_flag, state_flag):
state_result = 0
if state_flag > 37:
state_result = (state_flag + 21) * 3
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v72(42, 10) == 189
assert process_pipeline_v72(32, 20) == -1 |
py_logic_00000073 | Write a Python function `process_pipeline_v73` that evaluates `state_flag` against boundary `47` using relational operator `>`, returning mutated state. | def process_pipeline_v73(state_flag, state_flag):
state_result = 0
if state_flag > 47:
state_result = (state_flag + 24) * 3
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v73(52, 10) == 228
assert process_pipeline_v73(42, 20) == -4 |
py_logic_00000074 | Write a Python function `process_pipeline_v74` that evaluates `state_flag` against boundary `55` using relational operator `>`, returning mutated state. | def process_pipeline_v74(state_flag, state_flag):
state_result = 0
if state_flag > 55:
state_result = (state_flag + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v74(60, 10) == 340
assert process_pipeline_v74(50, 20) == -5 |
py_logic_00000075 | Write a Python function `process_pipeline_v75` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v75(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v75(64, 10) == 356
assert process_pipeline_v75(54, 20) == -5 |
py_logic_00000076 | Write a Python function `process_pipeline_v76` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v76(state_flag, state_flag):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 23) * 4
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v76(64, 10) == 348
assert process_pipeline_v76(54, 20) == -3 |
py_logic_00000077 | Write a Python function `process_pipeline_v77` that evaluates `state_flag` against boundary `56` using relational operator `>`, returning mutated state. | def process_pipeline_v77(state_flag, state_flag):
state_result = 0
if state_flag > 56:
state_result = (state_flag + 20) * 5
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v77(61, 10) == 405
assert process_pipeline_v77(51, 20) == 0 |
py_logic_00000078 | Write a Python function `process_pipeline_v78` that evaluates `state_flag` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v78(state_flag, state_flag):
state_result = 0
if state_flag > 50:
state_result = (state_flag + 15) * 5
else:
state_result = state_flag - 15
return state_result | assert process_pipeline_v78(55, 10) == 350
assert process_pipeline_v78(45, 20) == 5 |
py_logic_00000079 | Write a Python function `process_pipeline_v79` that evaluates `state_flag` against boundary `40` using relational operator `>`, returning mutated state. | def process_pipeline_v79(state_flag, state_flag):
state_result = 0
if state_flag > 40:
state_result = (state_flag + 10) * 5
else:
state_result = state_flag - 10
return state_result | assert process_pipeline_v79(45, 10) == 275
assert process_pipeline_v79(35, 20) == 10 |
py_logic_00000080 | Write a Python function `process_pipeline_v80` that evaluates `state_flag` against boundary `29` using relational operator `>`, returning mutated state. | def process_pipeline_v80(state_flag, state_flag):
state_result = 0
if state_flag > 29:
state_result = (state_flag + 3) * 5
else:
state_result = state_flag - 3
return state_result | assert process_pipeline_v80(34, 10) == 185
assert process_pipeline_v80(24, 20) == 17 |
py_logic_00000081 | Write a Python function `process_pipeline_v81` that evaluates `state_flag` against boundary `16` using relational operator `>`, returning mutated state. | def process_pipeline_v81(state_flag, state_flag):
state_result = 0
if state_flag > 16:
state_result = (state_flag + 4) * 5
else:
state_result = state_flag - 4
return state_result | assert process_pipeline_v81(21, 10) == 125
assert process_pipeline_v81(11, 20) == 16 |
py_logic_00000082 | Write a Python function `process_pipeline_v82` that evaluates `state_flag` against boundary `17` using relational operator `>`, returning mutated state. | def process_pipeline_v82(state_flag, state_flag):
state_result = 0
if state_flag > 17:
state_result = (state_flag + 10) * 5
else:
state_result = state_flag - 10
return state_result | assert process_pipeline_v82(22, 10) == 160
assert process_pipeline_v82(12, 20) == 10 |
py_logic_00000083 | Write a Python function `process_pipeline_v83` that evaluates `state_flag` against boundary `30` using relational operator `>`, returning mutated state. | def process_pipeline_v83(state_flag, state_flag):
state_result = 0
if state_flag > 30:
state_result = (state_flag + 16) * 5
else:
state_result = state_flag - 16
return state_result | assert process_pipeline_v83(35, 10) == 255
assert process_pipeline_v83(25, 20) == 4 |
py_logic_00000084 | Write a Python function `process_pipeline_v84` that evaluates `state_flag` against boundary `41` using relational operator `>`, returning mutated state. | def process_pipeline_v84(state_flag, state_flag):
state_result = 0
if state_flag > 41:
state_result = (state_flag + 20) * 5
else:
state_result = state_flag - 20
return state_result | assert process_pipeline_v84(46, 10) == 330
assert process_pipeline_v84(36, 20) == 0 |
py_logic_00000085 | Write a Python function `process_pipeline_v85` that evaluates `value_b` against boundary `50` using relational operator `>`, returning mutated state. | def process_pipeline_v85(value_b, state_flag):
state_result = 0
if value_b > 50:
state_result = (value_b + 23) * 5
else:
state_result = state_flag - 23
return state_result | assert process_pipeline_v85(55, 10) == 390
assert process_pipeline_v85(45, 20) == -3 |
py_logic_00000086 | Write a Python function `process_pipeline_v86` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v86(value_b, state_flag):
state_result = 0
if value_b > 57:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v86(62, 10) == 435
assert process_pipeline_v86(52, 20) == -5 |
py_logic_00000087 | Write a Python function `process_pipeline_v87` that evaluates `value_b` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v87(value_b, state_flag):
state_result = 0
if value_b > 59:
state_result = (value_b + 25) * 4
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v87(64, 10) == 356
assert process_pipeline_v87(54, 20) == -5 |
py_logic_00000088 | Write a Python function `process_pipeline_v88` that evaluates `value_a` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v88(value_a, state_flag):
state_result = 0
if value_a > 59:
state_result = (value_a + 24) * 4
else:
state_result = state_flag - 24
return state_result | assert process_pipeline_v88(64, 10) == 352
assert process_pipeline_v88(54, 20) == -4 |
py_logic_00000089 | Write a Python function `process_pipeline_v89` that evaluates `value_a` against boundary `54` using relational operator `>`, returning mutated state. | def process_pipeline_v89(value_a, state_flag):
state_result = 0
if value_a > 54:
state_result = (value_a + 21) * 4
else:
state_result = state_flag - 21
return state_result | assert process_pipeline_v89(59, 10) == 320
assert process_pipeline_v89(49, 20) == -1 |
py_logic_00000090 | Write a Python function `process_pipeline_v90` that evaluates `value_a` against boundary `46` using relational operator `>`, returning mutated state. | def process_pipeline_v90(value_a, state_flag):
state_result = 0
if value_a > 46:
state_result = (value_a + 17) * 3
else:
state_result = state_flag - 17
return state_result | assert process_pipeline_v90(51, 10) == 204
assert process_pipeline_v90(41, 20) == 3 |
py_logic_00000091 | Write a Python function `process_pipeline_v91` that evaluates `value_a` against boundary `36` using relational operator `>`, returning mutated state. | def process_pipeline_v91(value_a, state_flag):
state_result = 0
if value_a > 36:
state_result = (value_a + 12) * 3
else:
state_result = state_flag - 12
return state_result | assert process_pipeline_v91(41, 10) == 159
assert process_pipeline_v91(31, 20) == 8 |
py_logic_00000092 | Write a Python function `process_pipeline_v92` that evaluates `value_b` against boundary `24` using relational operator `>`, returning mutated state. | def process_pipeline_v92(value_b, state_flag):
state_result = 0
if value_b > 24:
state_result = (value_b + 6) * 2
else:
state_result = state_flag - 6
return state_result | assert process_pipeline_v92(29, 10) == 70
assert process_pipeline_v92(19, 20) == 14 |
py_logic_00000093 | Write a Python function `process_pipeline_v93` that evaluates `value_b` against boundary `11` using relational operator `>`, returning mutated state. | def process_pipeline_v93(value_b, state_flag):
state_result = 0
if value_b > 11:
state_result = (value_b + 2) * 2
else:
state_result = state_flag - 2
return state_result | assert process_pipeline_v93(16, 10) == 36
assert process_pipeline_v93(6, 20) == 18 |
py_logic_00000094 | Write a Python function `process_pipeline_v94` that evaluates `value_b` against boundary `22` using relational operator `>`, returning mutated state. | def process_pipeline_v94(value_b, value_b):
state_result = 0
if value_b > 22:
state_result = (value_b + 8) * 2
else:
state_result = value_b - 8
return state_result | assert process_pipeline_v94(27, 10) == 70
assert process_pipeline_v94(17, 20) == 12 |
py_logic_00000095 | Write a Python function `process_pipeline_v95` that evaluates `value_b` against boundary `34` using relational operator `>`, returning mutated state. | def process_pipeline_v95(value_b, value_b):
state_result = 0
if value_b > 34:
state_result = (value_b + 14) * 3
else:
state_result = value_b - 14
return state_result | assert process_pipeline_v95(39, 10) == 159
assert process_pipeline_v95(29, 20) == 6 |
py_logic_00000096 | Write a Python function `process_pipeline_v96` that evaluates `state_flag` against boundary `45` using relational operator `>`, returning mutated state. | def process_pipeline_v96(state_flag, value_b):
state_result = 0
if state_flag > 45:
state_result = (state_flag + 18) * 3
else:
state_result = value_b - 18
return state_result | assert process_pipeline_v96(50, 10) == 204
assert process_pipeline_v96(40, 20) == 2 |
py_logic_00000097 | Write a Python function `process_pipeline_v97` that evaluates `state_flag` against boundary `53` using relational operator `>`, returning mutated state. | def process_pipeline_v97(state_flag, value_a):
state_result = 0
if state_flag > 53:
state_result = (state_flag + 22) * 4
else:
state_result = value_a - 22
return state_result | assert process_pipeline_v97(58, 10) == 320
assert process_pipeline_v97(48, 20) == -2 |
py_logic_00000098 | Write a Python function `process_pipeline_v98` that evaluates `state_flag` against boundary `58` using relational operator `>`, returning mutated state. | def process_pipeline_v98(state_flag, value_a):
state_result = 0
if state_flag > 58:
state_result = (state_flag + 25) * 4
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v98(63, 10) == 352
assert process_pipeline_v98(53, 20) == -5 |
py_logic_00000099 | Write a Python function `process_pipeline_v99` that evaluates `state_flag` against boundary `59` using relational operator `>`, returning mutated state. | def process_pipeline_v99(state_flag, value_a):
state_result = 0
if state_flag > 59:
state_result = (state_flag + 25) * 4
else:
state_result = value_a - 25
return state_result | assert process_pipeline_v99(64, 10) == 356
assert process_pipeline_v99(54, 20) == -5 |
py_logic_00000100 | Write a Python function `process_pipeline_v100` that evaluates `value_b` against boundary `57` using relational operator `>`, returning mutated state. | def process_pipeline_v100(value_b, state_flag):
state_result = 0
if value_b > 57:
state_result = (value_b + 25) * 5
else:
state_result = state_flag - 25
return state_result | assert process_pipeline_v100(62, 10) == 435
assert process_pipeline_v100(52, 20) == -5 |
End of preview. Expand in Data Studio
Deterministic Synthetic Python Logic & Assertion Dataset
A high-entropy, 100% syntactically verified synthetic dataset of Python conditional logic, multi-variable state mutations, and ground-truth unit test assertions.
Dataset Overview
- Rows: 10,000 verified execution pairs
- Format: Apache Parquet (Snappy Compressed)
- Zero Hallucination: Every function includes closed-form deterministic unit test assertions.
- Purpose: Designed to fine-tune code LLMs on multi-variable boundary reasoning and execution state tracking.
Schema
| Column | Type | Description |
|---|---|---|
id |
string | Unique deterministic sample identifier |
instruction |
string | Natural language code generation prompt |
code |
string | Executable Python function implementation |
unit_test |
string | Ground-truth unit test suite (assert statements) |
Quickstart
from datasets import load_dataset
dataset = load_dataset("adolessence101-ally/python-logic-assertions")
print(dataset["train"][0])
- Downloads last month
- 20