Upload folder using huggingface_hub (part 12)

scipy/compound_atwood/277/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4f39a6b15286240ba376082d91eb7f075c1a2e605684daf0f61cbbf3b47b030
+size 8540

scipy/compound_atwood/284/cot.json

@@ -0,0 +1,150 @@
+{
+  "simulation": "compound_atwood",
+  "physical_observation": "Compound (double) Atwood machine: a fixed pulley A on the ceiling carries a string with mass m1=2.444 kg on one side and the axle of a movable pulley B on the other. A rope over B carries mass m2=1.909 kg and m3=1.649 kg. Gravity g=9.800 m/s^2 drives the system; all motions start from rest.",
+  "physical_law": {
+    "name": "Newton II + massless inextensible-cord constraints + massless pulleys",
+    "statement": "Each mass obeys m_i \\ddot{y}_i = m_i g - T_i; the cord constraints couple accelerations; a massless movable pulley enforces T_A = 2 T_B.",
+    "formula": "T_B = 4 g / (1/m2 + 1/m3 + 4/m1); T_A = 2 T_B; a_i = g - T_i/m_i; a_B = -a_1."
+  },
+  "ode_system": {
+    "state_variables": [
+      "y1, y2, y3 (cube depths, m, +y down)",
+      "yB (movable pulley depth)"
+    ],
+    "equations_latex": [
+      "\\dot{y}_i = v_i; \\dot{v}_i = a_i (constants)",
+      "a1 = -1.793729; a2 = 2.379439; a3 = 1.208019; aB = 1.793729"
+    ],
+    "equations_python": [
+      "y_dot_i = v_i; v_dot_i = a_i (constants)",
+      "a1 = -1.793729; a2 = 2.379439; a3 = 1.208019; aB = 1.793729"
+    ]
+  },
+  "derivation_steps": [
+    "Massless movable pulley B: tension balance gives T_A = 2 T_B (so T_A = 28.3344 N, T_B = 14.1672 N).",
+    "Constraint on string A:  y1 + yB = const  =>  \\ddot{y}1 + \\ddot{y}B = 0  =>  a_B = -a_1.",
+    "Constraint on rope B:  (y2 - yB) + (y3 - yB) = const  =>  a_2 + a_3 - 2 a_B = 0.",
+    "Newton II for each mass (down = +): m_i \\ddot{y}_i = m_i g - T_i (T_1 = T_A on m1; T_2 = T_3 = T_B on m2, m3).",
+    "Solving the linear system yields T_B = 4 g / (1/m2 + 1/m3 + 4/m1).",
+    "Therefore a_1 = -1.7937 m/s^2, a_2 = +2.3794, a_3 = +1.2080, a_B = +1.7937."
+  ],
+  "physical_constants_derived": {
+    "T_A_N": 28.334408699039933,
+    "T_B_N": 14.167204349519967,
+    "a_1_m_s2": -1.7937289008575554,
+    "a_2_m_s2": 2.379439052696598,
+    "a_3_m_s2": 1.2080187490185104,
+    "a_B_m_s2": 1.7937289008575554
+  },
+  "numerical_method": {
+    "solver": "Closed form (constant accelerations); positions are quadratic in t. No ODE integrator required.",
+    "tolerance": "Machine precision.",
+    "justification": "All four accelerations are time-independent, so y_i(t) = y_i_0 + v_i_0 t + 0.5 a_i t^2."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for three point masses with two cord constraints and a tension ratio T_A=2 T_B.",
+    "energy_check": "\\SigmaKE - \\SigmaPE evolves consistent with constant accelerations (no friction).",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Mass with the largest a_i descends fastest. a_1, a_2, a_3, a_B = -1.794, +2.379, +1.208, +1.794 m/s^2.",
+    "Motion stops in the render once the descender reaches the floor."
+  ],
+  "parameters": {
+    "m1": {
+      "value": 2.44394266429191,
+      "unit": "",
+      "description": ""
+    },
+    "m2": {
+      "value": 1.909182398760334,
+      "unit": "",
+      "description": ""
+    },
+    "m3": {
+      "value": 1.6488867859088496,
+      "unit": "",
+      "description": ""
+    },
+    "g": {
+      "value": 9.8,
+      "unit": "",
+      "description": ""
+    },
+    "x_A": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_B": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "cube_side": {
+      "value": 0.45,
+      "unit": "",
+      "description": ""
+    },
+    "x_m1": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_m2": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_m3": {
+      "value": 3.0,
+      "unit": "",
+      "description": ""
+    },
+    "y1_0": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "y2_0": {
+      "value": 5.0,
+      "unit": "",
+      "description": ""
+    },
+    "y3_0": {
+      "value": 3.5,
+      "unit": "",
+      "description": ""
+    },
+    "yB_0": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "v1_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v2_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v3_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "vB_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/compound_atwood/284/params.json

@@ -0,0 +1,21 @@
+{
+  "m1": 2.44394266429191,
+  "m2": 1.909182398760334,
+  "m3": 1.6488867859088496,
+  "g": 9.8,
+  "x_A": 2.0,
+  "x_B": 2.5,
+  "r_pulley": 0.5,
+  "cube_side": 0.45,
+  "x_m1": 1.5,
+  "x_m2": 2.0,
+  "x_m3": 3.0,
+  "y1_0": 1.5,
+  "y2_0": 5.0,
+  "y3_0": 3.5,
+  "yB_0": 2.5,
+  "v1_0": 0.0,
+  "v2_0": 0.0,
+  "v3_0": 0.0,
+  "vB_0": 0.0
+}

scipy/compound_atwood/284/simulation_code.py

@@ -0,0 +1,112 @@
+"""
+Compound Atwood machine — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import matplotlib.patches as patches
+
+m1, m2, m3 = 2.44394266429191, 1.909182398760334, 1.6488867859088496
+g = 9.8
+r_pulley = 0.5
+cube_side = 0.45
+x_A, x_B = 2.0, 2.5
+x_m1, x_m2, x_m3 = 1.5, 2.0, 3.0
+y1_0 = 1.5; y2_0 = 5.0; y3_0 = 3.5; yB_0 = 2.5
+v1_0 = 0.0; v2_0 = 0.0; v3_0 = 0.0; vB_0 = 0.0
+duration = 12
+fps = 30
+
+T_B = 4.0 * g / (1.0/m2 + 1.0/m3 + 4.0/m1)
+T_A = 2.0 * T_B
+a1 = g - T_A/m1
+a2 = g - T_B/m2
+a3 = g - T_B/m3
+aB = -a1
+
+y_floor = max(y1_0, y2_0, y3_0) + 2.5
+y_A = r_pulley + 0.05
+
+n_frames = int(duration * fps) + 1
+t_grid = np.linspace(0, duration, n_frames)
+y1 = y1_0 + v1_0 * t_grid + 0.5 * a1 * t_grid ** 2
+y2 = y2_0 + v2_0 * t_grid + 0.5 * a2 * t_grid ** 2
+y3 = y3_0 + v3_0 * t_grid + 0.5 * a3 * t_grid ** 2
+yB = yB_0 + vB_0 * t_grid + 0.5 * aB * t_grid ** 2
+
+ok = ((y1 >= y_A) & (y2 >= yB + r_pulley) & (y3 >= yB + r_pulley)
+      & (yB >= r_pulley)
+      & (y1 + cube_side <= y_floor)
+      & (y2 + cube_side <= y_floor)
+      & (y3 + cube_side <= y_floor)
+      & (yB + r_pulley <= y_floor))
+if not ok.all():
+    first_bad = int(np.argmax(~ok))
+    last_good = max(first_bad - 1, 0)
+    y1[first_bad:] = y1[last_good]
+    y2[first_bad:] = y2[last_good]
+    y3[first_bad:] = y3[last_good]
+    yB[first_bad:] = yB[last_good]
+
+y_A = r_pulley + 0.05
+y_floor_render = max(y1.max(), y2.max(), y3.max()) + cube_side + 0.5
+
+fig_w, fig_h = 5.0, 8.0
+fig_aspect = fig_w / fig_h
+x_lo_d = min(x_m1, x_m2, x_m3) - cube_side/2 - 0.4
+x_hi_d = max(x_m1, x_m2, x_m3) + cube_side/2 + 0.4
+y_lo_d = -0.4
+y_hi_d = y_floor_render + 0.4
+dx, dy = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx/dy < fig_aspect:
+    extra = (fig_aspect * dy - dx) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d - extra, x_hi_d + extra, y_lo_d, y_hi_d
+else:
+    extra = (dx/fig_aspect - dy) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d, x_hi_d, y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_hi, y_lo)
+ax.set_aspect("equal"); ax.axis("off")
+
+ax.add_patch(patches.Rectangle((x_lo, y_lo), x_hi - x_lo, -y_lo, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0, 0], color="#adb5bd", lw=2.5, zorder=2)
+ax.add_patch(patches.Rectangle((x_lo, y_floor_render), x_hi - x_lo, y_hi - y_floor_render, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [y_floor_render, y_floor_render], color="#adb5bd", lw=2.5, zorder=2)
+
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4))
+ax.plot([x_A, x_A], [0, y_A - r_pulley], color="#adb5bd", lw=2.5, zorder=3)
+ax.add_patch(patches.Arc((x_A, y_A), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5))
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6))
+
+pulley_B_body = patches.Circle((x_B, yB_0), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4)
+arc_B = patches.Arc((x_B, yB_0), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5)
+hub_B = patches.Circle((x_B, yB_0), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6)
+ax.add_patch(pulley_B_body); ax.add_patch(arc_B); ax.add_patch(hub_B)
+
+cube1 = patches.Rectangle((x_m1 - cube_side/2, y1_0), cube_side, cube_side, facecolor="#e63946", edgecolor="white", lw=1.5, zorder=7)
+cube2 = patches.Rectangle((x_m2 - cube_side/2, y2_0), cube_side, cube_side, facecolor="#f4d35e", edgecolor="white", lw=1.5, zorder=7)
+cube3 = patches.Rectangle((x_m3 - cube_side/2, y3_0), cube_side, cube_side, facecolor="#a8dadc", edgecolor="white", lw=1.5, zorder=7)
+ax.add_patch(cube1); ax.add_patch(cube2); ax.add_patch(cube3)
+
+str_A_left,  = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+str_A_right, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_left, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_right,= ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+
+def update(f):
+    y1f, y2f, y3f, yBf = y1[f], y2[f], y3[f], yB[f]
+    cube1.set_y(y1f); cube2.set_y(y2f); cube3.set_y(y3f)
+    pulley_B_body.center = (x_B, yBf)
+    hub_B.center = (x_B, yBf)
+    arc_B.set_center((x_B, yBf))
+    str_A_left.set_data([x_A - r_pulley, x_A - r_pulley], [y_A, y1f])
+    str_A_right.set_data([x_A + r_pulley, x_B], [y_A, yBf - r_pulley])
+    rope_B_left.set_data([x_B - r_pulley, x_B - r_pulley], [yBf, y2f])
+    rope_B_right.set_data([x_B + r_pulley, x_B + r_pulley], [yBf, y3f])
+    return cube1, cube2, cube3, pulley_B_body, hub_B, arc_B, str_A_left, str_A_right, rope_B_left, rope_B_right
+
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000/fps, blit=True)
+ani.save("compound_atwood.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved compound_atwood.mp4")

scipy/compound_atwood/284/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cce51920bf6542989aba203366a49fd35675b4c0f58f94e7cbe460ff2c907a1
+size 7823

scipy/compound_atwood/296/cot.json

@@ -0,0 +1,150 @@
+{
+  "simulation": "compound_atwood",
+  "physical_observation": "Compound (double) Atwood machine: a fixed pulley A on the ceiling carries a string with mass m1=2.256 kg on one side and the axle of a movable pulley B on the other. A rope over B carries mass m2=1.713 kg and m3=1.241 kg. Gravity g=9.800 m/s^2 drives the system; all motions start from rest.",
+  "physical_law": {
+    "name": "Newton II + massless inextensible-cord constraints + massless pulleys",
+    "statement": "Each mass obeys m_i \\ddot{y}_i = m_i g - T_i; the cord constraints couple accelerations; a massless movable pulley enforces T_A = 2 T_B.",
+    "formula": "T_B = 4 g / (1/m2 + 1/m3 + 4/m1); T_A = 2 T_B; a_i = g - T_i/m_i; a_B = -a_1."
+  },
+  "ode_system": {
+    "state_variables": [
+      "y1, y2, y3 (cube depths, m, +y down)",
+      "yB (movable pulley depth)"
+    ],
+    "equations_latex": [
+      "\\dot{y}_i = v_i; \\dot{v}_i = a_i (constants)",
+      "a1 = -1.186310; a2 = 2.563555; a3 = -0.190935; aB = 1.186310"
+    ],
+    "equations_python": [
+      "y_dot_i = v_i; v_dot_i = a_i (constants)",
+      "a1 = -1.186310; a2 = 2.563555; a3 = -0.190935; aB = 1.186310"
+    ]
+  },
+  "derivation_steps": [
+    "Massless movable pulley B: tension balance gives T_A = 2 T_B (so T_A = 24.7899 N, T_B = 12.3950 N).",
+    "Constraint on string A:  y1 + yB = const  =>  \\ddot{y}1 + \\ddot{y}B = 0  =>  a_B = -a_1.",
+    "Constraint on rope B:  (y2 - yB) + (y3 - yB) = const  =>  a_2 + a_3 - 2 a_B = 0.",
+    "Newton II for each mass (down = +): m_i \\ddot{y}_i = m_i g - T_i (T_1 = T_A on m1; T_2 = T_3 = T_B on m2, m3).",
+    "Solving the linear system yields T_B = 4 g / (1/m2 + 1/m3 + 4/m1).",
+    "Therefore a_1 = -1.1863 m/s^2, a_2 = +2.5636, a_3 = -0.1909, a_B = +1.1863."
+  ],
+  "physical_constants_derived": {
+    "T_A_N": 24.789919133158584,
+    "T_B_N": 12.394959566579292,
+    "a_1_m_s2": -1.1863099226324891,
+    "a_2_m_s2": 2.563555066819448,
+    "a_3_m_s2": -0.1909352215544704,
+    "a_B_m_s2": 1.1863099226324891
+  },
+  "numerical_method": {
+    "solver": "Closed form (constant accelerations); positions are quadratic in t. No ODE integrator required.",
+    "tolerance": "Machine precision.",
+    "justification": "All four accelerations are time-independent, so y_i(t) = y_i_0 + v_i_0 t + 0.5 a_i t^2."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for three point masses with two cord constraints and a tension ratio T_A=2 T_B.",
+    "energy_check": "\\SigmaKE - \\SigmaPE evolves consistent with constant accelerations (no friction).",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Mass with the largest a_i descends fastest. a_1, a_2, a_3, a_B = -1.186, +2.564, -0.191, +1.186 m/s^2.",
+    "Motion stops in the render once the descender reaches the floor."
+  ],
+  "parameters": {
+    "m1": {
+      "value": 2.256437266719537,
+      "unit": "",
+      "description": ""
+    },
+    "m2": {
+      "value": 1.7128520538788201,
+      "unit": "",
+      "description": ""
+    },
+    "m3": {
+      "value": 1.2406205517015436,
+      "unit": "",
+      "description": ""
+    },
+    "g": {
+      "value": 9.8,
+      "unit": "",
+      "description": ""
+    },
+    "x_A": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_B": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "cube_side": {
+      "value": 0.45,
+      "unit": "",
+      "description": ""
+    },
+    "x_m1": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_m2": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_m3": {
+      "value": 3.0,
+      "unit": "",
+      "description": ""
+    },
+    "y1_0": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "y2_0": {
+      "value": 5.0,
+      "unit": "",
+      "description": ""
+    },
+    "y3_0": {
+      "value": 3.5,
+      "unit": "",
+      "description": ""
+    },
+    "yB_0": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "v1_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v2_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v3_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "vB_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/compound_atwood/296/params.json

@@ -0,0 +1,21 @@
+{
+  "m1": 2.256437266719537,
+  "m2": 1.7128520538788201,
+  "m3": 1.2406205517015436,
+  "g": 9.8,
+  "x_A": 2.0,
+  "x_B": 2.5,
+  "r_pulley": 0.5,
+  "cube_side": 0.45,
+  "x_m1": 1.5,
+  "x_m2": 2.0,
+  "x_m3": 3.0,
+  "y1_0": 1.5,
+  "y2_0": 5.0,
+  "y3_0": 3.5,
+  "yB_0": 2.5,
+  "v1_0": 0.0,
+  "v2_0": 0.0,
+  "v3_0": 0.0,
+  "vB_0": 0.0
+}

scipy/compound_atwood/296/simulation_code.py

@@ -0,0 +1,112 @@
+"""
+Compound Atwood machine — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import matplotlib.patches as patches
+
+m1, m2, m3 = 2.256437266719537, 1.7128520538788201, 1.2406205517015436
+g = 9.8
+r_pulley = 0.5
+cube_side = 0.45
+x_A, x_B = 2.0, 2.5
+x_m1, x_m2, x_m3 = 1.5, 2.0, 3.0
+y1_0 = 1.5; y2_0 = 5.0; y3_0 = 3.5; yB_0 = 2.5
+v1_0 = 0.0; v2_0 = 0.0; v3_0 = 0.0; vB_0 = 0.0
+duration = 12
+fps = 30
+
+T_B = 4.0 * g / (1.0/m2 + 1.0/m3 + 4.0/m1)
+T_A = 2.0 * T_B
+a1 = g - T_A/m1
+a2 = g - T_B/m2
+a3 = g - T_B/m3
+aB = -a1
+
+y_floor = max(y1_0, y2_0, y3_0) + 2.5
+y_A = r_pulley + 0.05
+
+n_frames = int(duration * fps) + 1
+t_grid = np.linspace(0, duration, n_frames)
+y1 = y1_0 + v1_0 * t_grid + 0.5 * a1 * t_grid ** 2
+y2 = y2_0 + v2_0 * t_grid + 0.5 * a2 * t_grid ** 2
+y3 = y3_0 + v3_0 * t_grid + 0.5 * a3 * t_grid ** 2
+yB = yB_0 + vB_0 * t_grid + 0.5 * aB * t_grid ** 2
+
+ok = ((y1 >= y_A) & (y2 >= yB + r_pulley) & (y3 >= yB + r_pulley)
+      & (yB >= r_pulley)
+      & (y1 + cube_side <= y_floor)
+      & (y2 + cube_side <= y_floor)
+      & (y3 + cube_side <= y_floor)
+      & (yB + r_pulley <= y_floor))
+if not ok.all():
+    first_bad = int(np.argmax(~ok))
+    last_good = max(first_bad - 1, 0)
+    y1[first_bad:] = y1[last_good]
+    y2[first_bad:] = y2[last_good]
+    y3[first_bad:] = y3[last_good]
+    yB[first_bad:] = yB[last_good]
+
+y_A = r_pulley + 0.05
+y_floor_render = max(y1.max(), y2.max(), y3.max()) + cube_side + 0.5
+
+fig_w, fig_h = 5.0, 8.0
+fig_aspect = fig_w / fig_h
+x_lo_d = min(x_m1, x_m2, x_m3) - cube_side/2 - 0.4
+x_hi_d = max(x_m1, x_m2, x_m3) + cube_side/2 + 0.4
+y_lo_d = -0.4
+y_hi_d = y_floor_render + 0.4
+dx, dy = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx/dy < fig_aspect:
+    extra = (fig_aspect * dy - dx) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d - extra, x_hi_d + extra, y_lo_d, y_hi_d
+else:
+    extra = (dx/fig_aspect - dy) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d, x_hi_d, y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_hi, y_lo)
+ax.set_aspect("equal"); ax.axis("off")
+
+ax.add_patch(patches.Rectangle((x_lo, y_lo), x_hi - x_lo, -y_lo, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0, 0], color="#adb5bd", lw=2.5, zorder=2)
+ax.add_patch(patches.Rectangle((x_lo, y_floor_render), x_hi - x_lo, y_hi - y_floor_render, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [y_floor_render, y_floor_render], color="#adb5bd", lw=2.5, zorder=2)
+
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4))
+ax.plot([x_A, x_A], [0, y_A - r_pulley], color="#adb5bd", lw=2.5, zorder=3)
+ax.add_patch(patches.Arc((x_A, y_A), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5))
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6))
+
+pulley_B_body = patches.Circle((x_B, yB_0), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4)
+arc_B = patches.Arc((x_B, yB_0), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5)
+hub_B = patches.Circle((x_B, yB_0), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6)
+ax.add_patch(pulley_B_body); ax.add_patch(arc_B); ax.add_patch(hub_B)
+
+cube1 = patches.Rectangle((x_m1 - cube_side/2, y1_0), cube_side, cube_side, facecolor="#e63946", edgecolor="white", lw=1.5, zorder=7)
+cube2 = patches.Rectangle((x_m2 - cube_side/2, y2_0), cube_side, cube_side, facecolor="#f4d35e", edgecolor="white", lw=1.5, zorder=7)
+cube3 = patches.Rectangle((x_m3 - cube_side/2, y3_0), cube_side, cube_side, facecolor="#a8dadc", edgecolor="white", lw=1.5, zorder=7)
+ax.add_patch(cube1); ax.add_patch(cube2); ax.add_patch(cube3)
+
+str_A_left,  = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+str_A_right, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_left, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_right,= ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+
+def update(f):
+    y1f, y2f, y3f, yBf = y1[f], y2[f], y3[f], yB[f]
+    cube1.set_y(y1f); cube2.set_y(y2f); cube3.set_y(y3f)
+    pulley_B_body.center = (x_B, yBf)
+    hub_B.center = (x_B, yBf)
+    arc_B.set_center((x_B, yBf))
+    str_A_left.set_data([x_A - r_pulley, x_A - r_pulley], [y_A, y1f])
+    str_A_right.set_data([x_A + r_pulley, x_B], [y_A, yBf - r_pulley])
+    rope_B_left.set_data([x_B - r_pulley, x_B - r_pulley], [yBf, y2f])
+    rope_B_right.set_data([x_B + r_pulley, x_B + r_pulley], [yBf, y3f])
+    return cube1, cube2, cube3, pulley_B_body, hub_B, arc_B, str_A_left, str_A_right, rope_B_left, rope_B_right
+
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000/fps, blit=True)
+ani.save("compound_atwood.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved compound_atwood.mp4")

scipy/compound_atwood/296/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1973d99a57eacb6e7e61d2e2d3bb0a77e57e3a0ea3124c2a2537bc1a0ea6a53e
+size 7483

scipy/compound_atwood/299/cot.json

@@ -0,0 +1,150 @@
+{
+  "simulation": "compound_atwood",
+  "physical_observation": "Compound (double) Atwood machine: a fixed pulley A on the ceiling carries a string with mass m1=2.376 kg on one side and the axle of a movable pulley B on the other. A rope over B carries mass m2=0.848 kg and m3=1.121 kg. Gravity g=9.800 m/s^2 drives the system; all motions start from rest.",
+  "physical_law": {
+    "name": "Newton II + massless inextensible-cord constraints + massless pulleys",
+    "statement": "Each mass obeys m_i \\ddot{y}_i = m_i g - T_i; the cord constraints couple accelerations; a massless movable pulley enforces T_A = 2 T_B.",
+    "formula": "T_B = 4 g / (1/m2 + 1/m3 + 4/m1); T_A = 2 T_B; a_i = g - T_i/m_i; a_B = -a_1."
+  },
+  "ode_system": {
+    "state_variables": [
+      "y1, y2, y3 (cube depths, m, +y down)",
+      "yB (movable pulley depth)"
+    ],
+    "equations_latex": [
+      "\\dot{y}_i = v_i; \\dot{v}_i = a_i (constants)",
+      "a1 = 1.013799; a2 = -2.512182; a3 = 0.484585; aB = -1.013799"
+    ],
+    "equations_python": [
+      "y_dot_i = v_i; v_dot_i = a_i (constants)",
+      "a1 = 1.013799; a2 = -2.512182; a3 = 0.484585; aB = -1.013799"
+    ]
+  },
+  "derivation_steps": [
+    "Massless movable pulley B: tension balance gives T_A = 2 T_B (so T_A = 20.8799 N, T_B = 10.4400 N).",
+    "Constraint on string A:  y1 + yB = const  =>  \\ddot{y}1 + \\ddot{y}B = 0  =>  a_B = -a_1.",
+    "Constraint on rope B:  (y2 - yB) + (y3 - yB) = const  =>  a_2 + a_3 - 2 a_B = 0.",
+    "Newton II for each mass (down = +): m_i \\ddot{y}_i = m_i g - T_i (T_1 = T_A on m1; T_2 = T_3 = T_B on m2, m3).",
+    "Solving the linear system yields T_B = 4 g / (1/m2 + 1/m3 + 4/m1).",
+    "Therefore a_1 = +1.0138 m/s^2, a_2 = -2.5122, a_3 = +0.4846, a_B = -1.0138."
+  ],
+  "physical_constants_derived": {
+    "T_A_N": 20.87993613401704,
+    "T_B_N": 10.43996806700852,
+    "a_1_m_s2": 1.0137985734817132,
+    "a_2_m_s2": -2.5121818299273873,
+    "a_3_m_s2": 0.4845846829639662,
+    "a_B_m_s2": -1.0137985734817132
+  },
+  "numerical_method": {
+    "solver": "Closed form (constant accelerations); positions are quadratic in t. No ODE integrator required.",
+    "tolerance": "Machine precision.",
+    "justification": "All four accelerations are time-independent, so y_i(t) = y_i_0 + v_i_0 t + 0.5 a_i t^2."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for three point masses with two cord constraints and a tension ratio T_A=2 T_B.",
+    "energy_check": "\\SigmaKE - \\SigmaPE evolves consistent with constant accelerations (no friction).",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Mass with the largest a_i descends fastest. a_1, a_2, a_3, a_B = +1.014, -2.512, +0.485, -1.014 m/s^2.",
+    "Motion stops in the render once the descender reaches the floor."
+  ],
+  "parameters": {
+    "m1": {
+      "value": 2.37644632992339,
+      "unit": "",
+      "description": ""
+    },
+    "m2": {
+      "value": 0.8479380999419572,
+      "unit": "",
+      "description": ""
+    },
+    "m3": {
+      "value": 1.120719550519224,
+      "unit": "",
+      "description": ""
+    },
+    "g": {
+      "value": 9.8,
+      "unit": "",
+      "description": ""
+    },
+    "x_A": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_B": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "cube_side": {
+      "value": 0.45,
+      "unit": "",
+      "description": ""
+    },
+    "x_m1": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_m2": {
+      "value": 2.0,
+      "unit": "",
+      "description": ""
+    },
+    "x_m3": {
+      "value": 3.0,
+      "unit": "",
+      "description": ""
+    },
+    "y1_0": {
+      "value": 1.5,
+      "unit": "",
+      "description": ""
+    },
+    "y2_0": {
+      "value": 5.0,
+      "unit": "",
+      "description": ""
+    },
+    "y3_0": {
+      "value": 3.5,
+      "unit": "",
+      "description": ""
+    },
+    "yB_0": {
+      "value": 2.5,
+      "unit": "",
+      "description": ""
+    },
+    "v1_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v2_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "v3_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    },
+    "vB_0": {
+      "value": 0.0,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/compound_atwood/299/params.json

@@ -0,0 +1,21 @@
+{
+  "m1": 2.37644632992339,
+  "m2": 0.8479380999419572,
+  "m3": 1.120719550519224,
+  "g": 9.8,
+  "x_A": 2.0,
+  "x_B": 2.5,
+  "r_pulley": 0.5,
+  "cube_side": 0.45,
+  "x_m1": 1.5,
+  "x_m2": 2.0,
+  "x_m3": 3.0,
+  "y1_0": 1.5,
+  "y2_0": 5.0,
+  "y3_0": 3.5,
+  "yB_0": 2.5,
+  "v1_0": 0.0,
+  "v2_0": 0.0,
+  "v3_0": 0.0,
+  "vB_0": 0.0
+}

scipy/compound_atwood/299/simulation_code.py

@@ -0,0 +1,112 @@
+"""
+Compound Atwood machine — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import matplotlib.patches as patches
+
+m1, m2, m3 = 2.37644632992339, 0.8479380999419572, 1.120719550519224
+g = 9.8
+r_pulley = 0.5
+cube_side = 0.45
+x_A, x_B = 2.0, 2.5
+x_m1, x_m2, x_m3 = 1.5, 2.0, 3.0
+y1_0 = 1.5; y2_0 = 5.0; y3_0 = 3.5; yB_0 = 2.5
+v1_0 = 0.0; v2_0 = 0.0; v3_0 = 0.0; vB_0 = 0.0
+duration = 12
+fps = 30
+
+T_B = 4.0 * g / (1.0/m2 + 1.0/m3 + 4.0/m1)
+T_A = 2.0 * T_B
+a1 = g - T_A/m1
+a2 = g - T_B/m2
+a3 = g - T_B/m3
+aB = -a1
+
+y_floor = max(y1_0, y2_0, y3_0) + 2.5
+y_A = r_pulley + 0.05
+
+n_frames = int(duration * fps) + 1
+t_grid = np.linspace(0, duration, n_frames)
+y1 = y1_0 + v1_0 * t_grid + 0.5 * a1 * t_grid ** 2
+y2 = y2_0 + v2_0 * t_grid + 0.5 * a2 * t_grid ** 2
+y3 = y3_0 + v3_0 * t_grid + 0.5 * a3 * t_grid ** 2
+yB = yB_0 + vB_0 * t_grid + 0.5 * aB * t_grid ** 2
+
+ok = ((y1 >= y_A) & (y2 >= yB + r_pulley) & (y3 >= yB + r_pulley)
+      & (yB >= r_pulley)
+      & (y1 + cube_side <= y_floor)
+      & (y2 + cube_side <= y_floor)
+      & (y3 + cube_side <= y_floor)
+      & (yB + r_pulley <= y_floor))
+if not ok.all():
+    first_bad = int(np.argmax(~ok))
+    last_good = max(first_bad - 1, 0)
+    y1[first_bad:] = y1[last_good]
+    y2[first_bad:] = y2[last_good]
+    y3[first_bad:] = y3[last_good]
+    yB[first_bad:] = yB[last_good]
+
+y_A = r_pulley + 0.05
+y_floor_render = max(y1.max(), y2.max(), y3.max()) + cube_side + 0.5
+
+fig_w, fig_h = 5.0, 8.0
+fig_aspect = fig_w / fig_h
+x_lo_d = min(x_m1, x_m2, x_m3) - cube_side/2 - 0.4
+x_hi_d = max(x_m1, x_m2, x_m3) + cube_side/2 + 0.4
+y_lo_d = -0.4
+y_hi_d = y_floor_render + 0.4
+dx, dy = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx/dy < fig_aspect:
+    extra = (fig_aspect * dy - dx) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d - extra, x_hi_d + extra, y_lo_d, y_hi_d
+else:
+    extra = (dx/fig_aspect - dy) / 2.0
+    x_lo, x_hi, y_lo, y_hi = x_lo_d, x_hi_d, y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_hi, y_lo)
+ax.set_aspect("equal"); ax.axis("off")
+
+ax.add_patch(patches.Rectangle((x_lo, y_lo), x_hi - x_lo, -y_lo, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0, 0], color="#adb5bd", lw=2.5, zorder=2)
+ax.add_patch(patches.Rectangle((x_lo, y_floor_render), x_hi - x_lo, y_hi - y_floor_render, facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [y_floor_render, y_floor_render], color="#adb5bd", lw=2.5, zorder=2)
+
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4))
+ax.plot([x_A, x_A], [0, y_A - r_pulley], color="#adb5bd", lw=2.5, zorder=3)
+ax.add_patch(patches.Arc((x_A, y_A), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5))
+ax.add_patch(patches.Circle((x_A, y_A), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6))
+
+pulley_B_body = patches.Circle((x_B, yB_0), r_pulley, facecolor="#4a4e69", edgecolor="white", lw=1.6, zorder=4)
+arc_B = patches.Arc((x_B, yB_0), 2*r_pulley, 2*r_pulley, angle=0, theta1=180, theta2=360, color="#a8dadc", lw=2.5, zorder=5)
+hub_B = patches.Circle((x_B, yB_0), r_pulley * 0.18, facecolor="#1a1a2e", edgecolor="#adb5bd", lw=1.0, zorder=6)
+ax.add_patch(pulley_B_body); ax.add_patch(arc_B); ax.add_patch(hub_B)
+
+cube1 = patches.Rectangle((x_m1 - cube_side/2, y1_0), cube_side, cube_side, facecolor="#e63946", edgecolor="white", lw=1.5, zorder=7)
+cube2 = patches.Rectangle((x_m2 - cube_side/2, y2_0), cube_side, cube_side, facecolor="#f4d35e", edgecolor="white", lw=1.5, zorder=7)
+cube3 = patches.Rectangle((x_m3 - cube_side/2, y3_0), cube_side, cube_side, facecolor="#a8dadc", edgecolor="white", lw=1.5, zorder=7)
+ax.add_patch(cube1); ax.add_patch(cube2); ax.add_patch(cube3)
+
+str_A_left,  = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+str_A_right, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_left, = ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+rope_B_right,= ax.plot([], [], color="#a8dadc", lw=2.5, zorder=5)
+
+def update(f):
+    y1f, y2f, y3f, yBf = y1[f], y2[f], y3[f], yB[f]
+    cube1.set_y(y1f); cube2.set_y(y2f); cube3.set_y(y3f)
+    pulley_B_body.center = (x_B, yBf)
+    hub_B.center = (x_B, yBf)
+    arc_B.set_center((x_B, yBf))
+    str_A_left.set_data([x_A - r_pulley, x_A - r_pulley], [y_A, y1f])
+    str_A_right.set_data([x_A + r_pulley, x_B], [y_A, yBf - r_pulley])
+    rope_B_left.set_data([x_B - r_pulley, x_B - r_pulley], [yBf, y2f])
+    rope_B_right.set_data([x_B + r_pulley, x_B + r_pulley], [yBf, y3f])
+    return cube1, cube2, cube3, pulley_B_body, hub_B, arc_B, str_A_left, str_A_right, rope_B_left, rope_B_right
+
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000/fps, blit=True)
+ani.save("compound_atwood.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved compound_atwood.mp4")

scipy/compound_atwood/299/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a7a477e8d0fc66e0a06b83c050515e40cd1778480a342b5ae4711a759023fbc
+size 9970

scipy/conveyor_belt_drop/029/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.450 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.261 m/s rightward. Coulomb friction mu_belt=0.25272488955055605, mu_floor=0.3741802575064322 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 2.4792; ends when vx = v_belt = 1.2609200575127593",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -3.6707; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 2.4792; ends * when * vx = v_belt = 1.2609200575127593",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -3.6707; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.270 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2345 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 2.4792 m/s^2; t2 = v_belt/a = 0.5086 s; dx2 = 0.3206 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 0.9102 m -> t3 = 0.7219 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.5693 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 3.6707; t5 = 0.3435 s; dx5 = v_belt^2/(2 a_fl) = 0.2166 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.23448536522336647,
+    "t2_slip_s": 0.5085931778186846,
+    "t3_ride_s": 0.7218831934446154,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.34350864887141697,
+    "dx2_slip_m": 0.32064766951286644,
+    "dx4_off_belt_m": 0.5693352153600982,
+    "dx5_floor_m": 0.21656847264553863,
+    "final_x_m": 2.585903688005637
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.509 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.344 s on the floor.",
+    "Final cube rest position x ~ 2.586 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.2609200575127593,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.25272488955055605,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.3741802575064322,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5691153326914549,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.4496935108018039,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/029/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.2609200575127593,
+  "mu_belt": 0.25272488955055605,
+  "mu_floor": 0.3741802575064322,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5691153326914549,
+  "y_drop_top": 1.4496935108018039
+}

scipy/conveyor_belt_drop/029/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.2609200575127593
+mu_belt      = 0.25272488955055605
+mu_floor     = 0.3741802575064322
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5691153326914549
+y_drop_top   = 1.4496935108018039
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/029/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa153076e104cb89da33c3318a658047b22f656138788fcb6f7d8cd5034be046
+size 15614

scipy/conveyor_belt_drop/034/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.633 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.087 m/s rightward. Coulomb friction mu_belt=0.3765730539484565, mu_floor=0.4102183112577019 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 3.6942; ends when vx = v_belt = 1.087473851973722",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -4.0242; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 3.6942; ends * when * vx = v_belt = 1.087473851973722",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -4.0242; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.453 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.3037 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 3.6942 m/s^2; t2 = v_belt/a = 0.2944 s; dx2 = 0.1601 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 1.1756 m -> t3 = 1.0811 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.4910 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 4.0242; t5 = 0.2702 s; dx5 = v_belt^2/(2 a_fl) = 0.1469 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.30374564271843263,
+    "t2_slip_s": 0.2943747634216525,
+    "t3_ride_s": 1.0810755895105577,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.27023075427124726,
+    "dx2_slip_m": 0.16006242895099876,
+    "dx4_off_belt_m": 0.4910201531199527,
+    "dx5_floor_m": 0.1469344396345588,
+    "final_x_m": 2.4379545927545117
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.294 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.270 s on the floor.",
+    "Final cube rest position x ~ 2.438 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.087473851973722,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.3765730539484565,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.4102183112577019,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.4642961354491928,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.6325422428824774,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/034/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.087473851973722,
+  "mu_belt": 0.3765730539484565,
+  "mu_floor": 0.4102183112577019,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.4642961354491928,
+  "y_drop_top": 1.6325422428824774
+}

scipy/conveyor_belt_drop/034/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.087473851973722
+mu_belt      = 0.3765730539484565
+mu_floor     = 0.4102183112577019
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.4642961354491928
+y_drop_top   = 1.6325422428824774
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/034/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345e0338afd359b7e5692d590c10e57b70dfda0d638160bcdcb12847242da690
+size 15181

scipy/conveyor_belt_drop/035/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.545 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=0.955 m/s rightward. Coulomb friction mu_belt=0.27619220618152307, mu_floor=0.2804261022675867 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 2.7094; ends when vx = v_belt = 0.9552151069878713",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -2.7510; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 2.7094; ends * when * vx = v_belt = 0.9552151069878713",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -2.7510; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.365 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2726 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 2.7094 m/s^2; t2 = v_belt/a = 0.3526 s; dx2 = 0.1684 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 0.9929 m -> t3 = 1.0394 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.4313 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 2.7510; t5 = 0.3472 s; dx5 = v_belt^2/(2 a_fl) = 0.1658 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.2726143740529498,
+    "t2_slip_s": 0.3525500298695348,
+    "t3_ride_s": 1.039444136553637,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.3472272008620485,
+    "dx2_slip_m": 0.16838055725020246,
+    "dx4_off_belt_m": 0.4313022030317381,
+    "dx5_floor_m": 0.16583833391027034,
+    "final_x_m": 2.3971405369420085
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.353 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.347 s on the floor.",
+    "Final cube rest position x ~ 2.397 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 0.9552151069878713,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.27619220618152307,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.2804261022675867,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.6387267006437998,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.5445327179920814,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/035/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 0.9552151069878713,
+  "mu_belt": 0.27619220618152307,
+  "mu_floor": 0.2804261022675867,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.6387267006437998,
+  "y_drop_top": 1.5445327179920814
+}

scipy/conveyor_belt_drop/035/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 0.9552151069878713
+mu_belt      = 0.27619220618152307
+mu_floor     = 0.2804261022675867
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.6387267006437998
+y_drop_top   = 1.5445327179920814
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/035/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32a073ab3357517b2f78765b1093e245970e5be91d0ef78dede6a6a1acc8e952
+size 15313

scipy/conveyor_belt_drop/041/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.573 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.169 m/s rightward. Coulomb friction mu_belt=0.4135161181563597, mu_floor=0.3389781300055946 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 4.0566; ends when vx = v_belt = 1.169202623140597",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -3.3254; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 4.0566; ends * when * vx = v_belt = 1.169202623140597",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -3.3254; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.393 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2829 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 4.0566 m/s^2; t2 = v_belt/a = 0.2882 s; dx2 = 0.1685 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 1.1705 m -> t3 = 1.0011 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.5279 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 3.3254; t5 = 0.3516 s; dx5 = v_belt^2/(2 a_fl) = 0.2055 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.28293566800960934,
+    "t2_slip_s": 0.2882227989865531,
+    "t3_ride_s": 1.0010819221152623,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.3516001843514599,
+    "dx2_slip_m": 0.16849542631200143,
+    "dx4_off_belt_m": 0.5279226254505097,
+    "dx5_floor_m": 0.20554592892022222,
+    "final_x_m": 2.533468554370732
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.288 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.352 s on the floor.",
+    "Final cube rest position x ~ 2.533 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.169202623140597,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.4135161181563597,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.3389781300055946,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.46103696437220315,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.572657964898175,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/041/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.169202623140597,
+  "mu_belt": 0.4135161181563597,
+  "mu_floor": 0.3389781300055946,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.46103696437220315,
+  "y_drop_top": 1.572657964898175
+}

scipy/conveyor_belt_drop/041/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.169202623140597
+mu_belt      = 0.4135161181563597
+mu_floor     = 0.3389781300055946
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.46103696437220315
+y_drop_top   = 1.572657964898175
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/041/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88579e4751d97ed23fff63510e3f27c7c4cdfea07aa2989c2b44c01c6f88fc74
+size 13058

scipy/conveyor_belt_drop/080/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.492 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.230 m/s rightward. Coulomb friction mu_belt=0.43438504772240105, mu_floor=0.42858530097377967 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 4.2613; ends when vx = v_belt = 1.229860093733831",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -4.2044; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 4.2613; ends * when * vx = v_belt = 1.229860093733831",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -4.2044; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.312 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2524 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 4.2613 m/s^2; t2 = v_belt/a = 0.2886 s; dx2 = 0.1775 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 1.1156 m -> t3 = 0.9071 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.5553 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 4.2044; t5 = 0.2925 s; dx5 = v_belt^2/(2 a_fl) = 0.1799 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.2523623240712337,
+    "t2_slip_s": 0.2886103056661856,
+    "t3_ride_s": 0.9071264376028906,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.2925158681717193,
+    "dx2_slip_m": 0.17747514878958237,
+    "dx4_off_belt_m": 0.5553109074257517,
+    "dx5_floor_m": 0.17987679652415184,
+    "final_x_m": 2.5351877039499033
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.289 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.293 s on the floor.",
+    "Final cube rest position x ~ 2.535 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.229860093733831,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.43438504772240105,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.42858530097377967,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5068862456316905,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.4923834725051617,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/080/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.229860093733831,
+  "mu_belt": 0.43438504772240105,
+  "mu_floor": 0.42858530097377967,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5068862456316905,
+  "y_drop_top": 1.4923834725051617
+}

scipy/conveyor_belt_drop/080/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.229860093733831
+mu_belt      = 0.43438504772240105
+mu_floor     = 0.42858530097377967
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5068862456316905
+y_drop_top   = 1.4923834725051617
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/080/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fd167057a61c1689235b124c81b94262139dede94b68ce040af58f5f33ceaf3
+size 13705

scipy/conveyor_belt_drop/095/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.608 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.366 m/s rightward. Coulomb friction mu_belt=0.34436149271107924, mu_floor=0.3618359595338859 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 3.3782; ends when vx = v_belt = 1.3664233263792682",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -3.5496; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 3.3782; ends * when * vx = v_belt = 1.3664233263792682",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -3.5496; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.428 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2955 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 3.3782 m/s^2; t2 = v_belt/a = 0.4045 s; dx2 = 0.2763 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 0.9409 m -> t3 = 0.6886 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.6170 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 3.5496; t5 = 0.3850 s; dx5 = v_belt^2/(2 a_fl) = 0.2630 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.29553012228736086,
+    "t2_slip_s": 0.4044843084096268,
+    "t3_ride_s": 0.6885508106507919,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.3849501868238257,
+    "dx2_slip_m": 0.27634839708265,
+    "dx4_off_belt_m": 0.6169724354546009,
+    "dx5_floor_m": 0.26300245738506633,
+    "final_x_m": 2.679974892839667
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.404 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.385 s on the floor.",
+    "Final cube rest position x ~ 2.680 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.3664233263792682,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.34436149271107924,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.3618359595338859,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5827997138467532,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.60839315084389,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/095/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.3664233263792682,
+  "mu_belt": 0.34436149271107924,
+  "mu_floor": 0.3618359595338859,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5827997138467532,
+  "y_drop_top": 1.60839315084389
+}

scipy/conveyor_belt_drop/095/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.3664233263792682
+mu_belt      = 0.34436149271107924
+mu_floor     = 0.3618359595338859
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5827997138467532
+y_drop_top   = 1.60839315084389
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/095/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f6dceb3a9510ed9f908836fff160f997064ad5fc982edd4b22b397c5d22f3e6
+size 15765

scipy/conveyor_belt_drop/244/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.604 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=1.483 m/s rightward. Coulomb friction mu_belt=0.33294151078801415, mu_floor=0.36278662540912265 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 3.2662; ends when vx = v_belt = 1.4827812683679797",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -3.5589; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 3.2662; ends * when * vx = v_belt = 1.4827812683679797",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -3.5589; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.424 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2939 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 3.2662 m/s^2; t2 = v_belt/a = 0.4540 s; dx2 = 0.3366 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 0.8854 m -> t3 = 0.5971 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.6695 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 3.5589; t5 = 0.4166 s; dx5 = v_belt^2/(2 a_fl) = 0.3089 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.2938610017142196,
+    "t2_slip_s": 0.4539835721608513,
+    "t3_ride_s": 0.5971454429526873,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.41663602184264104,
+    "dx2_slip_m": 0.33657916847344665,
+    "dx4_off_belt_m": 0.6695107970789503,
+    "dx5_floor_m": 0.30889004445781026,
+    "final_x_m": 2.7784008415367607
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.454 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.417 s on the floor.",
+    "Final cube rest position x ~ 2.778 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 1.4827812683679797,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.33294151078801415,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.36278662540912265,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5779847542250085,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.6035677842512168,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/244/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 1.4827812683679797,
+  "mu_belt": 0.33294151078801415,
+  "mu_floor": 0.36278662540912265,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5779847542250085,
+  "y_drop_top": 1.6035677842512168
+}

scipy/conveyor_belt_drop/244/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 1.4827812683679797
+mu_belt      = 0.33294151078801415
+mu_floor     = 0.36278662540912265
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5779847542250085
+y_drop_top   = 1.6035677842512168
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/244/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebdf5286f478a9d29854c295bb20e960a41084b51ee205a153cb1bdfd3970056
+size 15562

scipy/conveyor_belt_drop/257/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.618 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=0.968 m/s rightward. Coulomb friction mu_belt=0.34298813719428556, mu_floor=0.22859095354435696 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 3.3647; ends when vx = v_belt = 0.9680709723656657",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -2.2425; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 3.3647; ends * when * vx = v_belt = 0.9680709723656657",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -2.2425; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.438 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2988 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 3.3647 m/s^2; t2 = v_belt/a = 0.2877 s; dx2 = 0.1393 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 1.1075 m -> t3 = 1.1440 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.4371 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 2.2425; t5 = 0.4317 s; dx5 = v_belt^2/(2 a_fl) = 0.2090 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.2988341073006338,
+    "t2_slip_s": 0.28771273873676134,
+    "t3_ride_s": 1.14402390638891,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.431697120014153,
+    "dx2_slip_m": 0.13926317537544264,
+    "dx4_off_belt_m": 0.4371069301751423,
+    "dx5_floor_m": 0.2089567253697793,
+    "final_x_m": 2.446063655544922
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.288 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.432 s on the floor.",
+    "Final cube rest position x ~ 2.446 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 0.9680709723656657,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.34298813719428556,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.22859095354435696,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5532404891570779,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.6180254451806477,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/257/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 0.9680709723656657,
+  "mu_belt": 0.34298813719428556,
+  "mu_floor": 0.22859095354435696,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5532404891570779,
+  "y_drop_top": 1.6180254451806477
+}

scipy/conveyor_belt_drop/257/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 0.9680709723656657
+mu_belt      = 0.34298813719428556
+mu_floor     = 0.22859095354435696
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5532404891570779
+y_drop_top   = 1.6180254451806477
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/257/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d6d52e5ccf6e0e41e14325d4d97cfd915c7a0b66fbcdb5250d06553e51bae9e
+size 15232

scipy/conveyor_belt_drop/260/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.434 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=0.981 m/s rightward. Coulomb friction mu_belt=0.3126096564704527, mu_floor=0.2517886259367248 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 3.0667; ends when vx = v_belt = 0.9808614451044682",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -2.4700; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 3.0667; ends * when * vx = v_belt = 0.9808614451044682",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -2.4700; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.254 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2274 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 3.0667 m/s^2; t2 = v_belt/a = 0.3198 s; dx2 = 0.1569 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 1.0520 m -> t3 = 1.0725 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.4429 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 2.4700; t5 = 0.3971 s; dx5 = v_belt^2/(2 a_fl) = 0.1948 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.22738489248792534,
+    "t2_slip_s": 0.31984257072010386,
+    "t3_ride_s": 1.072494931954687,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.3971024337793752,
+    "dx2_slip_m": 0.15686062306122459,
+    "dx4_off_belt_m": 0.4428821309960951,
+    "dx5_floor_m": 0.19475123352566967,
+    "final_x_m": 2.4376333645217647
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.320 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.397 s on the floor.",
+    "Final cube rest position x ~ 2.438 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 0.9808614451044682,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.3126096564704527,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.2517886259367248,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.5911704481144829,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.433607577172211,
+      "unit": "",
+      "description": ""
+    }
+  }
+}

scipy/conveyor_belt_drop/260/params.json

@@ -0,0 +1,14 @@
+{
+  "g": 9.81,
+  "v_belt": 0.9808614451044682,
+  "mu_belt": 0.3126096564704527,
+  "mu_floor": 0.2517886259367248,
+  "m_cube": 0.5,
+  "x_belt_left": 0.3,
+  "x_belt_right": 1.8,
+  "y_belt_top": 1.0,
+  "r_pulley": 0.07,
+  "cube_size": 0.18,
+  "x_drop": 0.5911704481144829,
+  "y_drop_top": 1.433607577172211
+}

scipy/conveyor_belt_drop/260/simulation_code.py

@@ -0,0 +1,122 @@
+"""
+Conveyor Belt Drop — auto-generated.
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+from matplotlib.patches import Rectangle, Circle, Polygon
+from matplotlib.collections import LineCollection
+
+g            = 9.81
+v_belt       = 0.9808614451044682
+mu_belt      = 0.3126096564704527
+mu_floor     = 0.2517886259367248
+m_cube       = 0.5
+x_belt_left  = 0.3
+x_belt_right = 1.8
+y_belt_top   = 1.0
+r_pulley     = 0.07
+cube_size    = 0.18
+x_drop       = 0.5911704481144829
+y_drop_top   = 1.433607577172211
+duration     = 12
+fps          = 30
+
+fall_dist_1 = (y_drop_top - cube_size) - y_belt_top
+t1_dur = np.sqrt(max(2.0 * fall_dist_1 / g, 0.0))
+a_friction = mu_belt * g
+t2_dur = v_belt / a_friction if a_friction > 0 else 0.0
+dx2 = 0.5 * a_friction * t2_dur ** 2
+x_at_phase3_start = x_drop + dx2
+t3_dur = max(0.0, (x_belt_right - x_at_phase3_start) / v_belt) if v_belt > 0 else 0.0
+fall_dist_4 = y_belt_top
+t4_dur = np.sqrt(2.0 * fall_dist_4 / g)
+dx4 = v_belt * t4_dur
+a_floor = mu_floor * g
+t5_dur = v_belt / a_floor if a_floor > 0 else 0.0
+dx5 = v_belt ** 2 / (2.0 * a_floor) if a_floor > 0 else 0.0
+t1_end = t1_dur
+t2_end = t1_end + t2_dur
+t3_end = t2_end + t3_dur
+t4_end = t3_end + t4_dur
+t5_end = t4_end + t5_dur
+
+def cube_com(t):
+    if t <= t1_end:
+        return (x_drop, (y_drop_top - cube_size/2) - 0.5*g*t**2)
+    if t <= t2_end:
+        dt = t - t1_end
+        return (x_drop + 0.5*a_friction*dt**2, y_belt_top + cube_size/2)
+    if t <= t3_end:
+        dt = t - t2_end
+        return (x_at_phase3_start + v_belt*dt, y_belt_top + cube_size/2)
+    if t <= t4_end:
+        dt = t - t3_end
+        return (x_belt_right + v_belt*dt, (y_belt_top + cube_size/2) - 0.5*g*dt**2)
+    if t <= t5_end:
+        dt = t - t4_end
+        return (x_belt_right + dx4 + v_belt*dt - 0.5*a_floor*dt**2, cube_size/2)
+    return (x_belt_right + dx4 + dx5, cube_size/2)
+
+fig_w, fig_h = 11.0, 6.0
+fig_aspect = fig_w / fig_h
+x_lo_d = -0.20
+x_hi_d = x_belt_right + dx4 + dx5 + 0.30
+y_lo_d = -0.25
+y_hi_d = y_drop_top + 0.20
+dx_d, dy_d = x_hi_d - x_lo_d, y_hi_d - y_lo_d
+if dx_d / dy_d < fig_aspect:
+    extra = (fig_aspect * dy_d - dx_d) / 2.0
+    x_lo, x_hi = x_lo_d - extra, x_hi_d + extra
+    y_lo, y_hi = y_lo_d, y_hi_d
+else:
+    extra = (dx_d / fig_aspect - dy_d) / 2.0
+    x_lo, x_hi = x_lo_d, x_hi_d
+    y_lo, y_hi = y_lo_d - extra, y_hi_d + extra
+
+fig = plt.figure(figsize=(fig_w, fig_h), facecolor="#1a1a2e")
+ax = fig.add_axes([0, 0, 1, 1]); ax.set_facecolor("#16213e")
+ax.set_xlim(x_lo, x_hi); ax.set_ylim(y_lo, y_hi)
+ax.set_aspect("equal"); ax.axis("off")
+ax.add_patch(Polygon([(x_lo, y_lo), (x_hi, y_lo), (x_hi, 0.0), (x_lo, 0.0)],
+                     facecolor="#4a4e69", edgecolor="none", zorder=0))
+ax.plot([x_lo, x_hi], [0.0, 0.0], color="#adb5bd", lw=2.0, zorder=1)
+y_pulley_c = y_belt_top - r_pulley
+ax.plot([x_belt_left, x_belt_right], [y_belt_top, y_belt_top],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.plot([x_belt_left, x_belt_right], [y_belt_top - 2*r_pulley, y_belt_top - 2*r_pulley],
+        color="#4a4e69", lw=10, solid_capstyle="butt", zorder=2)
+ax.add_patch(Circle((x_belt_left, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+ax.add_patch(Circle((x_belt_right, y_pulley_c), r_pulley, facecolor="#3a4357", edgecolor="#adb5bd", lw=1.2, zorder=3))
+
+hash_spacing = 0.12; hash_w = 0.025
+hash_lc = LineCollection([], colors="#adb5bd", linewidths=2.0, zorder=4)
+ax.add_collection(hash_lc)
+
+cube_patch = Rectangle((0, 0), cube_size, cube_size, facecolor="#e63946",
+                       edgecolor="#adb5bd", lw=1.2, zorder=5)
+ax.add_patch(cube_patch)
+
+def update(f):
+    t = f / fps
+    cx, cy = cube_com(t)
+    cube_patch.set_xy((cx - cube_size/2, cy - cube_size/2))
+    s0 = (v_belt * t) % hash_spacing
+    span = x_belt_right - x_belt_left
+    n_marks = int(np.ceil(span / hash_spacing)) + 1
+    segs = []
+    for k in range(n_marks):
+        x_m = x_belt_left + s0 + k * hash_spacing
+        if x_belt_left <= x_m <= x_belt_right:
+            segs.append([(x_m, y_belt_top - hash_w), (x_m, y_belt_top + hash_w)])
+        x_m_b = x_belt_right - s0 - k * hash_spacing
+        if x_belt_left <= x_m_b <= x_belt_right:
+            y_b = y_belt_top - 2 * r_pulley
+            segs.append([(x_m_b, y_b - hash_w), (x_m_b, y_b + hash_w)])
+    hash_lc.set_segments(segs)
+    return cube_patch, hash_lc
+
+n_frames = int(duration * fps) + 1
+ani = animation.FuncAnimation(fig, update, frames=n_frames, interval=1000.0/fps, blit=False)
+ani.save("conveyor_belt_drop.mp4", writer=animation.FFMpegWriter(fps=fps, bitrate=1800), dpi=120)
+plt.close(); print("Saved conveyor_belt_drop.mp4")

scipy/conveyor_belt_drop/260/video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a4ba3809052c4b1022ceac30bc766190d1669a002b01c1bece2e94957744dd7
+size 15859

scipy/conveyor_belt_drop/271/cot.json

@@ -0,0 +1,123 @@
+{
+  "simulation": "conveyor_belt_drop",
+  "physical_observation": "A cube (m=0.500 kg, side=0.180 m) is dropped from height y_drop_top=1.575 m above a conveyor belt whose top is at y=1.000 m and runs at v_belt=0.989 m/s rightward. Coulomb friction mu_belt=0.2004926860740261, mu_floor=0.21798917796520362 couples cube to belt and to the floor. Cube exits the belt's right edge at x=1.800 m, falls to the floor, and slides to rest.",
+  "physical_law": {
+    "name": "Newton II + Coulomb kinetic friction + perfectly inelastic vertical contact",
+    "statement": "Vertical free fall under gravity; friction f = mu_k m g acts to oppose relative slip; cube does not bounce vertically off the belt or floor.",
+    "formula": "Free fall: y'' = -g.  Slipping on belt: vx' = mu_belt g.  No-slip ride: vx = v_belt.  Off belt: vx const, y free fall.  Floor slide: vx' = -mu_floor g until vx=0."
+  },
+  "ode_system": {
+    "state_variables": [
+      "x_cube (m)",
+      "y_cube (m)"
+    ],
+    "equations_latex": [
+      "Phase 1 (drop): y(t) = y0 - 0.5 g t^2; x = x_drop",
+      "Phase 2 (slipping): vx' = mu_belt \\cdot g = 1.9668; ends when vx = v_belt = 0.9887897620447693",
+      "Phase 3 (riding): x' = v_belt; y on belt top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 (floor): vx' = -mu_floor \\cdot g = -2.1385; stops at v=0"
+    ],
+    "equations_python": [
+      "Phase 1 * (drop): y(t) = y0 - 0.5 * g * t**2; x = x_drop",
+      "Phase 2 * (slipping): vx' = mu_belt * g = 1.9668; ends * when * vx = v_belt = 0.9887897620447693",
+      "Phase 3 * (riding): x' = v_belt; y * on * belt * top",
+      "Phase 4 (off belt): x' = v_belt; y free fall",
+      "Phase 5 * (floor): vx' = -mu_floor * g = -2.1385; stops * at * v=0"
+    ]
+  },
+  "derivation_steps": [
+    "Phase 1 free fall through 0.395 m: t1 = \\sqrt(2 (y_drop_top - cube_size - y_belt_top)/g) = 0.2838 s.",
+    "Phase 2 slipping: cube starts at vx=0, belt moves at v_belt. Friction f = mu_belt m g pulls cube forward. a = mu_belt g = 1.9668 m/s^2; t2 = v_belt/a = 0.5027 s; dx2 = 0.2485 m.",
+    "Phase 3 no-slip: cube co-moves with belt at v_belt; remaining distance to right edge = 0.9401 m -> t3 = 0.9507 s.",
+    "Phase 4 off-belt projectile: vy free fall from y_belt_top to floor (drop 1.000 m); t4 = 0.4515 s; horizontal travel dx4 = 0.4465 m.",
+    "Phase 5 floor friction: deceleration a_fl = mu_floor g = 2.1385; t5 = 0.4624 s; dx5 = v_belt^2/(2 a_fl) = 0.2286 m."
+  ],
+  "physical_constants_derived": {
+    "t1_drop_s": 0.28384204566176324,
+    "t2_slip_s": 0.5027318720845381,
+    "t3_ride_s": 0.9507235012244237,
+    "t4_fall_s": 0.4515236409857309,
+    "t5_floor_slide_s": 0.46238104272012037,
+    "dx2_slip_m": 0.2485480640853959,
+    "dx4_off_belt_m": 0.4464619535278687,
+    "dx5_floor_m": 0.22859882060262007,
+    "final_x_m": 2.4750607741304886
+  },
+  "numerical_method": {
+    "solver": "Closed-form per phase; no ODE solver needed.",
+    "tolerance": "Machine precision.",
+    "justification": "Each phase has constant acceleration with analytic transition times."
+  },
+  "code_validation": {
+    "ode_source": "Newton II for each phase; standard friction-on-belt textbook problem.",
+    "energy_check": "KE evolves consistent with the work-energy theorem; friction dissipates KE while belt does positive work in phase 2.",
+    "physical_plausibility": true
+  },
+  "expected_behavior": [
+    "Drop, then slip on belt for ~0.503 s, ride to right edge, projectile to floor in ~0.452 s, and stop after ~0.462 s on the floor.",
+    "Final cube rest position x ~ 2.475 m."
+  ],
+  "parameters": {
+    "g": {
+      "value": 9.81,
+      "unit": "",
+      "description": ""
+    },
+    "v_belt": {
+      "value": 0.9887897620447693,
+      "unit": "",
+      "description": ""
+    },
+    "mu_belt": {
+      "value": 0.2004926860740261,
+      "unit": "",
+      "description": ""
+    },
+    "mu_floor": {
+      "value": 0.21798917796520362,
+      "unit": "",
+      "description": ""
+    },
+    "m_cube": {
+      "value": 0.5,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_left": {
+      "value": 0.3,
+      "unit": "",
+      "description": ""
+    },
+    "x_belt_right": {
+      "value": 1.8,
+      "unit": "",
+      "description": ""
+    },
+    "y_belt_top": {
+      "value": 1.0,
+      "unit": "",
+      "description": ""
+    },
+    "r_pulley": {
+      "value": 0.07,
+      "unit": "",
+      "description": ""
+    },
+    "cube_size": {
+      "value": 0.18,
+      "unit": "",
+      "description": ""
+    },
+    "x_drop": {
+      "value": 0.6113862713685363,
+      "unit": "",
+      "description": ""
+    },
+    "y_drop_top": {
+      "value": 1.5751777352731542,
+      "unit": "",
+      "description": ""
+    }
+  }
+}