Infinite Problem Generator: Verifiably Scaling Physics Reasoning Data with Agentic Workflows
Paper • 2603.14486 • Published
chapter stringclasses 7
values | word_problem stringlengths 178 1.23k | execution_result stringlengths 3 22 | signature stringlengths 24 81 | formula_ids listlengths 2 6 | unknown_var stringlengths 1 48 | variables unknown | code stringlengths 604 7.92k | validation_result dict |
|---|---|---|---|---|---|---|---|---|
Rigid Body Dynamics | A car accelerates uniformly. Its wheels, with a radius of 0.35 meters, initially spin at an angular velocity of 10.0 rad/s and experience a constant angular acceleration of 5.0 rad/s^2. What is the total linear displacement of the car after 8.0 seconds? | 84.0 | fids=[2_E,8_C,8_D]|unknown=car_displacement | [
"8_C",
"8_D",
"2_E"
] | car_displacement | {
"wheel_radius": {
"value": 0.35000000000000003,
"unit": "meter"
},
"initial_angular_velocity_of_wheel": {
"value": 10,
"unit": "radian/second"
},
"angular_acceleration_of_wheel": {
"value": 5,
"unit": "radian/second^2"
},
"time_interval": {
"value": 8,
"unit": "second"
... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_displacement_from_time... | {
"valid": true,
"unknown_var": "car_displacement"
} |
Rigid Body Dynamics | A car begins to accelerate from an initial linear speed of 1.0 m/s. It maintains a constant linear acceleration of 0.5 m/s² for a period of 3.0 seconds. If the radius of the car's wheels is 0.2 meters, what is the average angular acceleration of the wheels during this time? | 2.5 | fids=[2_D,8_B,8_C]|unknown=pulley_angular_acceleration | [
"8_C",
"2_D",
"8_B"
] | pulley_angular_acceleration | {
"pulley_radius": {
"value": 0.2,
"unit": "meter"
},
"bucket_speed": {
"value": 1,
"unit": "meter/second"
},
"bucket_acceleration": {
"value": 0.5,
"unit": "meter/second^2"
},
"time": {
"value": 3,
"unit": "second"
},
"pulley_angular_acceleration": {
"value": null,... | import math
# Formula ID: 8_C
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
# Formula ID: 2_D
def calculate_final_velocity_from_time(initial_velocity: float, acceleration: float, time: float) -> float:
return initial_velocit... | {
"valid": true,
"unknown_var": "pulley_angular_acceleration"
} |
Rigid Body Dynamics | A measuring tape is being retracted into its casing. The tape's spool has a radius of 0.15 meters. At a certain moment, the tape is retracting at a speed of 2.5 m/s and is accelerating at 1.2 m/s². Assuming the tape's linear motion corresponds to the tangential motion of a point on the spool's outer edge, what is the m... | 41.68394308497112 | fids=[8_C,8_D,8_E,8_F]|unknown=spool_total_acceleration | [
"8_C",
"8_D",
"8_E",
"8_F"
] | spool_total_acceleration | {
"pulley_radius": {
"value": 0.15,
"unit": "meter"
},
"bucket_speed": {
"value": 2.5,
"unit": "meter/second"
},
"bucket_acceleration": {
"value": 1.2,
"unit": "meter/second^2"
},
"spool_total_acceleration": {
"value": null,
"unit": "m/s^2"
}
} | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_centripetal_accelerati... | {
"valid": true,
"unknown_var": "spool_total_acceleration"
} |
Rigid Body Dynamics | A measuring tape is retracting into its casing. The tape spool has an effective radius of 0.18 meters. Initially, the tape retracts at a speed of 1.2 m/s. The retraction mechanism then causes the tape to accelerate uniformly at 0.4 m/s² for 3.5 seconds. Assuming the tape does not slip on the spool, what is the final an... | 14.444444444444446 | fids=[8_C,8_D,8_R]|unknown=final_spool_angular_velocity | [
"8_C",
"8_D",
"8_R"
] | final_spool_angular_velocity | {
"spool_radius": {
"value": 0.18,
"unit": "meter"
},
"initial_tape_speed": {
"value": 1.2,
"unit": "meter/second"
},
"tape_acceleration": {
"value": 0.4,
"unit": "meter/second^2"
},
"time_interval": {
"value": 3.5,
"unit": "second"
},
"final_spool_angular_velocity": {
... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_final_angular_velocity... | {
"valid": true,
"unknown_var": "final_spool_angular_velocity"
} |
Rigid Body Dynamics | A fishing reel is winding in a fishing line. The spool has a radius of 0.12 meters. Initially, the line is being reeled in at a speed of 1.5 m/s. The reel then accelerates uniformly, causing the line to gain speed at a rate of 0.4 m/s². What is the total angular displacement of the spool after 8.0 seconds? | 206.66666666666669 | fids=[8_C,8_D,8_S]|unknown=angular_displacement | [
"8_C",
"8_D",
"8_S"
] | angular_displacement | {
"pulley_radius": {
"value": 0.12,
"unit": "meter"
},
"initial_linear_speed": {
"value": 1.5,
"unit": "meter/second"
},
"linear_acceleration": {
"value": 0.4,
"unit": "meter/second^2"
},
"time": {
"value": 8,
"unit": "second"
},
"angular_displacement": {
"value": n... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_angular_displacement(i... | {
"valid": true,
"unknown_var": "angular_displacement"
} |
Rigid Body Dynamics | A fishing reel is winding in a fishing line. The spool has a radius of 0.1 meters. Initially, the line is being reeled in at a speed of 1.2 m/s. If the line's retraction accelerates uniformly at a constant rate of 0.8 m/s², what will be the linear speed of the fishing line after 5.0 seconds? | 5.2 | fids=[8_C,8_D,8_R]|unknown=final_linear_speed_of_line | [
"8_C",
"8_D",
"8_R"
] | final_linear_speed_of_line | {
"pulley_radius": {
"value": 0.1,
"unit": "meter"
},
"initial_linear_speed": {
"value": 1.2,
"unit": "meter/second"
},
"linear_acceleration": {
"value": 0.8,
"unit": "meter/second^2"
},
"time_interval": {
"value": 5,
"unit": "second"
},
"final_linear_speed_of_line": {
... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_final_angular_velocity... | {
"valid": true,
"unknown_var": "final_linear_speed_of_line"
} |
Rigid Body Dynamics | A conveyor belt system uses a cylindrical roller to move goods. The roller has a radius of 0.25 meters. Initially, the conveyor belt is moving at a steady speed of 1.2 m/s. The system then accelerates, and after 4.0 seconds, the conveyor belt reaches a speed of 3.8 m/s. Assuming the belt does not slip on the roller, wh... | 15.2 | fids=[2_C,8_C,8_D,8_R]|unknown=final_pulley_angular_velocity | [
"2_C",
"8_C",
"8_D",
"8_R"
] | final_pulley_angular_velocity | {
"pulley_radius": {
"value": 0.25,
"unit": "meter"
},
"initial_belt_speed": {
"value": 1.2,
"unit": "meter/second"
},
"final_belt_speed": {
"value": 3.8,
"unit": "meter/second"
},
"time": {
"value": 4,
"unit": "second"
},
"final_pulley_angular_velocity": {
"value":... | import math
def calculate_average_acceleration(final_velocity: float, initial_velocity: float, time_interval: float) -> float:
if time_interval == 0:
return float('inf')
return (final_velocity - initial_velocity) / time_interval
def calculate_linear_speed_from_angular_velocity(radius: float, angular_v... | {
"valid": true,
"unknown_var": "final_pulley_angular_velocity"
} |
Rigid Body Dynamics | A conveyor belt system uses a cylindrical roller to move goods. The roller has a radius of 0.28 meters. Initially, the conveyor belt is moving at a speed of 1.5 m/s. Due to an adjustment, the belt begins to accelerate uniformly at 0.8 m/s^2. What will be the angular velocity of the roller after 5.0 seconds? | 19.642857142857142 | fids=[8_C,8_D,8_R]|unknown=final_pulley_angular_velocity | [
"8_C",
"8_D",
"8_R"
] | final_pulley_angular_velocity | {
"pulley_radius": {
"value": 0.28,
"unit": "meter"
},
"initial_bucket_speed": {
"value": 1.5,
"unit": "meter/second"
},
"bucket_acceleration": {
"value": 0.8,
"unit": "meter/second^2"
},
"time_interval": {
"value": 5,
"unit": "second"
},
"final_pulley_angular_velocity"... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_final_angular_velocity... | {
"valid": true,
"unknown_var": "final_pulley_angular_velocity"
} |
Rigid Body Dynamics | A cyclist starts pedaling, causing their bicycle to accelerate uniformly. The bicycle's wheels have a radius of 0.35 meters. Initially, the bicycle is moving at a speed of 1.0 m/s. If the bicycle accelerates at a constant rate of 0.5 m/s², how much time does it take for the wheels to reach a final angular velocity corr... | 3.9999999999999996 | fids=[8_C,8_D,8_R]|unknown=time_elapsed | [
"8_C",
"8_D",
"8_R"
] | time_elapsed | {
"wheel_radius": {
"value": 0.35000000000000003,
"unit": "meter"
},
"initial_bicycle_speed": {
"value": 1,
"unit": "meter/second"
},
"bicycle_acceleration": {
"value": 0.5,
"unit": "meter/second^2"
},
"final_bicycle_speed": {
"value": 3,
"unit": "meter/second"
},
"time... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_final_angular_velocity... | {
"valid": true,
"unknown_var": "time_elapsed"
} |
Rigid Body Dynamics | A cyclist starts pedaling, causing their bicycle to accelerate uniformly. The bicycle's wheels have a radius of 0.35 meters. Initially, the bicycle is moving at a speed of 2.0 m/s. If it accelerates at 0.5 m/s² for 8.0 seconds, what is the total angular displacement of one of the wheels during this time? | 91.42857142857143 | fids=[8_C,8_D,8_S]|unknown=total_angular_displacement | [
"8_C",
"8_D",
"8_S"
] | total_angular_displacement | {
"wheel_radius": {
"value": 0.35000000000000003,
"unit": "meter"
},
"initial_bicycle_speed": {
"value": 2,
"unit": "meter/second"
},
"bicycle_acceleration": {
"value": 0.5,
"unit": "meter/second^2"
},
"time_elapsed": {
"value": 8,
"unit": "second"
},
"total_angular_dis... | import math
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_tangential_acceleration(radius: float, angular_acceleration: float) -> float:
return radius * angular_acceleration
def calculate_angular_displacement(i... | {
"valid": true,
"unknown_var": "total_angular_displacement"
} |
Rigid Body Dynamics | A uniform wooden door, which can be approximated as a thin rod, has a mass of 30 kg and a width (length) of 0.9 meters. It is attached to hinges at one end. A person pushes horizontally on the door handle, which is located 0.8 meters from the hinges, with a force of 40 N. The force is applied perpendicular to the door'... | 3.9506172839506166 | fids=[10_J,10_N,10_O]|unknown=angular_acceleration | [
"10_J",
"10_N",
"10_O"
] | angular_acceleration | {
"mass": {
"value": 30,
"unit": "kg"
},
"length": {
"value": 0.9,
"unit": "m"
},
"force_magnitude": {
"value": 40,
"unit": "N"
},
"lever_arm": {
"value": 0.8,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
... | import math
def calculate_inertia_rod_end(mass: float, length: float) -> float:
return (1 / 3) * mass * length**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.s... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
Rigid Body Dynamics | A uniform solid disc, often used as a flywheel, has a mass of 50 kg and a radius of 0.45 meters. Instead of being mounted through its center, it is mounted on a fixed axle that passes perpendicular to the disc's plane at a distance of 0.2 meters from its center. A constant force of 150 N is applied tangentially to the ... | 10.619469026548673 | fids=[10_C,10_G,10_N,10_O]|unknown=angular_acceleration | [
"10_G",
"10_C",
"10_N",
"10_O"
] | angular_acceleration | {
"mass": {
"value": 50,
"unit": "kg"
},
"radius": {
"value": 0.45,
"unit": "m"
},
"distance": {
"value": 0.2,
"unit": "m"
},
"force_magnitude": {
"value": 150,
"unit": "N"
},
"lever_arm": {
"value": 0.5,
"unit": "m"
},
"angle_degrees": {
"value": 90,
... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_parallel_axis_inertia(inertia_cm: float, mass: float, distance: float) -> float:
return inertia_cm + (mass * distance**2)
def calculate_torque_magnitude(force_magnitude: floa... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
Rigid Body Dynamics | A skilled mechanic is meticulously tightening a bolt on an engine. The bolt assembly, including the part it secures, can be accurately modeled as a uniform disc with a total mass of 0.5 kg and a radius of 0.08 meters. To apply the necessary torque, the mechanic uses a wrench with an effective lever arm of 0.25 meters. ... | 11012.022899834863 | fids=[10_G,10_N,10_O]|unknown=angular_acceleration | [
"10_G",
"10_N",
"10_O"
] | angular_acceleration | {
"bolt_assembly_mass": {
"value": 0.5,
"unit": "kg"
},
"bolt_assembly_radius": {
"value": 0.08,
"unit": "m"
},
"force_on_wrench": {
"value": 75,
"unit": "N"
},
"wrench_length": {
"value": 0.25,
"unit": "m"
},
"angle_of_force_application": {
"value": 70,
"unit":... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude *... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
Rigid Body Dynamics | A skilled mechanic is tightening a stubborn bolt on an engine. The bolt can be accurately modeled as a uniform solid disc with a mass of 0.8 kg and a radius of 0.04 meters. The mechanic applies a force perpendicular to a wrench, which has an effective lever arm of 0.3 meters from the center of the bolt. If the bolt nee... | 0.04266666666666667 | fids=[10_G,10_N,10_O]|unknown=force_magnitude | [
"10_G",
"10_O",
"10_N"
] | force_magnitude | {
"mass": {
"value": 0.8,
"unit": "kg"
},
"radius": {
"value": 0.04,
"unit": "m"
},
"lever_arm": {
"value": 0.30000000000000004,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 20,
"unit": "rad/s^2"
},
"... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: float) -> float:
if moment_of_inertia == 0:
return float('inf')
return net_torque / moment_o... | {
"valid": true,
"unknown_var": "force_magnitude"
} |
Rigid Body Dynamics | A child is playing with a bicycle wheel, which is mounted on a stationary, frictionless axle. The wheel can be approximated as a uniform solid disc with a mass of 2.5 kg and a radius of 0.35 meters. The child applies a force of 12 N to one of the spokes at an angle of 60.0 degrees relative to the spoke (and the radius ... | 0.07367229997471786 | fids=[10_G,10_N,10_O]|unknown=lever_arm | [
"10_G",
"10_O",
"10_N"
] | lever_arm | {
"mass": {
"value": 2.5,
"unit": "kg"
},
"radius": {
"value": 0.35000000000000003,
"unit": "m"
},
"force_magnitude": {
"value": 12,
"unit": "N"
},
"angle_degrees": {
"value": 60,
"unit": "degrees"
},
"angular_acceleration": {
"value": 5,
"unit": "rad/s^2"
},
... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: float) -> float:
if moment_of_inertia == 0:
return float('inf')
return net_torque / moment_o... | {
"valid": true,
"unknown_var": "lever_arm"
} |
Rigid Body Dynamics | A child is playing with a bicycle wheel that is mounted on a stationary, frictionless axle. The wheel can be approximated as a uniform solid disc with a mass of 1.5 kg and a radius of 0.35 meters. The child pushes perpendicularly on a spoke with a force of 15 N at a distance of 0.30 meters from the center of the axle. ... | 0.24748737341529162 | fids=[10_G,10_M,10_N,10_O]|unknown=radius_of_gyration | [
"10_G",
"10_N",
"10_O",
"10_M"
] | radius_of_gyration | {
"mass": {
"value": 1.5,
"unit": "kg"
},
"radius": {
"value": 0.35000000000000003,
"unit": "m"
},
"force_magnitude": {
"value": 15,
"unit": "N"
},
"lever_arm": {
"value": 0.30000000000000004,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude *... | {
"valid": true,
"unknown_var": "radius_of_gyration"
} |
Rigid Body Dynamics | A uniform seesaw, which can be modeled as a rigid rod, has a mass of 50 kg and a total length of 4.0 meters. It pivots freely at its center. A child with a mass of 30 kg sits 1.5 meters to the left of the pivot. On the right side, a second child with a mass of 25 kg sits 2.2 meters from the pivot. Neglecting any fricti... | -0.38406270411495796 | fids=[10_K,10_N,10_O,5_A]|unknown=angular_acceleration | [
"5_A",
"10_N",
"10_K",
"10_O"
] | angular_acceleration | {
"seesaw_mass": {
"value": 50,
"unit": "kg"
},
"seesaw_length": {
"value": 4,
"unit": "m"
},
"mass_child_1": {
"value": 30,
"unit": "kg"
},
"distance_child_1": {
"value": 1.5,
"unit": "m"
},
"mass_child_2": {
"value": 25,
"unit": "kg"
},
"distance_child_2":... | import math
def calculate_net_force(mass: float, acceleration: float) -> float:
return mass * acceleration
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angl... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
Rigid Body Dynamics | A uniform seesaw, which can be modeled as a rigid rod, has a mass of 50 kg and a total length of 4.0 meters. It pivots freely at its center. Two children are sitting on the seesaw: Child A, with a mass of 30 kg, sits 1.8 meters from the pivot. Child B, with a mass of 25 kg, sits 2.0 meters from the pivot on the opposit... | 1.5852494671236679 | fids=[10_A,10_K,10_M]|unknown=radius_of_gyration | [
"10_K",
"10_A",
"10_M"
] | radius_of_gyration | {
"seesaw_mass": {
"value": 50,
"unit": "kg"
},
"seesaw_length": {
"value": 4,
"unit": "m"
},
"child_A_mass": {
"value": 30,
"unit": "kg"
},
"child_A_distance": {
"value": 1.8,
"unit": "m"
},
"child_B_mass": {
"value": 25,
"unit": "kg"
},
"child_B_distance":... | import math
# import numpy as np # only if needed
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def cal... | {
"valid": true,
"unknown_var": "radius_of_gyration"
} |
Rigid Body Dynamics | A single blade of a large ceiling fan can be accurately modeled as a uniform rod, rotating about its central hub. This blade has a mass of 2.5 kg and a total length of 1.2 meters. If a maintenance worker accidentally applies a force of 30 N to the very tip of the blade, at an angle of 75 degrees with respect to the bla... | 57.9555495773441 | fids=[10_K,10_N,10_O]|unknown=angular_acceleration | [
"10_K",
"10_N",
"10_O"
] | angular_acceleration | {
"mass": {
"value": 2.5,
"unit": "kg"
},
"length": {
"value": 1.2,
"unit": "m"
},
"force_magnitude": {
"value": 30,
"unit": "N"
},
"angle_degrees": {
"value": 75,
"unit": "degrees"
},
"angular_acceleration": {
"value": null,
"unit": "rad/s^2"
}
} | import math
def calculate_inertia_rod_center(mass: float, length: float) -> float:
return (1 / 12) * mass * length**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * ma... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
Rigid Body Dynamics | A single blade of a large ceiling fan can be accurately modeled as a uniform rod. This blade has a mass of 2.5 kg and a total length of 0.80 meters. The blade rotates about its central hub, which is located precisely at its center. If a force is applied perpendicularly to the very tip of the blade, causing it to achiev... | 1.5000000000000002 | fids=[10_K,10_N,10_O]|unknown=force_magnitude | [
"10_K",
"10_N",
"10_O"
] | force_magnitude | {
"mass": {
"value": 2.5,
"unit": "kg"
},
"length": {
"value": 0.8,
"unit": "m"
},
"angular_acceleration": {
"value": 4.5,
"unit": "rad/s^2"
},
"lever_arm": {
"value": 0.4,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"force_magnitude"... | import math
# import numpy as np # only if needed
def calculate_inertia_rod_center(mass: float, length: float) -> float:
return (1 / 12) * mass * length**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
... | {
"valid": true,
"unknown_var": "force_magnitude"
} |
Rigid Body Dynamics | A uniform rod, with a length of 0.60 meters, is pivoted frictionlessly at its exact center. A force of 25.0 N is applied perpendicularly to one end of the rod, causing it to rotate with an angular acceleration of 5.0 rad/s². Determine the moment of inertia of the rod about its pivot point. | 1.5 | fids=[10_N,10_O]|unknown=moment_of_inertia | [
"10_N",
"10_O"
] | moment_of_inertia | {
"force_magnitude": {
"value": 25,
"unit": "N"
},
"lever_arm": {
"value": 0.30000000000000004,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 5,
"unit": "rad/s^2"
},
"moment_of_inertia": {
"value": null,
"... | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: flo... | {
"valid": true,
"unknown_var": "moment_of_inertia"
} |
Rigid Body Dynamics | A uniform rod, 0.80 meters in length, is pivoted at its exact center. A constant force of 20.0 N is applied perpendicularly to one end of the rod, causing it to rotate with an angular acceleration of 5.0 rad/s². What is the mass of the rod? | 30.0 | fids=[10_K,10_N,10_O]|unknown=mass | [
"10_N",
"10_O",
"10_K"
] | mass | {
"length": {
"value": 0.8,
"unit": "m"
},
"force_magnitude": {
"value": 20,
"unit": "N"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 5,
"unit": "rad/s^2"
},
"mass": {
"value": null,
"unit": "kg"
}
} | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: flo... | {
"valid": true,
"unknown_var": "mass"
} |
Rigid Body Dynamics | A large industrial flywheel, with a mass of 20.0 kg, is spun up by a powerful motor. A constant tangential force of 50.0 N is applied by the motor to the rim of the flywheel, which has a radius of 0.75 meters. If the flywheel accelerates from rest with a constant angular acceleration of 2.5 rad/s², calculate its radius... | 0.8660254037844386 | fids=[10_M,10_N,10_O]|unknown=radius_of_gyration | [
"10_N",
"10_O",
"10_M"
] | radius_of_gyration | {
"mass": {
"value": 20,
"unit": "kg"
},
"force_magnitude": {
"value": 50,
"unit": "N"
},
"lever_arm": {
"value": 0.75,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 2.5,
"unit": "rad/s^2"
},
"radius_o... | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: flo... | {
"valid": true,
"unknown_var": "radius_of_gyration"
} |
Rigid Body Dynamics | A large industrial flywheel in a factory, which can be modeled as a uniform solid disc, is being spun up by a motor. A constant tangential force of 75.0 N is applied by the motor at a point 0.50 meters from the flywheel's central axis of rotation. This force results in an angular acceleration of 15.0 rad/s². Assuming t... | 20.0 | fids=[10_G,10_N,10_O]|unknown=mass | [
"10_N",
"10_O",
"10_G"
] | mass | {
"force_magnitude": {
"value": 75,
"unit": "N"
},
"lever_arm": {
"value": 0.5,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 15,
"unit": "rad/s^2"
},
"mass": {
"value": null,
"unit": "kg"
}
} | import math
# import numpy as np # only if needed
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(ne... | {
"valid": true,
"unknown_var": "mass"
} |
Rigid Body Dynamics | A doorknob is located 0.80 meters from the hinges of a solid, uniform door. A person applies a force of 35.0 N tangentially to the doorknob, perpendicular to the door's surface, causing the door to accelerate rotationally at 1.5 rad/s^2. Treating the door as a uniform rod pivoted at one end (its hinges), what is the ma... | 87.49999999999999 | fids=[10_J,10_N,10_O]|unknown=mass | [
"10_N",
"10_O",
"10_J"
] | mass | {
"force_magnitude": {
"value": 35,
"unit": "N"
},
"lever_arm": {
"value": 0.8,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"angular_acceleration": {
"value": 1.5,
"unit": "rad/s^2"
},
"length": {
"value": 0.8,
"unit": "m"
},
"mass": ... | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: flo... | {
"valid": true,
"unknown_var": "mass"
} |
Rigid Body Dynamics | A heavy industrial grindstone, whose moment of inertia is unknown due to its intricate internal structure, is initially rotating at an angular velocity of 12.0 radians per second. A constant tangential force of 45.0 N is applied to its edge, which is located 0.50 meters from the axis of rotation. This force is maintain... | 5.0 | fids=[10_N,10_R,10_S]|unknown=moment_of_inertia | [
"10_N",
"10_S",
"10_R"
] | moment_of_inertia | {
"initial_angular_velocity": {
"value": 12,
"unit": "rad/s"
},
"force_magnitude": {
"value": 45,
"unit": "N"
},
"lever_arm": {
"value": 0.5,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"time_interval": {
"value": 4,
"unit": "s"
},
"f... | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angular_velocity: fl... | {
"valid": true,
"unknown_var": "moment_of_inertia"
} |
Rigid Body Dynamics | A child is pushing a large merry-go-round that is designed as a uniform solid disc with a mass of 75.0 kg and a radius of 0.8 meters. However, the merry-go-round also has a complex seating structure and decorative elements whose combined additional moment of inertia is unknown. The child applies a constant tangential f... | 2.6666666666666643 | fids=[10_G,10_N,10_O]|unknown=additional_moment_of_inertia | [
"10_N",
"10_O",
"10_G"
] | additional_moment_of_inertia | {
"force_magnitude": {
"value": 50,
"unit": "N"
},
"lever_arm": {
"value": 0.8,
"unit": "m"
},
"angle_degrees": {
"value": 90,
"unit": "degrees"
},
"mass_disc": {
"value": 75,
"unit": "kg"
},
"radius": {
"value": 0.8,
"unit": "m"
},
"angular_acceleration": {... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude *... | {
"valid": true,
"unknown_var": "additional_moment_of_inertia"
} |
Rigid Body Dynamics | A child pushes a merry-go-round that is initially composed of a uniform solid disc with a mass of 60.0 kg and a radius of 0.8 meters. An additional, smaller uniform solid disc is then placed concentrically on top of the first. This smaller disc has a radius of 0.4 meters. The child applies a tangential force of 19.5 N ... | 19.999999999999968 | fids=[10_G,10_N,10_O]|unknown=mass_inner_disc | [
"10_N",
"10_O",
"10_G"
] | mass_inner_disc | {
"mass_outer_disc": {
"value": 60,
"unit": "kg"
},
"radius_outer_disc": {
"value": 0.8,
"unit": "m"
},
"radius_inner_disc": {
"value": 0.4,
"unit": "m"
},
"force": {
"value": 19.5,
"unit": "N"
},
"angular_acceleration": {
"value": 0.75,
"unit": "rad/s^2"
},
... | import math
def calculate_torque_magnitude(force_magnitude: float, lever_arm: float, angle_degrees: float) -> float:
angle_radians = math.radians(angle_degrees)
return lever_arm * force_magnitude * math.sin(angle_radians)
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: flo... | {
"valid": true,
"unknown_var": "mass_inner_disc"
} |
Rigid Body Dynamics | A vintage record player features a uniform solid platter with a mass of 2.5 kg and a radius of 0.15 m, initially spinning at an angular speed of 33.3 rad/s. A stationary, uniform solid vinyl record, with a mass of 0.12 kg and a radius of 0.14 m, is gently lowered onto the center of the spinning platter. Due to friction... | 31.96349953926487 | fids=[10_G,10_R]|unknown=final_common_angular_speed | [
"10_G",
"10_R"
] | final_common_angular_speed | {
"mass_platter": {
"value": 2.5,
"unit": "kg"
},
"radius_platter": {
"value": 0.15,
"unit": "m"
},
"initial_angular_speed": {
"value": 33.3,
"unit": "rad/s"
},
"mass_record": {
"value": 0.12,
"unit": "kg"
},
"radius_record": {
"value": 0.14,
"unit": "m"
},
... | import math
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angular_velocity: float) -> float:
return moment_of_inertia * angular_velocity
def solve():
try:
# Define kn... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A cylindrical space station module, which can be approximated as a uniform solid cylinder, has a mass of 50.0 kg and a radius of 1.5 meters. It is initially rotating about its central axis with a rotational kinetic energy of 5625.0 Joules. This module then successfully docks coaxially with an identical, initially stati... | 7.0710678118654755 | fids=[10_I,10_P,10_R]|unknown=final_common_angular_speed | [
"10_I",
"10_P",
"10_R"
] | final_common_angular_speed | {
"mass_of_module": {
"value": 50,
"unit": "kg"
},
"radius_of_module": {
"value": 1.5,
"unit": "m"
},
"initial_rotational_kinetic_energy": {
"value": 5625,
"unit": "J"
},
"final_common_angular_speed": {
"value": null,
"unit": "rad/s"
}
} | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_rotational_kinetic_energy(moment_of_inertia: float, angular_velocity: float) -> float:
return 0.5 * moment_of_inertia * angular_velocity**2
def calculate_angular_momentu... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A rotating satellite module (Module A) with a moment of inertia of 25.0 kg·m² is spinning at an initial angular speed of 50.0 rad/s. It then successfully docks with an identical, initially non-rotating satellite module (Module B). Assuming no external torques act on the system during docking and the modules rigidly con... | 25.0 | fids=[10_P,10_R]|unknown=final_common_angular_speed | [
"10_R",
"10_P"
] | final_common_angular_speed | {
"moment_of_inertia_of_one_wheel": {
"value": 25,
"unit": "kg·m²"
},
"initial_angular_speed": {
"value": 50,
"unit": "rad/s"
},
"final_common_angular_speed": {
"value": null,
"unit": "rad/s"
}
} | import math
# import numpy as np # only if needed
def calculate_rotational_kinetic_energy(moment_of_inertia: float, angular_velocity: float) -> float:
return 0.5 * moment_of_inertia * angular_velocity**2
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angular_velocity: float) -> float:
re... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | An ice skater, with her arms tucked in, is spinning about a vertical axis with an initial angular speed of 5.0 rad/s. Her moment of inertia in this configuration is 2.0 kg·m². She then gracefully catches her non-spinning partner, whose mass is 70.0 kg. After the catch, the partner is held rigidly at a distance of 0.8 m... | 0.2136752136752136 | fids=[10_A,10_R]|unknown=final_common_angular_speed | [
"10_A",
"10_R"
] | final_common_angular_speed | {
"skater_moment_of_inertia": {
"value": 2,
"unit": "kg·m²"
},
"initial_angular_speed": {
"value": 5,
"unit": "rad/s"
},
"partner_mass": {
"value": 70,
"unit": "kg"
},
"partner_distance_from_axis": {
"value": 0.8,
"unit": "m"
},
"final_common_angular_speed": {
"valu... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_angular_momentum_rigid_body(mome... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | An ice skater, with her arms tucked close to her body, can be modeled as a uniform solid cylindrical torso and two point masses representing her arms. The torso has a mass of 40.0 kg and a radius of 0.15 m. Each arm has a mass of 3.0 kg and is approximated as a point mass at a distance of 0.20 m from her central axis o... | 0.08825786646201073 | fids=[10_A,10_I,10_R]|unknown=final_common_angular_speed | [
"10_I",
"10_A",
"10_R"
] | final_common_angular_speed | {
"mass_torso": {
"value": 40,
"unit": "kg"
},
"radius_torso": {
"value": 0.15,
"unit": "m"
},
"mass_arm": {
"value": 3,
"unit": "kg"
},
"radius_arm": {
"value": 0.2,
"unit": "m"
},
"initial_angular_speed": {
"value": 5,
"unit": "rad/s"
},
"mass_partner": {
... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_inertia_solid_cylinder_axis(mass... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A uniform bicycle wheel, which can be modeled as a solid disc, has a mass of 1.8 kg and a radius of 0.32 m. It is initially spinning freely about its central axle at an angular speed of 75.0 rad/s. This wheel is then carefully brought into contact with an identical, initially stationary bicycle wheel. Due to friction b... | 37.5 | fids=[10_G,10_P,10_R]|unknown=final_common_angular_speed | [
"10_G",
"10_R",
"10_P"
] | final_common_angular_speed | {
"initial_angular_speed": {
"value": 75,
"unit": "rad/s"
},
"moment_of_inertia_of_one_wheel": {
"value": 0.09216,
"unit": "kg·m²"
},
"final_common_angular_speed": {
"value": null,
"unit": "rad/s"
}
} | import math
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angular_velocity: float) -> float:
return moment_of_inertia * angular_velocity
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_rotational_kinetic_energy(m... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A small electric motor's rotor can be approximated as a uniform solid disc with a mass of 0.8 kg and a radius of 0.03 m. It is initially rotating at a constant angular speed of 450.0 rad/s. A fan blade assembly, which can be modeled as a thin uniform ring, has a mass of 0.3 kg and a radius of 0.15 m. This fan assembly ... | 22.78481012658228 | fids=[10_F,10_G,10_R]|unknown=final_common_angular_speed | [
"10_G",
"10_F",
"10_R"
] | final_common_angular_speed | {
"mass_motor_disc": {
"value": 0.8,
"unit": "kg"
},
"radius_motor_disc": {
"value": 0.03,
"unit": "m"
},
"mass_fan_ring": {
"value": 0.30000000000000004,
"unit": "kg"
},
"radius_fan_ring": {
"value": 0.15,
"unit": "m"
},
"initial_angular_speed": {
"value": 450,
... | import math
def calculate_inertia_ring_perp_axis(mass: float, radius: float) -> float:
return mass * radius**2
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angular_velocity: flo... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A small electric motor, whose rotor can be modeled as a uniform solid cylinder, has a mass of 0.5 kg and a radius of 0.04 m. It is initially rotating at a constant angular speed of 500.0 rad/s. A non-rotating fan blade attachment, which can be approximated as a uniform solid disc with a mass of 0.2 kg and a radius of 0... | 142.85714285714283 | fids=[10_G,10_I,10_R]|unknown=final_common_angular_speed | [
"10_I",
"10_G",
"10_R"
] | final_common_angular_speed | {
"motor_mass": {
"value": 0.5,
"unit": "kg"
},
"motor_radius": {
"value": 0.04,
"unit": "m"
},
"initial_angular_speed": {
"value": 500,
"unit": "rad/s"
},
"fan_mass": {
"value": 0.2,
"unit": "kg"
},
"fan_radius": {
"value": 0.1,
"unit": "m"
},
"final_common... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_inertia_disc_perp_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_momentum_rigid_body(moment_of_inertia: float, angula... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A heavy industrial flywheel, designed for energy storage, has an initial moment of inertia of 50.0 kg·m² about its central axis. It is initially rotating at an angular speed of 250.0 rad/s. Suddenly, a non-rotating piece of metallic debris, which can be modeled as a uniform solid sphere with a mass of 0.5 kg and a radi... | 248.4097799526551 | fids=[10_C,10_D,10_R]|unknown=final_common_angular_speed | [
"10_D",
"10_C",
"10_R"
] | final_common_angular_speed | {
"initial_angular_speed": {
"value": 250,
"unit": "rad/s"
},
"moment_of_inertia_of_one_wheel": {
"value": 50,
"unit": "kg·m²"
},
"mass_debris": {
"value": 0.5,
"unit": "kg"
},
"radius_debris": {
"value": 0.02,
"unit": "m"
},
"distance_debris_from_axis": {
"value": ... | import math
# import numpy as np # only if needed
def calculate_parallel_axis_inertia(inertia_cm: float, mass: float, distance: float) -> float:
return inertia_cm + (mass * distance**2)
def calculate_inertia_solid_sphere(mass: float, radius: float) -> float:
return (2 / 5) * mass * radius**2
def calculate_ang... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A nascent exoplanet, approximated as a uniform solid sphere, has a mass of 6.0e23 kg and a radius of 3.0e6 meters. It is slowly rotating about its central axis with an initial angular speed of 5.0e-5 rad/s. A large, non-rotating asteroid, with a mass of 5.0e12 kg, collides with and embeds itself onto the planet's surfa... | 4.999999999895833e-05 | fids=[10_A,10_D,10_R]|unknown=final_common_angular_speed | [
"10_D",
"10_A",
"10_R"
] | final_common_angular_speed | {
"planet_mass": {
"value": 6e+23,
"unit": "kg"
},
"planet_radius": {
"value": 3000000,
"unit": "m"
},
"asteroid_mass": {
"value": 5000000000000,
"unit": "kg"
},
"initial_angular_speed": {
"value": 0.00005,
"unit": "rad/s"
},
"final_common_angular_speed": {
"value":... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_inertia_solid_sphere(mass: float... | {
"valid": true,
"unknown_var": "final_common_angular_speed"
} |
Rigid Body Dynamics | A bucket of mass 10.0 kg is initially at rest, suspended just above the water level in a deep well. A massless rope attached to the bucket is wrapped around a massive cylindrical drum mounted horizontally at the well's edge. The drum, which can be modeled as a uniform solid cylinder, has a mass of 50.0 kg and a radius ... | 9.169826295285768 | fids=[10_I,10_P,7_A,7_C,8_C]|unknown=speed_bucket | [
"10_I",
"7_A",
"8_C",
"10_P",
"7_C"
] | speed_bucket | {
"mass_bucket": {
"value": 10,
"unit": "kg"
},
"mass_drum": {
"value": 50,
"unit": "kg"
},
"radius_drum": {
"value": 0.25,
"unit": "m"
},
"height_fallen": {
"value": 15,
"unit": "m"
},
"gravity": {
"value": 9.81,
"unit": "m/s²"
},
"speed_bucket": {
"val... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_rotational_kinetic_energy(moment_of_inertia: float, angular_velocity: float) -> float:
return 0.5 * moment_of_inertia * angular_velocity**2
def calculate_kinetic_energy_... | {
"valid": true,
"unknown_var": "speed_bucket"
} |
Rigid Body Dynamics | A 5.0 kg bucket is initially at rest at the top of a deep well. It is connected by a massless rope that unwinds from a massive, uniform solid cylindrical drum mounted horizontally at the well's edge. The drum has a mass of 50.0 kg and a radius of 0.2 meters. Assuming there is no friction in the system, what is the spee... | 5.718391382198319 | fids=[10_I,10_T,7_A,8_C]|unknown=speed_bucket | [
"10_I",
"8_C",
"10_T",
"7_A"
] | speed_bucket | {
"mass_drum": {
"value": 50,
"unit": "kg"
},
"radius_drum": {
"value": 0.2,
"unit": "m"
},
"mass_bucket": {
"value": 5,
"unit": "kg"
},
"height": {
"value": 10,
"unit": "m"
},
"gravity": {
"value": 9.81,
"unit": "m/s²"
},
"speed_bucket": {
"value": null... | import math
# import numpy as np # only if needed
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculat... | {
"valid": true,
"unknown_var": "speed_bucket"
} |
Rigid Body Dynamics | A massive crane is used to lower a large concrete block into a foundation pit. The block, with a mass of 500 kg, is attached to a steel cable that unwinds from a heavy, uniform solid cylindrical spool on the crane. The spool has a mass of 200 kg and a radius of 0.30 m. If the concrete block starts from rest and is lowe... | 15.660459763365825 | fids=[10_I,10_T,7_A,8_C]|unknown=final_speed_object | [
"10_I",
"8_C",
"10_T",
"7_A"
] | final_speed_object | {
"mass_spool": {
"value": 200,
"unit": "kg"
},
"radius_spool": {
"value": 0.30000000000000004,
"unit": "m"
},
"mass_object": {
"value": 500,
"unit": "kg"
},
"height_lowered": {
"value": 15,
"unit": "m"
},
"gravity": {
"value": 9.81,
"unit": "m/s²"
},
"final... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_total_kinetic_energy_rigid_body(mass:... | {
"valid": true,
"unknown_var": "final_speed_object"
} |
Rigid Body Dynamics | A construction crane is carefully lowering a large structural beam. The beam, which has a mass of 750 kg, starts from rest. The steel cable supporting the beam unwinds from a uniform solid cylindrical spool mounted on the crane. This spool has a mass of 200 kg and a radius of 0.8 meters. If the beam is lowered vertical... | 20.80370442125774 | fids=[10_I,10_T,7_A,8_C]|unknown=final_speed_beam | [
"10_I",
"8_C",
"7_A",
"10_T"
] | final_speed_beam | {
"mass_beam": {
"value": 750,
"unit": "kg"
},
"mass_spool": {
"value": 200,
"unit": "kg"
},
"radius_spool": {
"value": 0.8,
"unit": "m"
},
"height_lowered": {
"value": 25,
"unit": "m"
},
"gravity": {
"value": 9.81,
"unit": "m/s²"
},
"final_speed_beam": {
... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
"""Calculates the moment of inertia of a uniform solid cylinder about its central axis.
Parameters:
mass (float): The mass (M) of the cylinder in kilograms (kg).
radius (float): The radius (R) of the cy... | {
"valid": true,
"unknown_var": "final_speed_beam"
} |
Rigid Body Dynamics | An elevator system utilizes a large, solid cylindrical pulley located at the top of the building. A counterweight descends, unwinding a cable from the pulley and causing it to rotate. The pulley has a mass of 250.0 kg and a radius of 1.5 meters. Initially at rest, a constant net external torque of 800.0 N·m acts on the... | 42.66666666666667 | fids=[10_I,10_O,8_C,8_R]|unknown=v | [
"10_I",
"10_O",
"8_R",
"8_C"
] | v | {
"m": {
"value": 250,
"unit": "kg"
},
"r": {
"value": 1.5,
"unit": "m"
},
"angular_velocity_omega": {
"value": 0,
"unit": "rad/s"
},
"v": {
"value": null,
"unit": "m/s"
}
} | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_angular_acceleration_from_torque(net_torque: float, moment_of_inertia: float) -> float:
if moment_of_inertia == 0:
return float('inf')
return net_torque / mom... | {
"valid": true,
"unknown_var": "v"
} |
Rigid Body Dynamics | In a modern elevator system, a solid cylindrical pulley with a mass of 150.0 kg and a radius of 0.6 m is situated at the top of the building. A counterweight of mass 300.0 kg starts from rest at the top of its shaft and descends a vertical distance of 25.0 m. Assuming the cable does not slip on the pulley and ignoring ... | 19.809088823063014 | fids=[10_I,10_P,7_A,7_C,8_C]|unknown=speed_counterweight | [
"10_I",
"8_C",
"7_A",
"10_P",
"7_C"
] | speed_counterweight | {
"mass_pulley": {
"value": 150,
"unit": "kg"
},
"radius_pulley": {
"value": 0.6000000000000001,
"unit": "m"
},
"mass_counterweight": {
"value": 300,
"unit": "kg"
},
"height_descended": {
"value": 25,
"unit": "m"
},
"gravity": {
"value": 9.81,
"unit": "m/s^2"
... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_work_done_constant_force(force_magnit... | {
"valid": true,
"unknown_var": "speed_counterweight"
} |
Rigid Body Dynamics | A physics experiment is set up with two blocks connected by a light, inextensible string. Block A, with a mass of 5.0 kg, hangs vertically over the edge of a frictionless table. The string passes over a massive solid cylindrical pulley, which has a mass of 3.0 kg and a radius of 0.15 m, before connecting to Block B, wh... | 2.671056992006246 | fids=[10_I,10_P,7_A,7_C,8_C]|unknown=final_speed | [
"10_I",
"8_C",
"7_A",
"7_C",
"10_P"
] | final_speed | {
"mass_hanging": {
"value": 5,
"unit": "kg"
},
"mass_table": {
"value": 10,
"unit": "kg"
},
"pulley_mass": {
"value": 3,
"unit": "kg"
},
"pulley_radius": {
"value": 0.15,
"unit": "m"
},
"drop_height": {
"value": 1.2,
"unit": "m"
},
"gravity": {
"value":... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_kinetic_energy_from_momentum(momentum... | {
"valid": true,
"unknown_var": "final_speed"
} |
Rigid Body Dynamics | A physics experiment involves a block (m1) of mass 2.5 kg hanging over the edge of a frictionless table. It is connected by a light, inextensible string that passes over a massive, solid cylindrical pulley to a second block (m2) of unknown mass resting on the table. The pulley has a mass of 10.0 kg and a radius of 0.25... | 18.66 | fids=[10_I,10_P,7_A,8_C]|unknown=m2 | [
"10_I",
"8_C",
"10_P",
"7_A"
] | m2 | {
"m1": {
"value": 2.5,
"unit": "kg"
},
"M_pulley": {
"value": 10,
"unit": "kg"
},
"R_pulley": {
"value": 0.25,
"unit": "m"
},
"h": {
"value": 1.2,
"unit": "m"
},
"v": {
"value": 1.5,
"unit": "m/s"
},
"g": {
"value": 9.81,
"unit": "m/s²"
},
"m2":... | import math
# import numpy as np # only if needed
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculat... | {
"valid": true,
"unknown_var": "m2"
} |
Rigid Body Dynamics | A seasoned climber, with a mass of 75.0 kg, is rappelling down a sheer rock face. She uses a safety rope that unwinds from a heavy cylindrical reel securely anchored at the top. The reel has a mass of 20.0 kg and a radius of 0.25 m. Starting from rest, the climber descends a vertical distance of 40.0 meters. At the end... | -29047.5 | fids=[10_I,10_P,7_C,7_F,8_C]|unknown=work_non_conservative | [
"10_I",
"8_C",
"7_C",
"10_P",
"7_F"
] | work_non_conservative | {
"m_person": {
"value": 75,
"unit": "kg"
},
"m_reel": {
"value": 20,
"unit": "kg"
},
"R_reel": {
"value": 0.25,
"unit": "m"
},
"h": {
"value": 40,
"unit": "m"
},
"angular_velocity_omega": {
"value": 12,
"unit": "rad/s"
},
"g": {
"value": 9.81,
"unit... | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_kinetic_energy_from_momentum(momentum... | {
"valid": true,
"unknown_var": "work_non_conservative"
} |
Rigid Body Dynamics | A seasoned rock climber, with a mass of 80.0 kg, is rappelling down a cliff. She descends a vertical distance of 25.0 meters. The safety rope unwinds from a solid cylindrical reel securely anchored at the top of the cliff. The reel has a mass of 10.0 kg and a radius of 0.15 m. Assuming no friction in the reel's bearing... | 21.485973536787423 | fids=[10_I,10_P,7_A,7_F,8_C]|unknown=v | [
"10_I",
"8_C",
"7_A",
"10_P",
"7_F"
] | v | {
"m_person": {
"value": 80,
"unit": "kg"
},
"h": {
"value": 25,
"unit": "m"
},
"m_reel": {
"value": 10,
"unit": "kg"
},
"r": {
"value": 0.15,
"unit": "m"
},
"g": {
"value": 9.81,
"unit": "m/s^2"
},
"v": {
"value": null,
"unit": "m/s"
}
} | import math
def calculate_inertia_solid_cylinder_axis(mass: float, radius: float) -> float:
return (1 / 2) * mass * radius**2
def calculate_linear_speed_from_angular_velocity(radius: float, angular_velocity: float) -> float:
return radius * angular_velocity
def calculate_work_done_constant_force(force_magnit... | {
"valid": true,
"unknown_var": "v"
} |
Rigid Body Dynamics | A talented figure skater, whose body has an intrinsic moment of inertia of 2.5 kg·m² about a vertical axis, is performing a spin on a frictionless ice surface. She holds two identical small weights, each with a mass of 0.5 kg. Initially, her arms are tucked in, and each weight is effectively at a distance of 0.4 meters... | 0.985 | fids=[10_A,10_P,10_R]|unknown=Moment of Inertia of the system | [
"10_A",
"10_R",
"10_P"
] | Moment of Inertia of the system | {
"m1": {
"value": 0.5,
"unit": "kg"
},
"r1": {
"value": 0.4,
"unit": "m"
},
"m2": {
"value": 0.5,
"unit": "kg"
},
"r2": {
"value": 1.2,
"unit": "m"
},
"Moment of Inertia of the system": {
"value": null,
"unit": "kg·m²"
}
} | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_rotational_kinetic_energy(moment... | {
"valid": true,
"unknown_var": "Moment of Inertia of the system"
} |
Rigid Body Dynamics | An astronaut, whose body has a mass of 70.0 kg, is performing a controlled spin in the vacuum of space. When her limbs are somewhat tucked, her effective radius of mass distribution relative to the axis of rotation is 0.3 m. She extends her arms to hold two tools. The first tool has a mass of 5.0 kg and is held at a di... | 13.42125 | fids=[10_A,10_M,10_P]|unknown=rotational_kinetic_energy | [
"10_A",
"10_M",
"10_P"
] | rotational_kinetic_energy | {
"mass_astronaut": {
"value": 70,
"unit": "kg"
},
"effective_radius_astronaut": {
"value": 0.30000000000000004,
"unit": "m"
},
"mass_tool_1": {
"value": 5,
"unit": "kg"
},
"distance_tool_1": {
"value": 0.8,
"unit": "m"
},
"mass_tool_2": {
"value": 3,
"unit": "k... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_rotational_kinetic_energy(moment... | {
"valid": true,
"unknown_var": "rotational_kinetic_energy"
} |
Rigid Body Dynamics | An astronaut is performing a controlled spin in the vacuum of space. Her body, with a mass of 75.0 kg, can be approximated as a point mass with an effective radius of 0.35 m from her central axis of rotation. She is holding a compact tool, which has a mass of 5.0 kg, at a distance of 0.80 m from the same axis. If the t... | 64.58123107971745 | fids=[10_A,10_P,10_R]|unknown=rotational_kinetic_energy | [
"10_A",
"10_R",
"10_P"
] | rotational_kinetic_energy | {
"masses": {
"value": [
75,
5
],
"unit": "kg"
},
"radii": {
"value": [
0.35000000000000003,
0.8
],
"unit": "m"
},
"angular_momentum": {
"value": 40,
"unit": "kg·m²/s"
},
"rotational_kinetic_energy": {
"value": null,
"unit": "J"
}
} | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_rotational_kinetic_energy(moment... | {
"valid": true,
"unknown_var": "rotational_kinetic_energy"
} |
Rigid Body Dynamics | An engineer is designing a balancing mechanism for a high-precision rotating platform used in advanced manufacturing. To ensure smooth operation and minimize vibrations, she affixes two counterweights to the platform. The first counterweight has a mass of 0.5 kg and is strategically placed 0.2 meters from the central a... | 49.99999999999999 | fids=[10_A,10_P]|unknown=angular_velocity | [
"10_A",
"10_P"
] | angular_velocity | {
"m1": {
"value": 0.5,
"unit": "kg"
},
"r1": {
"value": 0.2,
"unit": "m"
},
"m2": {
"value": 0.8,
"unit": "kg"
},
"r2": {
"value": 0.15,
"unit": "m"
},
"rotational_kinetic_energy": {
"value": 47.5,
"unit": "J"
},
"angular_velocity": {
"value": null,
... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_rotational_kinetic_energy(moment... | {
"valid": true,
"unknown_var": "angular_velocity"
} |
Rigid Body Dynamics | Consider a simplified model of a diatomic molecule represented by two point masses connected by a rigid, massless rod. The first atom has a mass of 0.005 kg, and the second atom has a mass of 0.012 kg. The total length of the rigid rod connecting the two atoms is 0.25 m. This 'molecule' rotates about an axis perpendicu... | 0.0033088235294117647 | fids=[10_A,10_R,9_B]|unknown=angular_momentum | [
"9_B",
"10_A",
"10_R"
] | angular_momentum | {
"mass_1": {
"value": 0.005,
"unit": "kg"
},
"mass_2": {
"value": 0.012,
"unit": "kg"
},
"total_distance": {
"value": 0.25,
"unit": "m"
},
"angular_velocity": {
"value": 15,
"unit": "rad/s"
},
"angular_momentum": {
"value": null,
"unit": "kg·m^2/s"
}
} | import math
def calculate_com_distances_two_masses(mass_1: float, mass_2: float, total_distance: float) -> tuple[float, float]:
total_mass = mass_1 + mass_2
if total_mass == 0:
return (0.0, 0.0)
distance_from_m1 = (mass_2 * total_distance) / total_mass
distance_from_m2 = (mass_1 * total_distanc... | {
"valid": true,
"unknown_var": "angular_momentum"
} |
Rigid Body Dynamics | A simplified model of a diatomic molecule consists of two point masses connected by a rigid, massless bond. The first atom has a mass of 12.0 kg, and the second atom has a mass of 16.0 kg. The total length of the bond connecting the two atoms is 0.5 meters. If the molecule rotates about an axis perpendicular to the bon... | 0.24743582965269675 | fids=[10_A,10_M,9_B]|unknown=radius_of_gyration | [
"9_B",
"10_A",
"10_M"
] | radius_of_gyration | {
"mass_atom_1": {
"value": 12,
"unit": "kg"
},
"mass_atom_2": {
"value": 16,
"unit": "kg"
},
"bond_length": {
"value": 0.5,
"unit": "m"
},
"radius_of_gyration": {
"value": null,
"unit": "m"
}
} | import math
def calculate_com_distances_two_masses(mass_1: float, mass_2: float, total_distance: float) -> tuple[float, float]:
total_mass = mass_1 + mass_2
if total_mass == 0:
return (0.0, 0.0)
distance_from_m1 = (mass_2 * total_distance) / total_mass
distance_from_m2 = (mass_1 * total_distanc... | {
"valid": true,
"unknown_var": "radius_of_gyration"
} |
Rigid Body Dynamics | A child is playing with a homemade mobile, which consists of two decorative objects suspended from a central pivot. The first object has a mass of 0.15 kg and is suspended at a distance of 0.30 m from the pivot. The second object has a mass of 0.25 kg and is suspended at a distance of 0.50 m from the pivot. The child d... | 1.3157894736842106 | fids=[10_A,10_N,10_O]|unknown=angular_acceleration | [
"10_A",
"10_N",
"10_O"
] | angular_acceleration | {
"m1": {
"value": 0.15,
"unit": "kg"
},
"r1": {
"value": 0.30000000000000004,
"unit": "m"
},
"m2": {
"value": 0.25,
"unit": "kg"
},
"r2": {
"value": 0.5,
"unit": "m"
},
"force_magnitude": {
"value": 0.5,
"unit": "N"
},
"lever_arm": {
"value": 0.2,
"... | import math
def calculate_moment_of_inertia_discrete(masses: list[float], radii: list[float]) -> float:
if len(masses) != len(radii):
raise ValueError("Masses and radii lists must have the same length.")
return sum(m * r**2 for m, r in zip(masses, radii))
def calculate_torque_magnitude(force_magnitude... | {
"valid": true,
"unknown_var": "angular_acceleration"
} |
End of preview. Expand in Data Studio
YAML Metadata Warning:empty or missing yaml metadata in repo card
Check out the documentation for more information.
Thanks for going through our work!
Update: ArXiv Preprint for our Data Generation Methodology for High Complexity Problems is out! "Infinite Problem Generator: Verifiably Scaling Physics Reasoning Data with Agentic Workflows" https://arxiv.org/abs/2603.14486
PS: We just saw that this dataset has started getting some downloads. There are also some variations of it which RL/SFT etc. It just makes us really happy to see the community engage so directly with our work. I guess we really did something alteast slightly impactful :)
Btw, a lot of stuff is in the works. Stay tuned for exciting open-science updates ahead (wink wink)
If you are interested in more details, like the methods behind this Synthetic Dataset Generation Please go through the README at: https://github.com/er-ads/ProblemGenerationAgent
- Downloads last month
- 22