Dataset Viewer
Auto-converted to Parquet Duplicate
task_id
stringlengths
23
52
subset
stringclasses
1 value
family
stringclasses
80 values
problem_key
stringclasses
75 values
domain
stringclasses
8 values
tier
stringclasses
2 values
level
stringclasses
6 values
source
stringclasses
80 values
license
stringclasses
3 values
tags
listlengths
0
4
prompt
stringlengths
308
37k
instance
stringlengths
56
37.8k
direction
null
baseline
null
best_known
null
reference_answer
stringlengths
8
198k
reference_reward
float64
1
1
construct-ae-p32-spherical-design-l1-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
1
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 7, "N": 32, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[0.11606245518956762, -0.16610236292160294, 0.9792545693164928], [-0.39675347898353364, 0.021959702877615433, 0.9176624915316032], [0.48607965266991554, 0.3267742455138338, 0.8105215381031888], [-0.5028561752354322, -0.5750524338141748, 0.6453296563710569], [-0.028977008371302036, 0.6135860519291835, 0.7890...
1
construct-ae-p32-spherical-design-l2-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
2
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 9, "N": 50, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[0.16922693235862724, -0.20103306308114954, 0.9648564416081281], [-0.1444229652425299, 0.2171017544618927, 0.9654060468632476], [0.43300572300753354, 0.1842363624211028, 0.8823621742825126], [-0.19147178208270688, -0.49237023697924936, 0.8490642534008073], [-0.22349668833015543, 0.654913436090283, 0.7218986...
1
construct-ae-p32-spherical-design-l3-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
3
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 11, "N": 74, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[0.012181667145405233, 0.04406897535978663, 0.9989542193695851], [-0.34509997965572176, 0.1288545422759548, 0.9296787138449899], [0.23747361043298654, 0.3418894723530763, 0.9092402724484091], [-0.32378205632304635, -0.3291285139317033, 0.8870397969202556], [-0.10993350849569812, 0.5729830527072197, 0.812160...
1
construct-ae-p32-spherical-design-l4-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
4
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 15, "N": 120, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[-0.6797362419565781, -0.33277023955514695, 0.6536226809384437], [0.9801860827417008, 0.15541248185198572, -0.12280962374376724], [-0.3823571350063186, 0.8762371708640566, -0.2932770732701655], [0.3500260050652461, 0.4693794053767845, -0.810656998727699], [-0.9252524215421856, 0.31148183475383806, -0.216534...
1
construct-ae-p32-spherical-design-l5-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
5
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 19, "N": 198, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[0.2527759326534977, -0.9566791840084274, -0.14446199069694396], [-0.9071773294756267, 0.015962244615743904, 0.4204455965190948], [-0.616471714044581, -0.20797033654468083, -0.7594148832492214], [-0.6669229800600651, 0.5278085911769907, 0.5259580113921283], [-0.6636953921393339, 0.3035315017983519, 0.683649...
1
construct-ae-p32-spherical-design-l6-s0
construct
ae_p32_spherical_designs
spherical_t_design_s2
discrete_geometry
research
6
AlphaEvolve-Repository-of-Problems/32-spherical-designs
CC-BY-4.0
[ "float_tolerance", "numerical_design" ]
Spherical designs on the 2-sphere. A finite set X of points on the unit sphere S^2 in R^3 is a spherical t-design if for every polynomial P(x, y, z) of degree at most t, the average of P over the points of X equals the average of P over the whole sphere (with respect to the uniform surface measure). Equivalently, the...
{"t": 21, "N": 234, "family": "ae_p32_spherical_designs", "subset": "construct"}
null
null
null
{"points": [[-0.9596810424419001, -0.28105208802161075, 0.0046926108213612315], [-0.7595309788778035, 0.28634046819989534, -0.5840563572087804], [-0.813730818738408, -0.3764390859035123, 0.4428721816048601], [-0.9347893044111631, 0.08032069257362744, 0.34600222933239383], [-0.2683002097771996, 0.8777526186055353, -0.39...
1
construct-ae-p38-factorial-factors-l1-s0
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 36. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 10. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 36, "t": 10, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [60, 10, 10, 10, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 14, 14, 14, 14, 14, 15, 15, 15, 15, 17, 17, 19, 23, 29, 31]}
1
construct-ae-p38-factorial-factors-l1-s1
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 37. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 10. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 37, "t": 10, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [60, 10, 10, 10, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 14, 14, 14, 14, 14, 15, 15, 15, 15, 17, 17, 19, 23, 29, 31, 37]}
1
construct-ae-p38-factorial-factors-l1-s2
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 44. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 12. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 44, "t": 12, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [96, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 17, 17, 19, 19, 22, 22, 22, 22, 23, 29, 31, 37, 41, 43]}
1
construct-ae-p38-factorial-factors-l1-s3
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 45. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 12. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 45, "t": 12, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [24, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 17, 17, 19, 19, 22, 22, 22, 22, 23, 29, 31, 37, 41, 516]}
1
construct-ae-p38-factorial-factors-l1-s4
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 48. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 13. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 48, "t": 13, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [52, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 17, 17, 18, 18, 18, 18, 18, 18, 19, 19, 22, 22, 22, 22, 23, 23, 29, 31, 37, 41, 43, 47]}
1
construct-ae-p38-factorial-factors-l1-s5
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 52. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 15. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 52, "t": 15, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [45, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 18, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 26, 26, 26, 26, 29, 31, 37, 41, 43, 47]}
1
construct-ae-p38-factorial-factors-l1-s6
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 54. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 15. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 54, "t": 15, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [120, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 26, 26, 26, 26, 29, 31, 37, 41, 43, 47, 53]}
1
construct-ae-p38-factorial-factors-l1-s7
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 55. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 15. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 55, "t": 15, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 18, 18, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 26, 26, 26, 26, 29, 31, 33, 37, 41, 43, 47, 795]}
1
construct-ae-p38-factorial-factors-l1-s8
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 56. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 15. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 56, "t": 15, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [60, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 18, 18, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 23, 23, 26, 26, 26, 26, 29, 31, 37, 41, 43, 47, 795]}
1
construct-ae-p38-factorial-factors-l1-s9
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
1
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 59. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 17. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 59, "t": 17, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 23, 23, 24, 24, 24, 24, 26, 26, 26, 26, 29, 29, 31, 37, 41, 43, 47, 53, 59]}
1
construct-ae-p38-factorial-factors-l2-s0
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 86. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 24. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 86, "t": 24, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [288, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 31, 31, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 37, 37, 38, 38, 38, 38, 41, 41, 43, 43, 46, 46, 46...
1
construct-ae-p38-factorial-factors-l2-s1
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 88. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 25. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 88, "t": 25, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [150, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 37, 37, 38, 38, 38, 38, 41, 41, 43, 43, 46...
1
construct-ae-p38-factorial-factors-l2-s2
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 97. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 28. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numbe...
{"N": 97, "t": 28, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [336, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 36, 36, 36, 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39...
1
construct-ae-p38-factorial-factors-l2-s3
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 106. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 30. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 106, "t": 30, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [360, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 36, 36, 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 41, 41, 42, 43, 43, 46...
1
construct-ae-p38-factorial-factors-l2-s4
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 110. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 31. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 110, "t": 31, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [186, 31, 31, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40...
1
construct-ae-p38-factorial-factors-l2-s5
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 119. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 35. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 119, "t": 35, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 43, 43, 44, 44, 44, 44, 44, 44, 44, 44,...
1
construct-ae-p38-factorial-factors-l2-s6
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 120. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 35. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 120, "t": 35, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [245, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 43, 43, 44, 44, 44, 44, 44, 44...
1
construct-ae-p38-factorial-factors-l2-s7
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 134. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 39. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 134, "t": 39, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [585, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45...
1
construct-ae-p38-factorial-factors-l2-s8
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 139. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 40. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 139, "t": 40, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 43, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 47, 47, 48, 49, 49, 49, 49, 49,...
1
construct-ae-p38-factorial-factors-l2-s9
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
2
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 152. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 44. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 152, "t": 44, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [704, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 47, 47, 47, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 50, 50, 50, 50, 50, 50, 50...
1
construct-ae-p38-factorial-factors-l3-s0
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 180. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 54. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 180, "t": 54, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 57, 57, 57, 57, 57, 57, 57, 57, 58, 58,...
1
construct-ae-p38-factorial-factors-l3-s1
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 231. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 69. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 231, "t": 69, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 71, 71, 71, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, 73, 73, 74, 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 75, 75, 75, 76,...
1
construct-ae-p38-factorial-factors-l3-s2
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 252. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 75. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 252, "t": 75, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [750, 75, 75, 75, 75, 75, 75, 75, 75, 75, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 79, 79, 79, 80, 80, 80, 80, 80, 80, 80...
1
construct-ae-p38-factorial-factors-l3-s3
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 275. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 83. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 275, "t": 83, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [83, 83, 83, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 86, 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,...
1
construct-ae-p38-factorial-factors-l3-s4
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 284. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 85. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 284, "t": 85, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 86, 86, 86, 86, 86, 86, 87, 87, 87, 87, 87, 87, 87, 87, 87, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 88, 89, 89, 89, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,...
1
construct-ae-p38-factorial-factors-l3-s5
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 313. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 93. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your numb...
{"N": 313, "t": 93, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [930, 93, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 94, 94, 94, 94, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 97, 97, 97, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98...
1
construct-ae-p38-factorial-factors-l3-s6
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 339. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 103. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 339, "t": 103, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [103, 103, 103, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 105, 10...
1
construct-ae-p38-factorial-factors-l3-s7
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 357. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 108. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 357, "t": 108, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [972, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 109, 109, 109, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 110, 111, 111, 111, 111, 111, 111, 11...
1
construct-ae-p38-factorial-factors-l3-s8
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 384. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 117. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 384, "t": 117, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 118, 118, 118, 118, 118, 118, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 120, 12...
1
construct-ae-p38-factorial-factors-l3-s9
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
3
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 395. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 120. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 395, "t": 120, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 12...
1
construct-ae-p38-factorial-factors-l4-s0
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 568. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 174. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 568, "t": 174, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [348, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 176, 177, 177, 177, 177, 177, 177, 17...
1
construct-ae-p38-factorial-factors-l4-s1
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 577. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 178. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 577, "t": 178, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [178, 178, 178, 178, 178, 178, 179, 179, 179, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 18...
1
construct-ae-p38-factorial-factors-l4-s2
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 584. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 180. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 584, "t": 180, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [2880, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 180, 1...
1
construct-ae-p38-factorial-factors-l4-s3
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 736. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 228. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 736, "t": 228, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 229, 229, 229, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 230, 23...
1
construct-ae-p38-factorial-factors-l4-s4
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 751. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 232. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 751, "t": 232, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 233, 233, 233, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 23...
1
construct-ae-p38-factorial-factors-l4-s5
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 778. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 240. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 778, "t": 240, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [480, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 241, 241, 241, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 242, 24...
1
construct-ae-p38-factorial-factors-l4-s6
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 891. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 278. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your num...
{"N": 891, "t": 278, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [278, 278, 278, 278, 278, 278, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 28...
1
construct-ae-p38-factorial-factors-l4-s7
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 1031. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 322. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your nu...
{"N": 1031, "t": 322, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [2254, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 322, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 323, 3...
1
construct-ae-p38-factorial-factors-l4-s8
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 1117. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 350. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your nu...
{"N": 1117, "t": 350, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 350, 35...
1
construct-ae-p38-factorial-factors-l4-s9
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
4
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 1164. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 365. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your nu...
{"N": 1164, "t": 365, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, 367, 367, 367, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 368, 36...
1
construct-ae-p38-factorial-factors-l5-s0
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
5
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 1632. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 515. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your nu...
{"N": 1632, "t": 515, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 515, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 516, 517, 517, 517, 517, 517, 517, 517, 517, 517, 51...
1
construct-ae-p38-factorial-factors-l5-s1
construct
ae_p38_factorial_factors
factorial_into_n_large_factors_A034258
number_theory
research
5
AlphaEvolve-Repository-of-Problems/38-factoring-N-factorial
CC-BY-4.0
[ "agentic_trivial", "exact_integer", "ilp_friendly", "np_search" ]
Factoring N! into N large factors (Erdos-Guy-Selfridge). Let N = 1725. Write N! as a product of exactly N positive integers, N! = a_1 * a_2 * ... * a_N, such that every factor satisfies a_i >= 546. (The order of the factors does not matter; repeated values are allowed.) The check is exact: the product of your nu...
{"N": 1725, "t": 546, "family": "ae_p38_factorial_factors", "subset": "construct"}
null
null
null
{"factors": [546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 546, 54...
1
End of preview. Expand in Data Studio

MathConstructOptimize-Envs

3,793 RL tasks in 219 families where the model must construct a mathematical object, graded by a deterministic checker. There is no answer matching and no LLM judge in the reward path.

Most math RL data asks for a final number. Here the model has to produce the object itself: a colouring, a design, a counterexample, a point configuration, a polynomial. The checker accepts any valid object, not a stored answer. The collection has two subsets:

subset what the model does reward families tasks
construct produce any object satisfying stated conditions (a witness) 1 if valid, else 0 80 3,464
optimize produce a valid object with the best objective it can (extremal constructions, bound improvement) 0 if invalid; otherwise 0.1 + 0.9 × progress from a trivial baseline to the best known value 139 329

The runnable sandboxed version (one Harbor task directory per row) is in amphora/MathConstructOptimize-Envs-harbor.

Sources

Tasks are converted from existing generator suites and research-problem repositories. Each checker was re-implemented and hardened; see the list of upstream verifier bugs below.

source subset tier families tasks
RLVE-Gym construct competition 30 1,800
MathConstraint construct competition 33 875
NPPC construct competition 8 480
Reasoning Gym construct competition 3 180
AlphaEvolve repository of problems construct + optimize research (mostly) 34 203
EinsteinArena optimize research 26 28
FunSearch optimize research 3 15
Finch / Evolution Fine-Tuning (erdos_* tasks) optimize research / competition 12 12
Optimization Constants in Mathematics (Tao, Davis, Ivanisvili) optimize research 13 17
Leaps in Bounds (D. Munro) optimize research 14 82
FrontierShift open problems (AItonomy Foundation) optimize research 8 9
FrontierCO (minimum dominating set only) optimize competition 1 15
ALE-Bench (AtCoder Heuristic Contest) optimize competition 18 36
FrontierCS (algorithmic track) optimize competition 14 37
EdgeBench (released task dirs) optimize competition 2 4

Construct generators have 4–6 difficulty levels × 10 seeds. Optimize tasks are single research problems or contest instances, some at several sizes n. Sources added in v2 (2026-11-18) are described in the v2 section below. families.csv lists every family with its source, license, domain, problem_key and tags.

Row schema

column meaning
task_id unique id
subset, family, problem_key task contract, generator family, canonical math problem id (for cross-source dedupe)
domain, tier, level math area, competition or research, difficulty level
source, license upstream task and its license
tags see below
prompt full, self-contained task statement including the required JSON answer schema
instance JSON string with the instance data the checker needs
direction, baseline, best_known optimize only: objective direction, trivial-baseline score, best known score
reference_answer, reference_reward a known valid answer (planted witness or published construction) and its reward; for SFT/debugging, not needed for grading

Grading

from datasets import load_dataset
from huggingface_hub import snapshot_download
import sys, json

repo = snapshot_download("amphora/MathConstructOptimize-Envs", repo_type="dataset", allow_patterns=["grade.py", "graders/*"])
sys.path.insert(0, repo)
from grade import grade

ds = load_dataset("amphora/MathConstructOptimize-Envs", "construct", split="train")
row = ds[0]
reward, details = grade(row, json.loads(row["reference_answer"]))   # -> 1.0, {"valid": True}

Graders need Python ≥ 3.10 with numpy, scipy, sympy and networkx. Every check runs in under 60 s. Feasibility checks use exact integer or rational arithmetic wherever the problem allows.

The optimize reward is 0 for an invalid answer, else 0.1 + 0.9 · clip(progress, 0, 1). Progress is linear between baseline (a deliberately weak valid construction) and best_known. The kissing-number tasks use a log scale of the overlap loss instead. The 0.1 floor for validity keeps GRPO groups from being all-zero, because without it research-level tasks gave no signal in our pilot.

Tags

tag meaning
agentic_trivial a solver (CP-SAT, z3, brute force) cracks the top level within seconds, so the task is useful single-turn but weak for sandboxed agents (2,368 tasks)
np_search the task is essentially combinatorial search
best_known_uncertain best_known comes from our own search or an uncited value
ea_under_review EinsteinArena marks the problem as under review. We audited each one and included it only when we could make the check sound
unique_answer the answer is unique, but it is still verified as a witness (e.g. by expanding a factorization)
float_objective, exact_integer, exact_rational, ... how the objective is computed
reference_is_baseline / reference_below_record the shipped reference_answer is the weak baseline (reward 0.1) or a valid construction weaker than best_known
known_optimum best_known is a proved optimum, so the reward cannot exceed 1 by improving it
record_memorizable the record object is famous; an agent that recalls it saturates the reward
license_restricted source license restricts derivatives (ALE-Bench, CC BY-ND 4.0)
license_unknown the source states no license (FrontierShift)

Reference pass rates (pilot, 66 tasks)

Pilot with 8 single-turn samples and 4 agentic attempts per task (Harbor terminus-2, no network):

model / mode trivial (≥0.9) trainable too hard (≤0.1)
gpt-oss-120b, single-turn 23 23 20
gpt-oss-120b, agentic 33 19 13
Qwen3-8B, single-turn 13 15 38
Qwen3-8B, agentic 8 10 47

Pass rates vary a lot by model and mode, so filter for your policy. Difficulty levels are monotone within every generator family.

Upstream verifier bugs found and fixed

Re-implementing the checkers surfaced problems in the source verifiers that an RL policy could exploit:

  • Model output executed as code. RLVE integral (sympify) and Reasoning Gym integration (parse_expr) evaluate the model's answer as Python, and they also accept an unevaluated Integral(f, x). Our checkers parse through a whitelist syntax tree.
  • Empty answers accepted. MathConstraint verify() lets the solver fill in any variable the answer omits, so {} passes.
  • Missing range, length or type checks.
    • NPPC 3-colouring accepts an all-distinct colouring.
    • Clique and independent set accept a vertex repeated k times.
    • Quadratic congruence accepts x = 0.
    • Several verifiers accept floats or bools.
  • Floating-point feasibility checks.
    • EinsteinArena circle packing and circles-in-rectangle (the AlphaEvolve seed overlaps by about 1e-16).
    • Heilbronn triangle containment (uses a rounded √3).
    • Finch tolerances that allowed beating the proven 10/3 bound.
    • AlphaEvolve p58 (Erdős–Szekeres): the published 33- and 65-point sets reported as having no convex 7- or 8-gon do contain one under exact arithmetic.
  • Checks that are wrong or too weak.
    • AlphaEvolve spherical designs: the pass test compares a negated error, so it always passes.
    • AlphaEvolve 3D Kakeya ignores tubes that leave its Monte Carlo box.
    • Arithmetic Kakeya "repairs" the submitted distribution before scoring it.
    • The prime-number-theorem constraint was checked on random samples.
    • The uncertainty-principle root scan could miss roots.
  • Wrong or unreachable targets. Several Finch targets are above a provable maximum, below a known optimum, or infeasible.

Excluded

  • AlphaEvolve problem 6: the notebook's functional differs from the one a construction-checker can certify.
  • Problems with no checkable objective (proof-only or meta problems), or no recoverable construction or verifier.
  • FunSearch corner-free sets (checker not released).
  • Sources without a license (v1). v2 includes FrontierShift, which states no license, tagged license_unknown.
  • Duplicate problem and size pairs across sources (deduplicated by problem_key).

v2 (2026-11-18): optimize extension

216 new optimize tasks in 77 families (the construct subset is unchanged; the previous version is git tag pre-v2). Same reward contract and graders interface; every reference answer was re-graded in an isolated copy of the task's tests/ dir, through grade.py, and by the Harbor oracle agent in the sandbox image; a no-op answer scores 0 everywhere. All checks run in under 10 s.

source families tasks license notes
Optimization Constants in Mathematics 13 17 Apache-2.0 one family per constant where a finite object certifies a bound (Lehmer/Mahler measure, degree vs sensitivity, Komlós discrepancy, matrix-multiplication exponent from exact small-format algorithms, biplanar chromatic number, Bohnenblust–Hille, Berry–Esseen, Brezis–Gallouet–Wainger, sunflower-free families, Fourier entropy–influence, hollow lattice width, narrowest admissible tuples, covering systems)
AlphaEvolve repository (new problems/sizes) 7 16 CC-BY-4.0 2D Nikodym over F_{p²}, Hausdorff–Young, Thomson n=292/306, hexagons in a hexagon, Erdős discrepancy C=3, Szemerédi–Trotter incidences, Rudin L4/L2 spherical harmonics
Leaps in Bounds 14 82 MIT cages, degree–diameter, superpermutations, snake/coil-in-the-box, Golomb rulers, no-three-in-line, sorting-network size/depth, equal circles in a square/triangle, isosceles sets, unit squares in a square, disk covering
FrontierShift 8 9 unknown matrix-multiplication rank 3×3/4×4 over Q, max-determinant ±1 23×23, Boolean nonlinearity n=9, low-weight codeword (decoding challenge n=1280), abc quality, Cramér–Shanks–Granville gap ratio, rational Diophantine septuples, tetrahedra packing density
FrontierCO 1 15 MIT minimum dominating set only (the other 7 types overlap CO-Bench)
ALE-Bench 18 36 CC BY-ND 4.0 non-interactive AtCoder Heuristic Contest problems, 2 public-seed instances each; statements kept verbatim; scorers re-implemented in Python and matched against the official tools on ~7,700 outputs
FrontierCS 14 37 MIT algorithmic-track problems with deterministic scorers (Max-Cut, Max-3-SAT, Zarankiewicz grids, XOR-Sidon sets, ...); each port matched the upstream checker on ≥100 outputs
EdgeBench 2 4 CC-BY-4.0 the two released task directories that run offline (AHC056, AHC058)

License caveats. ALE-Bench is CC BY-ND 4.0 (no derivatives): its statements are reproduced verbatim and its tasks carry license_restricted; check that your use is compatible before redistributing modified versions. FrontierShift states no license (its repository is not public); those tasks carry license_unknown. AtCoder problem statements (ALE-Bench, EdgeBench) remain © AtCoder.

best_known provenance. Values are the published records where available (cited in tests/instance.json → best_known_source, hidden from the agent). For contest instances and several FrontierCS/ALE problems no per-instance record is published, so best_known is our own best solution (tag best_known_uncertain); agents can beat it and the reward clips at 1.

Excluded in v2. Anything overlapping the problem families of HorizonMath, HeuriGym or CO-Bench is left out at every size (e.g. Ramsey/Schur/van der Waerden colourings, kissing numbers, Tammes, spherical designs, difference bases, merit factor, codes and covering designs, Hadamard matrices, sphere packing, TSP/routing, scheduling, bin/rectangle/circle-unequal packing, facility location, set cover, graph colouring, MIS). Also skipped: constants whose certificate is a proof rather than an object, interactive or program-output problems, problems needing a GPU/network/hardware, and problems whose verifier could not be made sound and fast.

Upstream verifier bugs found in v2 sources (all fixed in our checkers):

  • AlphaEvolve p6 scores a different functional than stated; p13 never checks f̂ ≥ 0; p14 truncates the Fourier integral; p33 clamps coincident points to distance 1e-12; the hexagon-packing outer side is taken as input, not computed; p40 scores the longest valid prefix plus a bonus; p55's sample layout overlaps; p56 silently drops duplicate lines; p57 drops coefficients below 1e-8.
  • EdgeBench AHC058: the eval script reads any Score = … line, so a submission can forge the score.
  • FrontierCS 58/8 compare counts only modulo primes; 192/176 ignore trailing tokens; 227 has no range check; 111 and 27 accept empty answers; 193 is a re-encoding of 192.
  • FrontierCO MDS accepts 3.0/True as node ids.
  • ALE-Bench tools: ahc014 turn count wrong, ahc004 panics on Unicode whitespace, ahc024/041 accept an empty output at turn 0.

License

Each row carries the license of its source (license column): MIT (93 families), CC-BY-4.0 (68), Apache-2.0 (32), CC-BY-ND-4.0 (18, ALE-Bench), unknown (8, FrontierShift). Attribution belongs to the original authors of each source listed above. Our packaging, checkers and generators are released under the same terms as the corresponding source.

Downloads last month
607