Datasets:

mjbommar
/

openlemma-v0.4-programs

id stringlengths 23 26	text stringlengths 20 1.37k	format stringclasses 2 values	messages listlengths 2 4 ⌀	family stringclasses 1 value	sub stringclasses 3 values	variant stringclasses 1 value	variant_of stringclasses 0 values	generator stringclasses 1 value	sources listlengths 0 0	source_ids listlengths 0 0	n_tokens_alea int64 8 494	meta stringlengths 47 170
nlprog_det-arith-0000000	<\|start\|><\|user\|> Drill: 1,410 ÷ 5 is<\|eot\|> <\|assistant\|> 1,410 ÷ 5 = 282<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Drill: 1,410 ÷ 5 is" }, { "role": "assistant", "content": "1,410 ÷ 5 = 282" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	32	{"a": 1410, "b": 5, "notation": "÷", "commas": true, "carries": null, "shown": "1,410 ÷ 5", "gold": "282", "printed": "282"}
nlprog_det-arith-0000001	What's 67318 + 45443? Exact answer, please. ```python print(67318 + 45443) ``` Executing it gives 112761. Answer 112761.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	61	{"a": 67318, "b": 45443, "notation": "+", "commas": false, "carries": 3, "shown": "67318 + 45443", "gold": "112761", "printed": "112761"}
nlprog_det-arith-0000002	Try this: Figure out 300 - 177. 300 - 177 = 123	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	21	{"a": 300, "b": 177, "notation": "-", "commas": true, "carries": 2, "shown": "300 - 177", "gold": "123", "printed": "123"}
nlprog_det-arith-0000004	<\|start\|><\|user\|> What is 2000 − 101? Give the exact value.<\|eot\|> <\|assistant\|> ```python print(2000 - 101) # 1899 ``` Printed result — 1899 So we have 1899.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "What is 2000 − 101? Give the exact value." }, { "role": "assistant", "content": "```python\nprint(2000 - 101) # 1899\n```\nPrinted result — 1899\n\nSo we have 1899." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 2000, "b": 101, "notation": "−", "commas": false, "carries": 3, "shown": "2000 − 101", "gold": "1899", "printed": "1899"}
nlprog_det-arith-0000005	What is 76360 / 92? In parts: 76360 ÷ 92 = 830 check: 92 × 830 = 76360 The result is 830.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	46	{"a": 76360, "b": 92, "notation": "/", "commas": false, "carries": null, "shown": "76360 / 92", "gold": "830", "printed": "830"}
nlprog_det-arith-0000006	Remove 254 from 2,000; what is left? 1,746	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	20	{"a": 2000, "b": 254, "notation": "difference", "commas": true, "carries": 3, "shown": "the difference between 2,000 and 254", "gold": "1746", "printed": "1746"}
nlprog_det-arith-0000007	<\|start\|><\|user\|> Determine 10502 divided by 59.<\|eot\|> <\|assistant\|> ```python print(10502 // 59) # 178 ``` (Printed result: 178) 178<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Determine 10502 divided by 59." }, { "role": "assistant", "content": "```python\nprint(10502 // 59) # 178\n```\n(Printed result: 178)\n\n178" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	57	{"a": 10502, "b": 59, "notation": "divided by", "commas": false, "carries": null, "shown": "10502 divided by 59", "gold": "178", "printed": "178"}
nlprog_det-arith-0000009	Tell me 26877 − 22969. Integers only. 26877 − 22900 = 3977 3977 − 69 = 3908 This yields 3908.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	53	{"a": 26877, "b": 22969, "notation": "−", "commas": false, "carries": 2, "shown": "26877 − 22969", "gold": "3908", "printed": "3908"}
nlprog_det-arith-0000010	How much is 300 minus 26? A Python solution: ```python print(300 - 26) # 274 ``` stdout: 274 That is: 274	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	55	{"a": 300, "b": 26, "notation": "minus", "commas": false, "carries": 2, "shown": "300 minus 26", "gold": "274", "printed": "274"}
nlprog_det-arith-0000011	Take 50 times 58. Working: 50 × 50 = 2500 50 × 8 = 400 2500 + 400 = 2900 So the answer is 2900.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	46	{"a": 50, "b": 58, "notation": "product", "commas": false, "carries": null, "shown": "the product of 50 and 58", "gold": "2900", "printed": "2900"}
nlprog_det-arith-0000012	Determine 50 * 88. Integers only. Here is the program. ```python print(50 * 88) # 4400 ``` Interpreter output — 4400 We end up with 4,400.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 50, "b": 88, "notation": "", "commas": true, "carries": null, "shown": "50 88", "gold": "4400", "printed": "4400"}
nlprog_det-arith-0000013	<\|start\|><\|user\|> 100 minus 51 is how much? Exact answer, please.<\|eot\|> <\|assistant\|> print(100 - 51) # 49 Run output — 49 Answer 49.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "100 minus 51 is how much? Exact answer, please." }, { "role": "assistant", "content": " print(100 - 51) # 49\nRun output — 49\n\nAnswer 49." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	45	{"a": 100, "b": 51, "notation": "minus", "commas": true, "carries": 2, "shown": "100 minus 51", "gold": "49", "printed": "49"}
nlprog_det-arith-0000014	Number work: Please find 2863 added to 77016. 79879	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	21	{"a": 77016, "b": 2863, "notation": "added", "commas": false, "carries": 0, "shown": "2863 added to 77016", "gold": "79879", "printed": "79879"}
nlprog_det-arith-0000015	<\|start\|><\|user\|> Question of the day: Tell me 72054 plus 31225.<\|eot\|> <\|assistant\|> 103279<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Question of the day: Tell me 72054 plus 31225." }, { "role": "assistant", "content": "103279" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	31	{"a": 72054, "b": 31225, "notation": "plus", "commas": false, "carries": 1, "shown": "72054 plus 31225", "gold": "103279", "printed": "103279"}
nlprog_det-arith-0000016	Bookkeeping check: 72 x 901 = Python does the arithmetic: ```python print(72 * 901) ``` # program output: 64872 Which gives 64,872.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	59	{"a": 72, "b": 901, "notation": "x", "commas": true, "carries": null, "shown": "72 x 901", "gold": "64872", "printed": "64872"}
nlprog_det-arith-0000017	Problem: 4 x 3684 equals Python: 4 * 3684 Result: 14736 14736	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	35	{"a": 4, "b": 3684, "notation": "x", "commas": false, "carries": null, "shown": "4 x 3684", "gold": "14736", "printed": "14736"}
nlprog_det-arith-0000018	How many times does 75 go into 750? Python version: ```python print(750 // 75) # 10 ``` Running it prints: 10 Upshot: 10	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 750, "b": 75, "notation": "divided by", "commas": true, "carries": null, "shown": "750 divided by 75", "gold": "10", "printed": "10"}
nlprog_det-arith-0000019	From the workbook: Work out 400 - 85. Script: ```python print(400 - 85) # 315 ``` # execution result: 315 315	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	49	{"a": 400, "b": 85, "notation": "-", "commas": true, "carries": 2, "shown": "400 - 85", "gold": "315", "printed": "315"}
nlprog_det-arith-0000020	Try this: Please find 7740 plus 7737. Split it: 7740 + 7700 = 15440 15440 + 37 = 15477 It must be 15477.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	48	{"a": 7740, "b": 7737, "notation": "plus", "commas": false, "carries": 2, "shown": "7740 plus 7737", "gold": "15477", "printed": "15477"}
nlprog_det-arith-0000021	Take 118 away from 300. 182	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	10	{"a": 300, "b": 118, "notation": "minus", "commas": false, "carries": 2, "shown": "300 minus 118", "gold": "182", "printed": "182"}
nlprog_det-arith-0000022	<\|start\|><\|user\|> Easy one: 74,175 / 75 equals<\|eot\|> <\|assistant\|> ```python print(74175 // 75) # 989 ``` Result: 989 It equals 989.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Easy one: 74,175 / 75 equals" }, { "role": "assistant", "content": "```python\nprint(74175 // 75) # 989\n```\nResult:\n989\n\nIt equals 989." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 74175, "b": 75, "notation": "/", "commas": true, "carries": null, "shown": "74,175 / 75", "gold": "989", "printed": "989"}
nlprog_det-arith-0000023	Deduct 3,696 from 10,000. Python version: ```python print(10000 - 3696) # 6304 ``` (Result: 6304) Which gives 6,304.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	66	{"a": 10000, "b": 3696, "notation": "minus", "commas": true, "carries": 4, "shown": "10,000 minus 3,696", "gold": "6304", "printed": "6304"}
nlprog_det-arith-0000025	<\|start\|><\|system\|> You have access to these functions: {"name": "compute", "description": "Use for arithmetic and date math; returns stdout of the code.", "parameters": {"type": "object", "properties": {"source": {"type": "string", "description": "Python source code"}}, "required": ["source"]}} {"name": "convert_units...	chat	[ { "role": "system", "content": "You have access to these functions:\n{\"name\": \"compute\", \"description\": \"Use for arithmetic and date math; returns stdout of the code.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"source\": {\"type\": \"string\", \"description\": \"Python source code\"}...	nlprog_det	arith	original	null	deterministic	[]	[]	282	{"a": 312, "b": 68, "notation": "difference", "commas": false, "carries": 2, "shown": "the difference between 312 and 68", "gold": "244", "printed": "244"}
nlprog_det-arith-0000027	Can you work out 148280 divided by 220? Show the computation. Computation in Python: ```python print(148280 // 220) # 674 ``` Printed — 674 That leaves 674.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	70	{"a": 148280, "b": 220, "notation": "divided by", "commas": false, "carries": null, "shown": "148280 divided by 220", "gold": "674", "printed": "674"}
nlprog_det-arith-0000028	Can you work out the product of 27 and 65? ```python print(27 * 65) # 1755 ``` Out: 1755 So we have 1755.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	49	{"a": 27, "b": 65, "notation": "product", "commas": false, "carries": null, "shown": "the product of 27 and 65", "gold": "1755", "printed": "1755"}
nlprog_det-arith-0000029	<\|start\|><\|system\|> Functions: {"name": "python", "description": "Python sandbox for calculations. Returns printed text.", "parameters": {"type": "object", "properties": {"snippet": {"type": "string", "description": "Python source code"}}, "required": ["snippet"]}} {"name": "define_word", "description": "Return a dicti...	chat	[ { "role": "system", "content": "Functions:\n{\"name\": \"python\", \"description\": \"Python sandbox for calculations. Returns printed text.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"snippet\": {\"type\": \"string\", \"description\": \"Python source code\"}}, \"required\": [\"snippet\"]}}...	nlprog_det	arith	original	null	deterministic	[]	[]	211	{"a": 3121, "b": 847, "notation": "-", "commas": false, "carries": 3, "shown": "3121 - 847", "gold": "2274", "printed": "2274"}
nlprog_det-arith-0000030	How much is 34 * 1,912? Step by step: 34 × 1910 = 64940 34 × 2 = 68 64940 + 68 = 65008 Reply: 65,008	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	57	{"a": 34, "b": 1912, "notation": "", "commas": true, "carries": null, "shown": "34 1,912", "gold": "65008", "printed": "65008"}
nlprog_det-arith-0000031	Quick check: Quick: 50375 divided by 65? 775	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	18	{"a": 50375, "b": 65, "notation": "divided by", "commas": false, "carries": null, "shown": "50375 divided by 65", "gold": "775", "printed": "775"}
nlprog_det-arith-0000032	Simple arithmetic: Find 3155 + 531. 3155 + 531 = 3686	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	27	{"a": 3155, "b": 531, "notation": "+", "commas": false, "carries": 0, "shown": "3155 + 531", "gold": "3686", "printed": "3686"}
nlprog_det-arith-0000033	Arithmetic: Please find 241 minus 68. As a program: ```python print(241 - 68) # 173 ``` The run gives: 173 The figure is 173.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	56	{"a": 241, "b": 68, "notation": "minus", "commas": false, "carries": 2, "shown": "241 minus 68", "gold": "173", "printed": "173"}
nlprog_det-arith-0000034	Problem: Calculate 5,711 + 8,493. No rounding needed. Python expression: 5711 + 8493 Its value: 14204 14,204	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	49	{"a": 5711, "b": 8493, "notation": "+", "commas": true, "carries": 3, "shown": "5,711 + 8,493", "gold": "14204", "printed": "14204"}
nlprog_det-arith-0000035	Find 13 multiplied by 17. Coded up: ```python print(13 * 17) ``` Python prints: 221 Worked answer: 221	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	53	{"a": 13, "b": 17, "notation": "product", "commas": false, "carries": null, "shown": "the product of 13 and 17", "gold": "221", "printed": "221"}
nlprog_det-arith-0000036	Remove 531 from 736; what is left? 736 − 500 = 236 236 − 31 = 205 Expected answer: 205	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	40	{"a": 736, "b": 531, "notation": "subtract", "commas": false, "carries": 0, "shown": "531 subtracted from 736", "gold": "205", "printed": "205"}
nlprog_det-arith-0000037	<\|start\|><\|user\|> Calculation: Give me 300 less 11.<\|eot\|> <\|assistant\|> print(300 - 11) (stdout: 289) 289 it is.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Calculation: Give me 300 less 11." }, { "role": "assistant", "content": " print(300 - 11)\n(stdout: 289)\n\n289 it is." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	42	{"a": 300, "b": 11, "notation": "less", "commas": true, "carries": 2, "shown": "300 less 11", "gold": "289", "printed": "289"}
nlprog_det-arith-0000039	Exercise: I need 60 times 34. Expression 60 * 34, value 2040. This yields 2040.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	29	{"a": 60, "b": 34, "notation": "times", "commas": false, "carries": null, "shown": "60 times 34", "gold": "2040", "printed": "2040"}
nlprog_det-arith-0000040	<\|start\|><\|system\|> You can call tools. Available tools: [{"name": "business_days", "description": "Count business days between two dates.", "parameters": {"type": "object", "properties": {"start": {"type": "string"}, "end": {"type": "string"}}, "required": ["start", "end"]}}, {"name": "python_exec", "description": "Us...	chat	[ { "role": "system", "content": "You can call tools. Available tools:\n[{\"name\": \"business_days\", \"description\": \"Count business days between two dates.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"start\": {\"type\": \"string\"}, \"end\": {\"type\": \"string\"}}, \"required\": [\"star...	nlprog_det	arith	original	null	deterministic	[]	[]	329	{"a": 270, "b": 699, "notation": "plus", "commas": false, "carries": 1, "shown": "270 plus 699", "gold": "969", "printed": "969"}
nlprog_det-arith-0000041	<\|start\|><\|user\|> What does 35 * 930 come to? Exact answer, please.<\|eot\|> <\|assistant\|> ```python print(35 * 930) # 32550 ``` It outputs 32550. Hence: 32550<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "What does 35 * 930 come to? Exact answer, please." }, { "role": "assistant", "content": "```python\nprint(35 * 930) # 32550\n```\nIt outputs 32550.\n\nHence:\n32550" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	67	{"a": 35, "b": 930, "notation": "", "commas": false, "carries": null, "shown": "35 930", "gold": "32550", "printed": "32550"}
nlprog_det-arith-0000042	Exercise: What does 15 * 6283 come to? In Python, 15 * 6283 evaluates to 94245. Gives: 94245	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	41	{"a": 15, "b": 6283, "notation": "", "commas": false, "carries": null, "shown": "15 6283", "gold": "94245", "printed": "94245"}
nlprog_det-arith-0000043	Simple arithmetic: The product of 55 and 7 is how much? Set it up in Python: ```python print(55 * 7) # 385 ``` Console: 385 That gives 385.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	65	{"a": 55, "b": 7, "notation": "product", "commas": true, "carries": null, "shown": "the product of 55 and 7", "gold": "385", "printed": "385"}
nlprog_det-arith-0000044	Number work: Calculate 29 x 2. Python: 29 * 2 Result: 58 So the result is 58.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	33	{"a": 29, "b": 2, "notation": "x", "commas": true, "carries": null, "shown": "29 x 2", "gold": "58", "printed": "58"}
nlprog_det-arith-0000045	<\|start\|><\|user\|> Exercise: 4,567 x 23 equals<\|eot\|> <\|assistant\|> ```python print(4567 * 23) # 105041 ``` It prints 105041, as expected. 105,041<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Exercise: 4,567 x 23 equals" }, { "role": "assistant", "content": "```python\nprint(4567 * 23) # 105041\n```\nIt prints 105041, as expected.\n\n105,041" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	61	{"a": 4567, "b": 23, "notation": "x", "commas": true, "carries": null, "shown": "4,567 x 23", "gold": "105041", "printed": "105041"}
nlprog_det-arith-0000046	Number work: Give me the sum of 14,248 and 44,000. 58,248	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	24	{"a": 14248, "b": 44000, "notation": "sum", "commas": true, "carries": 0, "shown": "the sum of 14,248 and 44,000", "gold": "58248", "printed": "58248"}
nlprog_det-arith-0000047	<\|start\|><\|system\|> You can call tools. Available tools: [{"name": "calculator", "description": "Evaluates Python and returns the printed output.", "parameters": {"type": "object", "properties": {"script": {"type": "string", "description": "Python source code"}}, "required": ["script"]}}]<\|eot\|> <\|user\|> Find 4 x 1,212...	chat	[ { "role": "system", "content": "You can call tools. Available tools:\n[{\"name\": \"calculator\", \"description\": \"Evaluates Python and returns the printed output.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"script\": {\"type\": \"string\", \"description\": \"Python source code\"}}, \"req...	nlprog_det	arith	original	null	deterministic	[]	[]	177	{"a": 4, "b": 1212, "notation": "x", "commas": true, "carries": null, "shown": "4 x 1,212", "gold": "4848", "printed": "4848"}
nlprog_det-arith-0000048	Evaluate 799 · 488. print(799 * 488) # 389912 Shell output — 389912 That leaves 389912.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	43	{"a": 799, "b": 488, "notation": "·", "commas": false, "carries": null, "shown": "799 · 488", "gold": "389912", "printed": "389912"}
nlprog_det-arith-0000049	Ledger line: 139 + 735 is Working: 139 + 700 = 839 839 + 35 = 874 Answer 874.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	42	{"a": 139, "b": 735, "notation": "+", "commas": true, "carries": 1, "shown": "139 + 735", "gold": "874", "printed": "874"}
nlprog_det-arith-0000051	<\|start\|><\|system\|> Write short, precise answers.<\|eot\|> <\|user\|> Easy one: Tell me 620208 / 876.<\|eot\|> <\|assistant\|> print(620208 // 876) # 708 The printout reads 708. In the end: 708.<\|eot\|> <\|end\|>	chat	[ { "role": "system", "content": "Write short, precise answers." }, { "role": "user", "content": "Easy one: Tell me 620208 / 876." }, { "role": "assistant", "content": " print(620208 // 876) # 708\nThe printout reads 708.\n\nIn the end: 708." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	70	{"a": 620208, "b": 876, "notation": "/", "commas": false, "carries": null, "shown": "620208 / 876", "gold": "708", "printed": "708"}
nlprog_det-arith-0000052	Multiply 252 by 866. In code: 252 * 866 It evaluates to 218232. Final: 218232.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	40	{"a": 252, "b": 866, "notation": "product", "commas": false, "carries": null, "shown": "the product of 252 and 866", "gold": "218232", "printed": "218232"}
nlprog_det-arith-0000053	<\|start\|><\|user\|> Try this: Figure out 392,535 divided by 671.<\|eot\|> <\|assistant\|> So we have 585.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Try this: Figure out 392,535 divided by 671." }, { "role": "assistant", "content": "So we have 585." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	33	{"a": 392535, "b": 671, "notation": "divided by", "commas": true, "carries": null, "shown": "392,535 divided by 671", "gold": "585", "printed": "585"}
nlprog_det-arith-0000054	Combine 3862 and 132. ```python print(3862 + 132) # 3994 ``` Execution prints: 3994 Number: 3994	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	53	{"a": 3862, "b": 132, "notation": "plus", "commas": false, "carries": 0, "shown": "3862 plus 132", "gold": "3994", "printed": "3994"}
nlprog_det-arith-0000055	Find the value of 1050 / 42. 1050 / 42 = 25	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	18	{"a": 1050, "b": 42, "notation": "/", "commas": false, "carries": null, "shown": "1050 / 42", "gold": "25", "printed": "25"}
nlprog_det-arith-0000056	Give the value of 47840 / 52. No rounding needed. One way, in code: print(47840 // 52) # 920 Console: 920 AMOUNT: 920	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	58	{"a": 47840, "b": 52, "notation": "/", "commas": false, "carries": null, "shown": "47840 / 52", "gold": "920", "printed": "920"}
nlprog_det-arith-0000057	Find the value of 144 - 40. In Python, 144 - 40 evaluates to 104. 104	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	28	{"a": 144, "b": 40, "notation": "-", "commas": false, "carries": 0, "shown": "144 - 40", "gold": "104", "printed": "104"}
nlprog_det-arith-0000059	<\|start\|><\|user\|> Sum check: I need 1613 subtracted from 2000.<\|eot\|> <\|assistant\|> ```python print(2000 - 1613) # 387 ``` Run result: 387 Final: 387.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Sum check: I need 1613 subtracted from 2000." }, { "role": "assistant", "content": "```python\nprint(2000 - 1613) # 387\n```\nRun result: 387\n\nFinal: 387." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 2000, "b": 1613, "notation": "subtract", "commas": false, "carries": 3, "shown": "1613 subtracted from 2000", "gold": "387", "printed": "387"}
nlprog_det-arith-0000060	Question of the day: Find the value of 8 x 19. Expression: 8 * 19 Value: 152 So: 152	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	37	{"a": 8, "b": 19, "notation": "x", "commas": false, "carries": null, "shown": "8 x 19", "gold": "152", "printed": "152"}
nlprog_det-arith-0000061	<\|start\|><\|user\|> Work out 3 x 91.<\|eot\|> <\|assistant\|> ```python print(3 * 91) # 273 ``` Output of the run: 273 The number we want is 273.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Work out 3 x 91." }, { "role": "assistant", "content": "```python\nprint(3 * 91) # 273\n```\nOutput of the run: 273\n\nThe number we want is 273." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	56	{"a": 3, "b": 91, "notation": "x", "commas": false, "carries": null, "shown": "3 x 91", "gold": "273", "printed": "273"}
nlprog_det-arith-0000063	Compute 300 − 192. 300 − 192 = 108	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	17	{"a": 300, "b": 192, "notation": "−", "commas": true, "carries": 2, "shown": "300 − 192", "gold": "108", "printed": "108"}
nlprog_det-arith-0000064	<\|start\|><\|user\|> Figure out 400 − 193.<\|eot\|> <\|assistant\|> ```python print(400 - 193) ``` The script prints: 207 207<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Figure out 400 − 193." }, { "role": "assistant", "content": "```python\nprint(400 - 193)\n```\nThe script prints: 207\n\n207" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	48	{"a": 400, "b": 193, "notation": "−", "commas": false, "carries": 2, "shown": "400 − 193", "gold": "207", "printed": "207"}
nlprog_det-arith-0000065	Basic math: How much is 594315 ÷ 705? 843	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	21	{"a": 594315, "b": 705, "notation": "÷", "commas": false, "carries": null, "shown": "594315 ÷ 705", "gold": "843", "printed": "843"}
nlprog_det-arith-0000066	Exam warm-up: 3,712 x 3 is 11,136	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	19	{"a": 3712, "b": 3, "notation": "x", "commas": true, "carries": null, "shown": "3,712 x 3", "gold": "11136", "printed": "11136"}
nlprog_det-arith-0000067	What do you get for 37346 divided by 71? Python: ```python print(37346 // 71) # 526 ``` The program prints: 526 That leaves 526.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	62	{"a": 37346, "b": 71, "notation": "divided by", "commas": false, "carries": null, "shown": "37346 divided by 71", "gold": "526", "printed": "526"}
nlprog_det-arith-0000068	What is 53732 divided by 707? Double-check it. Evaluate in Python: 53732 // 707 Gives 76. 76	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	46	{"a": 53732, "b": 707, "notation": "divided by", "commas": false, "carries": null, "shown": "53732 divided by 707", "gold": "76", "printed": "76"}
nlprog_det-arith-0000069	Find 2 x 99. Use Python if it helps. Python version: ```python print(2 * 99) # 198 ``` The script prints 198, as expected. The number we want is 198.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	63	{"a": 2, "b": 99, "notation": "x", "commas": true, "carries": null, "shown": "2 x 99", "gold": "198", "printed": "198"}
nlprog_det-arith-0000070	Add 3423 and 3005. All told, 6428.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	17	{"a": 3423, "b": 3005, "notation": "sum", "commas": false, "carries": 0, "shown": "the sum of 3423 and 3005", "gold": "6428", "printed": "6428"}
nlprog_det-arith-0000071	Practice: Determine 3 times 4,951. That gives 14,853.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	24	{"a": 3, "b": 4951, "notation": "times", "commas": true, "carries": null, "shown": "3 times 4,951", "gold": "14853", "printed": "14853"}
nlprog_det-arith-0000073	<\|start\|><\|system\|> Tools you may use: [{"name": "math_engine", "description": "Use for arithmetic and date math; returns stdout of the code.", "parameters": {"type": "object", "properties": {"program": {"type": "string", "description": "Python source code"}}, "required": ["program"]}}, {"name": "get_weather", "descrip...	chat	[ { "role": "system", "content": "Tools you may use:\n[{\"name\": \"math_engine\", \"description\": \"Use for arithmetic and date math; returns stdout of the code.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"program\": {\"type\": \"string\", \"description\": \"Python source code\"}}, \"requir...	nlprog_det	arith	original	null	deterministic	[]	[]	239	{"a": 25326, "b": 67, "notation": "÷", "commas": false, "carries": null, "shown": "25326 ÷ 67", "gold": "378", "printed": "378"}
nlprog_det-arith-0000074	Calculate 3598 · 5. No rounding needed. Python expression: 3598 * 5 Its value: 17990 That is 17990.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	42	{"a": 3598, "b": 5, "notation": "·", "commas": false, "carries": null, "shown": "3598 · 5", "gold": "17990", "printed": "17990"}
nlprog_det-arith-0000076	<\|start\|><\|system\|> Functions: {"name": "interpreter", "description": "Python sandbox for calculations. Returns printed text.", "parameters": {"type": "object", "properties": {"snippet": {"type": "string", "description": "Python source code"}}, "required": ["snippet"]}}<\|eot\|> <\|user\|> Compute 5 · 4.<\|eot\|> <\|assistant...	chat	[ { "role": "system", "content": "Functions:\n{\"name\": \"interpreter\", \"description\": \"Python sandbox for calculations. Returns printed text.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"snippet\": {\"type\": \"string\", \"description\": \"Python source code\"}}, \"required\": [\"snippet...	nlprog_det	arith	original	null	deterministic	[]	[]	129	{"a": 5, "b": 4, "notation": "·", "commas": true, "carries": null, "shown": "5 · 4", "gold": "20", "printed": "20"}
nlprog_det-arith-0000077	Subtract 4722 from 6292. We write it as a program: ```python print(6292 - 4722) ``` (Printed result: 1570) 1570	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	53	{"a": 6292, "b": 4722, "notation": "less", "commas": false, "carries": 1, "shown": "6292 less 4722", "gold": "1570", "printed": "1570"}
nlprog_det-arith-0000078	Quick check: Find the quotient of 13,543 and 29. As a Python expression: 13543 // 29 Evaluated: 467 467 exactly.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	48	{"a": 13543, "b": 29, "notation": "quotient", "commas": true, "carries": null, "shown": "the quotient of 13,543 and 29", "gold": "467", "printed": "467"}
nlprog_det-arith-0000080	Split 56643 into 79 equal parts; how big is each? Step by step: 56643 ÷ 79 = 717 check: 79 × 717 = 56643 717	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	54	{"a": 56643, "b": 79, "notation": "divided by", "commas": false, "carries": null, "shown": "56643 divided by 79", "gold": "717", "printed": "717"}
nlprog_det-arith-0000081	Quiz: How much is 1000 − 286? In parts: 1000 − 200 = 800 800 − 86 = 714 Answer = 714	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	44	{"a": 1000, "b": 286, "notation": "−", "commas": false, "carries": 3, "shown": "1000 − 286", "gold": "714", "printed": "714"}
nlprog_det-arith-0000082	Exam warm-up: Find the value of 2 · 69. Translated to Python: ```python print(2 * 69) # 138 ``` Executing it gives 138, as expected. 138	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	65	{"a": 2, "b": 69, "notation": "·", "commas": false, "carries": null, "shown": "2 · 69", "gold": "138", "printed": "138"}
nlprog_det-arith-0000083	Bookkeeping check: What do you get for 60 - 30? Exact answer, please. Set it up in Python: print(60 - 30) # 30 It outputs: 30 30	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	52	{"a": 60, "b": 30, "notation": "-", "commas": true, "carries": 0, "shown": "60 - 30", "gold": "30", "printed": "30"}
nlprog_det-arith-0000084	<\|start\|><\|user\|> Find 9 x 7.<\|eot\|> <\|assistant\|> 9 x 7 = 63<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Find 9 x 7." }, { "role": "assistant", "content": "9 x 7 = 63" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	21	{"a": 9, "b": 7, "notation": "x", "commas": true, "carries": null, "shown": "9 x 7", "gold": "63", "printed": "63"}
nlprog_det-arith-0000085	How much is 2,979 added to 6,080? Python, step by step: ```python print(6080 + 2979) # 9059 ``` Result: 9059 It equals 9,059.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	66	{"a": 6080, "b": 2979, "notation": "added", "commas": true, "carries": 2, "shown": "2,979 added to 6,080", "gold": "9059", "printed": "9059"}
nlprog_det-arith-0000086	What do you get for 56544 / 76? In Python, 56544 // 76 evaluates to 744. 744 is correct.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	41	{"a": 56544, "b": 76, "notation": "/", "commas": false, "carries": null, "shown": "56544 / 76", "gold": "744", "printed": "744"}
nlprog_det-arith-0000087	Can you work out the sum of 912 and 124? Python, step by step: ```python print(912 + 124) # 1036 ``` Console: 1036 That works out as 1036.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	64	{"a": 912, "b": 124, "notation": "sum", "commas": false, "carries": 1, "shown": "the sum of 912 and 124", "gold": "1036", "printed": "1036"}
nlprog_det-arith-0000088	Add 35 to 88. A short script: ```python print(88 + 35) # 123 ``` Run it and it prints: 123 It works out to 123.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	51	{"a": 88, "b": 35, "notation": "plus", "commas": true, "carries": 2, "shown": "88 plus 35", "gold": "123", "printed": "123"}
nlprog_det-arith-0000089	Number work: What do you get for the sum of 294 and 188? 482	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	21	{"a": 294, "b": 188, "notation": "sum", "commas": false, "carries": 2, "shown": "the sum of 294 and 188", "gold": "482", "printed": "482"}
nlprog_det-arith-0000090	<\|start\|><\|user\|> 32852 / 43 =<\|eot\|> <\|assistant\|> 32852 / 43 = 764<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "32852 / 43 =" }, { "role": "assistant", "content": "32852 / 43 = 764" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	26	{"a": 32852, "b": 43, "notation": "/", "commas": false, "carries": null, "shown": "32852 / 43", "gold": "764", "printed": "764"}
nlprog_det-arith-0000091	Tell me 3 · 18. Break it up: 10 × 3 = 30 8 × 3 = 24 30 + 24 = 54 It must be 54.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	43	{"a": 3, "b": 18, "notation": "·", "commas": false, "carries": null, "shown": "3 · 18", "gold": "54", "printed": "54"}
nlprog_det-arith-0000092	<\|start\|><\|user\|> Add 50 to 96.<\|eot\|> <\|assistant\|> 146<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Add 50 to 96." }, { "role": "assistant", "content": "146" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	18	{"a": 96, "b": 50, "notation": "plus", "commas": true, "carries": 1, "shown": "96 plus 50", "gold": "146", "printed": "146"}
nlprog_det-arith-0000093	Add 13030 to 86200. In Python, 86200 + 13030 evaluates to 99230. Number: 99230	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	39	{"a": 86200, "b": 13030, "notation": "sum", "commas": false, "carries": 0, "shown": "the sum of 86200 and 13030", "gold": "99230", "printed": "99230"}
nlprog_det-arith-0000097	10000 − 4425 = what? 10000 − 4425 = 5575	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	22	{"a": 10000, "b": 4425, "notation": "−", "commas": false, "carries": 4, "shown": "10000 − 4425", "gold": "5575", "printed": "5575"}
nlprog_det-arith-0000099	Give me 6607 minus 3768. Set it up in Python: ```python print(6607 - 3768) # 2839 ``` The printout reads: 2839 Which gives 2839.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	66	{"a": 6607, "b": 3768, "notation": "minus", "commas": false, "carries": 3, "shown": "6607 minus 3768", "gold": "2839", "printed": "2839"}
nlprog_det-arith-0000100	How much is the product of 886 and 656? The Python version: ```python print(886 * 656) # 581216 ``` Output of the run: 581216 581216	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	61	{"a": 886, "b": 656, "notation": "product", "commas": false, "carries": null, "shown": "the product of 886 and 656", "gold": "581216", "printed": "581216"}
nlprog_det-arith-0000101	<\|start\|><\|system\|> You can call tools. Available tools: {"name": "calculator", "description": "Run Python code in a sandbox; the result is whatever the code prints.", "parameters": {"type": "object", "properties": {"program": {"type": "string", "description": "Python source code"}}, "required": ["program"]}}<\|eot\|> <\|...	chat	[ { "role": "system", "content": "You can call tools. Available tools:\n{\"name\": \"calculator\", \"description\": \"Run Python code in a sandbox; the result is whatever the code prints.\", \"parameters\": {\"type\": \"object\", \"properties\": {\"program\": {\"type\": \"string\", \"description\": \"Python s...	nlprog_det	arith	original	null	deterministic	[]	[]	173	{"a": 2448, "b": 16, "notation": "divided by", "commas": false, "carries": null, "shown": "2448 divided by 16", "gold": "153", "printed": "153"}
nlprog_det-arith-0000102	Ledger line: Work out 7 times 92. We write it as a program: ```python print(7 * 92) # 644 ``` The program prints 644, as expected. Outcome: 644	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	60	{"a": 7, "b": 92, "notation": "times", "commas": true, "carries": null, "shown": "7 times 92", "gold": "644", "printed": "644"}
nlprog_det-arith-0000104	<\|start\|><\|system\|> You are a logic tutor.<\|eot\|> <\|user\|> Quiz: The sum of 36 and 52 is how much? Integers only.<\|eot\|> <\|assistant\|> 88<\|eot\|> <\|end\|>	chat	[ { "role": "system", "content": "You are a logic tutor." }, { "role": "user", "content": "Quiz: The sum of 36 and 52 is how much? Integers only." }, { "role": "assistant", "content": "88" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	39	{"a": 36, "b": 52, "notation": "sum", "commas": false, "carries": 0, "shown": "the sum of 36 and 52", "gold": "88", "printed": "88"}
nlprog_det-arith-0000105	Solve: 6807 − 5949 As Python: print(6807 - 5949) Out — 858 So the answer is 858.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	46	{"a": 6807, "b": 5949, "notation": "−", "commas": false, "carries": 3, "shown": "6807 − 5949", "gold": "858", "printed": "858"}
nlprog_det-arith-0000106	Math check: Figure out 90 × 20. Here is the program. ```python print(90 * 20) # 1800 ``` Shell output: 1800 It's 1800.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	54	{"a": 90, "b": 20, "notation": "×", "commas": false, "carries": null, "shown": "90 × 20", "gold": "1800", "printed": "1800"}
nlprog_det-arith-0000107	Quick check: Determine 98 * 4. Written as code: print(98 * 4) # 392 Python prints: 392 392	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	45	{"a": 98, "b": 4, "notation": "", "commas": true, "carries": null, "shown": "98 4", "gold": "392", "printed": "392"}
nlprog_det-arith-0000108	<\|start\|><\|system\|> Show working only when it helps.<\|eot\|> <\|user\|> What is 8 x 1801?<\|eot\|> <\|assistant\|> ```python print(8 * 1801) # 14408 ``` Output: 14408 It equals 14408.<\|eot\|> <\|end\|>	chat	[ { "role": "system", "content": "Show working only when it helps." }, { "role": "user", "content": "What is 8 x 1801?" }, { "role": "assistant", "content": "```python\nprint(8 * 1801) # 14408\n```\nOutput:\n14408\n\nIt equals 14408." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	69	{"a": 8, "b": 1801, "notation": "x", "commas": false, "carries": null, "shown": "8 x 1801", "gold": "14408", "printed": "14408"}
nlprog_det-arith-0000109	Mental arithmetic: Can you work out 9 multiplied by 88? The number we want is 792.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	26	{"a": 9, "b": 88, "notation": "multiplied by", "commas": false, "carries": null, "shown": "9 multiplied by 88", "gold": "792", "printed": "792"}
nlprog_det-arith-0000110	Can you work out 16 added to 95? Comes to: 111	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	20	{"a": 95, "b": 16, "notation": "added", "commas": true, "carries": 2, "shown": "16 added to 95", "gold": "111", "printed": "111"}
nlprog_det-arith-0000111	<\|start\|><\|user\|> What does 62 x 4 come to?<\|eot\|> <\|assistant\|> ```python print(62 * 4) # 248 ``` Program output — 248 Thus 248.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "What does 62 x 4 come to?" }, { "role": "assistant", "content": "```python\nprint(62 * 4) # 248\n```\nProgram output — 248\n\nThus 248." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	53	{"a": 62, "b": 4, "notation": "x", "commas": true, "carries": null, "shown": "62 x 4", "gold": "248", "printed": "248"}
nlprog_det-arith-0000112	Find the value of 2000 - 1739. The Python version: ```python print(2000 - 1739) # 261 ``` Executing it gives: 261 The figure is 261.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	59	{"a": 2000, "b": 1739, "notation": "-", "commas": false, "carries": 3, "shown": "2000 - 1739", "gold": "261", "printed": "261"}
nlprog_det-arith-0000113	<\|start\|><\|user\|> Add 124 and 190.<\|eot\|> <\|assistant\|> ```python print(124 + 190) # 314 ``` When run, it prints: 314 Hence 314.<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "Add 124 and 190." }, { "role": "assistant", "content": "```python\nprint(124 + 190) # 314\n```\nWhen run, it prints: 314\n\nHence 314." } ]	nlprog_det	arith	original	null	deterministic	[]	[]	56	{"a": 124, "b": 190, "notation": "plus", "commas": true, "carries": 1, "shown": "124 plus 190", "gold": "314", "printed": "314"}
nlprog_det-arith-0000114	<\|start\|><\|user\|> 168 * 680 equals<\|eot\|> <\|assistant\|> 168 * 680 = 114240<\|eot\|> <\|end\|>	chat	[ { "role": "user", "content": "168 * 680 equals" }, { "role": "assistant", "content": "168 * 680 = 114240" } ]	nlprog_det	arith	original	null	deterministic	[]	[]	26	{"a": 168, "b": 680, "notation": "", "commas": false, "carries": null, "shown": "168 680", "gold": "114240", "printed": "114240"}
nlprog_det-arith-0000115	Practice set: Figure out 5000 − 4222. Python: 5000 - 4222 Result: 778 That gives 778.	plain	null	nlprog_det	arith	original	null	deterministic	[]	[]	43	{"a": 5000, "b": 4222, "notation": "−", "commas": false, "carries": 3, "shown": "5000 − 4222", "gold": "778", "printed": "778"}

End of preview. Expand in Data Studio

OpenLemma v0.4 programs

Part of OpenLemma v0.4: arithmetic, expression and everyday problems solved with executed Python (including tool-call documents), and small math and logic problems with machine-checked formal solutions (SMT-LIB, Lean 4, CAS). The problems and solutions are generated by deterministic code; every program was run and every formal artifact was checked.

488,303 documents, 35,722,291 tokens (alea-p1sw-staged-16k, the ALEA tokenizer, counting the document start and end tokens).

Configs

config	variant	documents	tokens	generator
`nl_to_python`	original	429,226	28,451,837	deterministic (429,226)
`nl_to_python_paraphrased`	paraphrased	29,365	2,257,543	GLM-5.3-Flash (21,613), DeepSeek-V4.1-Flash (7,752)
`formal_solutions`	original	29,712	5,012,911	deterministic (29,712)

Task families

nl_to_python: Arithmetic and word problems solved with executed Python. Arithmetic in 22 notations (including a x b, ÷, ·, words), expressions and templated everyday problems, answered directly, with a short program, with program-of-thought, or with a tool call (<|tool_call|> / <|tool_result|>). Every program was executed and its printed output equals the stated answer.
formal_solutions: Small problems with checked formal solutions. Linear systems, ordering puzzles, 8-bit arithmetic, propositional entailment, factoring and small rules-as-code eligibility checks, each with an SMT-LIB query, a Lean 4 (core) theorem, a CAS step list or a short Python check. Every SMT query was solved, every Lean theorem compiled and every program run.

Sources

Deterministic generators (no model wrote the problems, programs or solutions).
The formal checks use the Axeyum solver (SMT-LIB, CAS) and Lean 4 core; Python programs run in a sandbox.

Variants and model-generated text

nl_to_python has two configs; formal_solutions has only the original:

original: written entirely by deterministic generators. No language model wrote any of it.
_paraphrased: the same documents with their instruction, question and answer sentences paraphrased by GLM-5.3-Flash or DeepSeek-V4.1-Flash (the split per config is in the table above), open-weight models served by zero-data-retention providers. The model only ever saw masked template prose: every passage, name, number, date, quotation, code or data block, label and short answer was replaced by a placeholder before the request and restored afterwards. The generator column names the model of each row.

In the paraphrased config every passage, number, date, name, quotation, data block, label and short answer is checked to be byte-identical to the original document (variant_of names it), and a variant fails if its meaning class changes (negation, yes/no, pointers, names, numbers). For structured answers (JSON, YAML, CSV, tables) the variant's data block must equal the original's exactly. Rows with visible paraphrase artefacts (repeated words, garbled frames) were removed.

Verification and filters

Family checkers (fail closed): each family re-derives its gold answer from the source (the knowledge base, the passage, the parsed record, the executed program or the solver, as applicable) and rejects any document that does not match.
Decontamination (fail closed): documents sharing word 8-grams or 13-grams with ALEA's evaluation sets, the held-out probe items, or copyright-memorization probe texts were removed.
Toxicity: s-nlp/roberta_toxicity_classifier on every document (64-word chunks); any chunk scoring 0.8 or more removes the document.
Private contact details: documents with an e-mail address, phone number or street address that is not an agency, court, company or placeholder contact were removed. Names in the public record are kept.
Format: no instruction or label follows a passage at the end of a document; frequent opening and closing phrases are capped at about 1% of a family's documents.
Pre-release screen of every row: 0 decontamination hits, 0 private contact details, 0 hashed slur/vulgar lexicon matches.
ALEA's held-out evaluation splits are not part of this release.

Columns

column	content
`id`	row id
`text`	the document as used for training; chat documents use ALEA's chat template, whose control tokens appear as text (`<
`format`	`chat` or `plain`
`messages`	chat documents: the role/content turns; null for plain documents
`family`, `sub`	task family and source / sub-type
`variant`, `variant_of`	`original` or `paraphrase`, and the id of the original document
`generator`	what wrote the row (see above)
`sources`, `source_ids`	empty in this release (every problem is generated)
`n_tokens_alea`	tokens under the ALEA tokenizer
`meta`	JSON: the generator's structured fields (gold values, operations, roles)

release_manifest.json lists every file with its sha256, size, rows and tokens.

Known limitations

The problems are template-generated: the arithmetic and everyday problems use fixed settings and number ranges, and the formal problems are small (a few variables).
Programs use plain arithmetic and datetime only; tool-call documents use a small set of invented tool names and JSON schemas.

Licence

Released under CC-BY-4.0.

Code will be released with the ALEA model.

Downloads last month: 16