Boo-AI — Master Artificial Intelligence by Building from Scratch

Learning Objectives

By the end of this section, you will be able to:

Understand momentum as mass times velocity and its role as the fundamental quantity of motion
Define impulse as the integral of force over time and understand its physical meaning
Apply the impulse-momentum theorem to solve problems involving changing velocities
Use integration to calculate impulse from variable forces
Analyze collisions using conservation of momentum principles
Connect these concepts to engineering safety design and numerical computing

The Big Picture: Why Impulse and Momentum Matter

"An object in motion stays in motion unless acted upon by a force." — Newton's First Law

How do we quantify "motion"? The answer is momentum — the product of mass and velocity. And when forces act on objects, how do we calculate the resulting change in motion? This is where impulse enters: the integral of force over time.

The Central Question

Given a force that varies with time, how much does an object's velocity change? Calculus gives us the answer: integrate the force. The impulse-momentum theorem connects the integral of force to the change in momentum.

This is not just abstract physics — it's the foundation for:

Vehicle safety design: Why do crumple zones and airbags save lives?
Sports science: How do athletes maximize performance?
Aerospace engineering: How do rockets change their velocity?
Numerical simulation: How do physics engines compute motion?

Historical Context: Newton's Original Formulation

When Isaac Newton (1643–1727) formulated his laws of motion in the Principia Mathematica (1687), he actually expressed the second law in terms of momentum, not acceleration:

\vec{F} = \frac{d\vec{p}}{dt}

where $\vec{p} = m\vec{v}$ is the momentum. The familiar $\vec{F} = m\vec{a}$ form is derived from this when mass is constant.

This momentum formulation is actually more fundamental — it handles cases where mass changes (like rockets expelling fuel) and directly leads to conservation laws that govern collisions.

Momentum: The Foundation

Linear momentum (often just called "momentum") measures the quantity of motion of an object:

Momentum Definition

\vec{p} = m\vec{v}

where

m

is mass (kg) and

\vec{v}

is velocity (m/s)
Units: kg·m/s (or equivalently, N·s)

Why Momentum?

Momentum captures an intuitive idea: a more massive object moving at the same speed is "harder to stop" than a lighter one. Similarly, a faster object is harder to stop than a slower one. Momentum quantifies this "quantity of motion."

Object	Mass (kg)	Velocity (m/s)	Momentum (kg·m/s)
Baseball (pitched)	0.145	40	5.8
Hockey puck (slap shot)	0.17	45	7.65
Tennis ball (serve)	0.058	60	3.48
Car (highway)	1500	30	45,000
Train	100,000	30	3,000,000

The Power of Momentum

A train moving at 30 m/s has about 65,000 times the momentum of a pitched baseball. This is why collisions with trains are so devastating — stopping them requires enormous impulse.

Impulse: Force Over Time

When a force acts on an object over a time interval, it delivers impulse. For a constant force:

\vec{J} = \vec{F} \cdot \Delta t \quad \text{(constant force)}

But what if the force varies with time? This is where calculus becomes essential. We must integrate:

Impulse as an Integral

\vec{J} = \int_{t_1}^{t_2} \vec{F}(t) \, dt

Impulse is the area under the force-time curve

Geometric Interpretation

Just as we learned that the definite integral represents area under a curve, impulse is the area under the force-time graph. This geometric interpretation is incredibly powerful:

A constant force creates a rectangular area: $J = F \cdot \Delta t$
A linearly increasing force creates a triangular area
Complex force profiles require integration

The Impulse-Momentum Theorem

The impulse-momentum theorem is one of the most important results in mechanics. It connects impulse (the integral of force) to momentum change:

The Impulse-Momentum Theorem

\vec{J} = \int_{t_1}^{t_2} \vec{F}(t) \, dt = \Delta \vec{p} = m\vec{v}_f - m\vec{v}_i

Impulse equals the change in momentum

Derivation from Newton's Second Law

Starting from $\vec{F} = \frac{d\vec{p}}{dt}$ :

\vec{F}(t) = \frac{d\vec{p}}{dt}

\vec{F}(t) \, dt = d\vec{p}

\int_{t_1}^{t_2} \vec{F}(t) \, dt = \int_{\vec{p}_1}^{\vec{p}_2} d\vec{p}

\vec{J} = \vec{p}_2 - \vec{p}_1 = \Delta\vec{p}

This is the Fundamental Theorem of Calculus in action! The integral of the rate of change of momentum (force) equals the total change in momentum.

Variable Forces and Integration

In real-world applications, forces rarely remain constant. Consider these examples:

Example 1: Spring Force

A compressed spring releases an object. By Hooke's Law, the force decreases as the spring extends:

F(x) = kx_0 - kx = k(x_0 - x)

Converting to time (using kinematics), we need to integrate to find the impulse delivered to the object.

Example 2: Bat Hitting Ball

When a bat hits a baseball, the force follows a complex profile. A common model is:

F(t) = F_{\max} \sin\left(\frac{\pi t}{T}\right) \quad \text{for } 0 \leq t \leq T

The impulse is:

J = \int_0^T F_{\max} \sin\left(\frac{\pi t}{T}\right) dt = F_{\max} \cdot \frac{2T}{\pi}

Example 3: Rocket Thrust

Rocket engines may vary thrust over time. If $F(t) = F_0 e^{-t/\tau}$ (exponentially decreasing thrust):

J = \int_0^{\infty} F_0 e^{-t/\tau} dt = F_0 \tau

The Integral Is Essential

Without calculus, we could only handle constant forces. Integration lets us compute the total impulse from any force profile — a capability that's essential for engineering and simulation.

Interactive: Impulse and Force Visualization

Explore how different force profiles produce the same impulse. Notice that the area under each curve is equal:

Collision Analysis

Collisions are the perfect application of impulse-momentum principles. During a collision, complex forces act for very short times, making them difficult to measure directly. But we can analyze the outcome using conservation of momentum.

Conservation of Momentum

For an isolated system (no external forces), total momentum is conserved:

Conservation of Momentum

\sum \vec{p}_{\text{before}} = \sum \vec{p}_{\text{after}}

m_1 \vec{v}_{1i} + m_2 \vec{v}_{2i} = m_1 \vec{v}_{1f} + m_2 \vec{v}_{2f}

Types of Collisions

Type	Momentum	Kinetic Energy	Example
Elastic	Conserved	Conserved	Billiard balls, atomic collisions
Inelastic	Conserved	Not conserved	Most real collisions
Perfectly Inelastic	Conserved	Maximum loss	Objects stick together
Explosive	Conserved	Increases	Explosions, springs releasing

Newton's Third Law in Collisions

During a collision, the forces on each object are equal and opposite. Since they act for the same time:

\vec{J}_1 = -\vec{J}_2

This means the momentum gained by one object exactly equals the momentum lost by the other — which is why total momentum is conserved!

Interactive: Collision Analyzer

Experiment with different collision scenarios. Observe how momentum is always conserved, but kinetic energy depends on the collision type:

Real-World Applications

Vehicle Safety: The Physics of Crumple Zones

The Problem: In a crash, a car must go from highway speed to zero. The impulse required ( $J = \Delta p = mv$ ) is fixed by physics.

The Key Insight: Since $J = F_{\text{avg}} \cdot \Delta t$ , we can't change the impulse, but we CAN change how it's delivered:

F_{\text{avg}} = \frac{J}{\Delta t}

Longer collision time = Lower average force!

This is exactly why crumple zones work. By designed to collapse progressively, they extend the collision time from ~5ms (hitting a rigid wall) to ~150ms, reducing the average force by a factor of 30!

Sports: Maximizing Performance

Baseball batting: The bat contacts the ball for about 1 ms, during which it delivers an impulse of ~8 N·s. The ball's velocity changes from -40 m/s (toward batter) to +55 m/s (away from batter).

Golf driving: A driver contacts the ball for ~0.5 ms with a peak force of ~10,000 N. The impulse accelerates the ball from rest to ~70 m/s (155 mph).

Aerospace: Rocket Propulsion

Impulse is everything in rocketry. The total impulse delivered by a rocket engine determines how much it can change a spacecraft's velocity.

Specific impulse (Isp) measures efficiency: impulse per unit weight of propellant. Higher Isp means more $\Delta v$ per kg of fuel.

I_{sp} = \frac{J}{m_p g} = \frac{v_e}{g}

Numerical Computing Connection

The impulse-momentum theorem is fundamental to physics simulation in games, engineering software, and scientific computing.

Time-Stepping in Physics Engines

Physics engines update object states at discrete time steps. The basic update loop uses the impulse-momentum theorem:

// For each time step Δt:
impulse = force * dt
velocity += impulse / mass
position += velocity * dt

More sophisticated integrators (Runge-Kutta, Verlet) improve accuracy, but all are fundamentally based on the impulse-momentum relationship.

Collision Detection and Response

When objects collide in a simulation:

Detect the collision (geometry intersection)
Calculate the impulse needed to prevent penetration
Apply equal and opposite impulses to each object
Update velocities using $\Delta v = J/m$

Why Impulse, Not Force?

Physics engines often work directly with impulses rather than forces because impulses directly change velocities. This avoids numerical issues with very short collision times and large forces.

Python Implementation

Computing Impulse and Analyzing Motion

Impulse and Momentum Analysis

🐍impulse_momentum.py

Explanation(9)

Code(154)

5Constant Force Impulse

For constant force, impulse is simply J = F × Δt. This is the base case before we need calculus.

17Variable Force Impulse

When force varies with time, we MUST integrate: J = ∫F(t)dt. This is where calculus becomes essential!

31Numerical Integration

scipy.integrate.quad uses adaptive quadrature to compute the definite integral accurately, handling the variable force.

35Impulse-Momentum Analysis

Complete analysis function that combines force integration with the impulse-momentum theorem.

51Computing Impulse

First, integrate the force over time to get the total impulse. This is the heart of the calculation.

54Applying the Theorem

The impulse-momentum theorem: J = m × Δv. Rearranging: Δv = J/m gives us the velocity change.

63Verification

A key check: Impulse should equal momentum change. If |J - Δp| ≈ 0, our physics is correct!

94Spring Force Example

A realistic force that decreases as the spring extends. This requires integration—no shortcut!

110Cumulative Impulse

We can compute J(t) = ∫₀ᵗ F(τ)dτ to see how impulse accumulates over time, connecting integration to physics.

145 lines without explanation

1import numpy as np
2from scipy import integrate
3import matplotlib.pyplot as plt
4
5def compute_impulse_constant_force(F: float, t1: float, t2: float) -> float:
6    """
7    Impulse from constant force: J = F * Δt
8
9    Parameters:
10    -----------
11    F : Force magnitude (N)
12    t1, t2 : Start and end times (s)
13
14    Returns:
15    --------
16    float : Impulse (N·s = kg·m/s)
17    """
18    return F * (t2 - t1)
19
20def compute_impulse_variable_force(F_func, t1: float, t2: float) -> tuple:
21    """
22    Impulse from variable force: J = ∫ F(t) dt
23
24    This is where calculus becomes essential! When force
25    varies with time, we must integrate to find the total
26    impulse.
27
28    Parameters:
29    -----------
30    F_func : callable - Force as a function of time F(t)
31    t1, t2 : Start and end times (s)
32
33    Returns:
34    --------
35    tuple : (impulse, error_estimate)
36    """
37    impulse, error = integrate.quad(F_func, t1, t2)
38    return impulse, error
39
40def impulse_momentum_analysis(F_func, m: float, v_initial: float,
41                               t1: float, t2: float) -> dict:
42    """
43    Complete impulse-momentum analysis.
44
45    The Impulse-Momentum Theorem: J = Δp = m * Δv
46
47    Parameters:
48    -----------
49    F_func : callable - Force function F(t)
50    m : Mass (kg)
51    v_initial : Initial velocity (m/s)
52    t1, t2 : Time interval (s)
53
54    Returns:
55    --------
56    dict : Analysis results including impulse, velocities, momentum change
57    """
58    # Compute impulse by integrating force
59    impulse, error = compute_impulse_variable_force(F_func, t1, t2)
60
61    # Apply impulse-momentum theorem: J = m * Δv
62    delta_v = impulse / m
63    v_final = v_initial + delta_v
64
65    # Calculate momentum change
66    p_initial = m * v_initial
67    p_final = m * v_final
68    delta_p = p_final - p_initial
69
70    return {
71        'impulse': impulse,
72        'impulse_error': error,
73        'initial_velocity': v_initial,
74        'final_velocity': v_final,
75        'velocity_change': delta_v,
76        'initial_momentum': p_initial,
77        'final_momentum': p_final,
78        'momentum_change': delta_p,
79        'verification': abs(impulse - delta_p) < 1e-10  # Should be equal!
80    }
81
82# Example 1: Constant Force (Baseball Bat)
83print("Example 1: Baseball Bat Hit")
84print("=" * 50)
85print("A baseball (m = 0.145 kg) is hit by a bat.")
86print("The bat exerts a constant force of 8000 N for 0.001 s.")
87
88F_bat = 8000  # N
89t_contact = 0.001  # s
90m_ball = 0.145  # kg
91v_initial = -40  # m/s (toward batter)
92
93impulse_bat = compute_impulse_constant_force(F_bat, 0, t_contact)
94delta_v = impulse_bat / m_ball
95v_final = v_initial + delta_v
96
97print(f"\nImpulse: J = F × Δt = {F_bat} × {t_contact} = {impulse_bat} N·s")
98print(f"Velocity change: Δv = J/m = {impulse_bat}/{m_ball} = {delta_v:.1f} m/s")
99print(f"Final velocity: v_f = {v_initial} + {delta_v:.1f} = {v_final:.1f} m/s")
100
101# Example 2: Variable Force (Spring-loaded Launcher)
102print("\n\nExample 2: Spring-loaded Projectile")
103print("=" * 50)
104print("A spring launcher exerts force F(t) = 500 - 10000t² (N)")
105print("for 0 ≤ t ≤ 0.2 s on a 0.5 kg projectile.")
106
107def spring_force(t):
108    """Force decreases as spring extends: F(t) = 500 - 10000t²"""
109    if t < 0 or t > 0.2:
110        return 0
111    return 500 - 10000 * t**2
112
113results = impulse_momentum_analysis(
114    F_func=spring_force,
115    m=0.5,
116    v_initial=0,
117    t1=0,
118    t2=0.2
119)
120
121print(f"\nImpulse (∫F dt): {results['impulse']:.4f} N·s")
122print(f"Initial velocity: {results['initial_velocity']} m/s")
123print(f"Final velocity: {results['final_velocity']:.4f} m/s")
124print(f"Momentum change: {results['momentum_change']:.4f} kg·m/s")
125print(f"Verification (J = Δp): {results['verification']}")
126
127# Visualize the force and cumulative impulse
128t = np.linspace(0, 0.2, 1000)
129F_values = [spring_force(ti) for ti in t]
130cumulative_impulse = [integrate.quad(spring_force, 0, ti)[0] for ti in t]
131
132fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
133
134ax1.plot(t * 1000, F_values, 'b-', linewidth=2)
135ax1.fill_between(t * 1000, F_values, alpha=0.3)
136ax1.set_xlabel('Time (ms)')
137ax1.set_ylabel('Force (N)')
138ax1.set_title('Variable Force F(t)')
139ax1.grid(True, alpha=0.3)
140ax1.annotate('Area = Impulse J', xy=(100, 200), fontsize=12,
141             ha='center', color='blue')
142
143ax2.plot(t * 1000, cumulative_impulse, 'r-', linewidth=2)
144ax2.set_xlabel('Time (ms)')
145ax2.set_ylabel('Cumulative Impulse (N·s)')
146ax2.set_title('Impulse Accumulation J(t) = ∫₀ᵗ F(τ) dτ')
147ax2.grid(True, alpha=0.3)
148ax2.axhline(y=results['impulse'], color='g', linestyle='--',
149            label=f"Final J = {results['impulse']:.2f} N·s")
150ax2.legend()
151
152plt.tight_layout()
153plt.savefig('impulse_analysis.png', dpi=150)
154plt.show()

Collision Analysis

Collision and Safety Analysis

🐍collision_analysis.py

Explanation(7)

Code(128)

5Collision Analysis Function

Collisions are where impulse-momentum principles shine. During contact, complex forces act, but we can skip the details by using conservation laws.

17Momentum Conservation

Momentum is ALWAYS conserved in collisions (no external forces). This is a direct consequence of Newton's third law applied over the collision.

28Elastic Collision

In elastic collisions, both momentum AND kinetic energy are conserved. These formulas come from solving two simultaneous equations.

34Inelastic Collision

When objects stick together, momentum is still conserved but KE is not. The common final velocity comes directly from momentum conservation.

45Impulse Calculation

The impulse on each object equals its momentum change. By Newton's third law, J₁ = -J₂ (equal and opposite impulses).

60Car Crash Analysis

Real-world engineering application: analyzing car crashes to design better safety systems.

81The Key Safety Insight

Since J = F × Δt is fixed, extending the collision time dramatically reduces the average force. This is the physics behind crumple zones!

121 lines without explanation

1import numpy as np
2from scipy import integrate
3import matplotlib.pyplot as plt
4
5def analyze_collision(m1: float, v1i: float, m2: float, v2i: float,
6                      collision_type: str = 'elastic') -> dict:
7    """
8    Analyze collisions using conservation laws.
9
10    In collisions, MOMENTUM is always conserved:
11    m₁v₁ᵢ + m₂v₂ᵢ = m₁v₁f + m₂v₂f
12
13    For elastic collisions, KINETIC ENERGY is also conserved.
14    For perfectly inelastic, objects stick together.
15
16    Parameters:
17    -----------
18    m1, m2 : Masses (kg)
19    v1i, v2i : Initial velocities (m/s)
20    collision_type : 'elastic' or 'inelastic'
21
22    Returns:
23    --------
24    dict : Collision analysis results
25    """
26    # Initial momentum and kinetic energy
27    p_initial = m1 * v1i + m2 * v2i
28    KE_initial = 0.5 * m1 * v1i**2 + 0.5 * m2 * v2i**2
29
30    if collision_type == 'elastic':
31        # For elastic collision, solve two equations:
32        # 1. p₁ + p₂ = const (momentum)
33        # 2. KE₁ + KE₂ = const (energy)
34        # Solution (derived from these equations):
35        v1f = ((m1 - m2) * v1i + 2 * m2 * v2i) / (m1 + m2)
36        v2f = ((m2 - m1) * v2i + 2 * m1 * v1i) / (m1 + m2)
37
38    else:  # perfectly inelastic
39        # Objects stick together: m₁v₁ + m₂v₂ = (m₁+m₂)v_f
40        v1f = v2f = p_initial / (m1 + m2)
41
42    # Final momentum and kinetic energy
43    p_final = m1 * v1f + m2 * v2f
44    KE_final = 0.5 * m1 * v1f**2 + 0.5 * m2 * v2f**2
45
46    # Impulse on each object (from Newton's third law, equal and opposite)
47    J1 = m1 * (v1f - v1i)  # Impulse on object 1
48    J2 = m2 * (v2f - v2i)  # Impulse on object 2
49
50    return {
51        'type': collision_type,
52        'v1_initial': v1i, 'v2_initial': v2i,
53        'v1_final': v1f, 'v2_final': v2f,
54        'p_initial': p_initial, 'p_final': p_final,
55        'momentum_conserved': abs(p_initial - p_final) < 1e-10,
56        'KE_initial': KE_initial, 'KE_final': KE_final,
57        'KE_ratio': KE_final / KE_initial if KE_initial > 0 else 0,
58        'impulse_on_1': J1, 'impulse_on_2': J2,
59        'impulse_equal_opposite': abs(J1 + J2) < 1e-10  # Newton's 3rd law
60    }
61
62def car_crash_analysis():
63    """
64    Real-world example: Car crash analysis using impulse-momentum.
65
66    This demonstrates how engineers use these principles for safety design.
67    """
68    print("\nCar Crash Safety Analysis")
69    print("=" * 60)
70
71    # Car parameters
72    m_car = 1500  # kg
73    v_initial = 27.8  # m/s (100 km/h)
74    v_final = 0  # m/s (comes to rest)
75
76    # Calculate required impulse
77    impulse_required = m_car * (v_final - v_initial)
78
79    print(f"Car mass: {m_car} kg")
80    print(f"Initial speed: {v_initial} m/s ({v_initial * 3.6:.0f} km/h)")
81    print(f"Impulse to stop: J = Δp = {impulse_required:.0f} N·s")
82
83    # Compare different stopping scenarios
84    scenarios = [
85        ("Hitting a wall (rigid)", 0.05),      # 50 ms
86        ("Crumple zone", 0.15),                 # 150 ms
87        ("Crumple zone + airbag", 0.25),       # 250 ms
88    ]
89
90    print("\n" + "-" * 60)
91    print(f"{'Scenario':<30} {'Δt (ms)':<10} {'Avg Force (kN)':<15}")
92    print("-" * 60)
93
94    for name, delta_t in scenarios:
95        # Impulse = Force × Time → Force = Impulse / Time
96        avg_force = abs(impulse_required) / delta_t
97        # Compare to body weight (deceleration in g's)
98        g_force = avg_force / (m_car * 9.81)
99
100        print(f"{name:<30} {delta_t*1000:<10.0f} {avg_force/1000:<15.1f}")
101
102    print("-" * 60)
103    print("\nKey insight: Same impulse, but LONGER TIME = LOWER FORCE")
104    print("This is why crumple zones and airbags save lives!")
105
106    return scenarios
107
108# Example: Billiard Ball Collision
109print("Example: Billiard Ball Collision (Elastic)")
110print("=" * 60)
111
112m_ball = 0.17  # kg (standard billiard ball)
113v1i = 2.0  # m/s (cue ball moving)
114v2i = 0.0  # m/s (target ball at rest)
115
116result = analyze_collision(m_ball, v1i, m_ball, v2i, 'elastic')
117
118print(f"Ball mass: {m_ball} kg each")
119print(f"Cue ball: v_i = {result['v1_initial']} m/s → v_f = {result['v1_final']:.4f} m/s")
120print(f"Target:   v_i = {result['v2_initial']} m/s → v_f = {result['v2_final']:.4f} m/s")
121print(f"\nMomentum conserved: {result['momentum_conserved']}")
122print(f"KE conserved: {result['KE_ratio']:.4f} (should be 1.0 for elastic)")
123print(f"\nImpulse on cue ball: {result['impulse_on_1']:.4f} N·s")
124print(f"Impulse on target: {result['impulse_on_2']:.4f} N·s")
125print(f"Equal & opposite: {result['impulse_equal_opposite']} (Newton's 3rd law)")
126
127# Car crash analysis
128car_crash_analysis()

Common Mistakes to Avoid

Mistake 1: Confusing momentum with kinetic energy

Momentum ( $p = mv$ ) and kinetic energy ( $KE = \frac{1}{2}mv^2$ ) are different quantities! Momentum is a vector (has direction), kinetic energy is a scalar. Momentum is always conserved in collisions; KE is only conserved in elastic collisions.

Mistake 2: Forgetting momentum is a vector

In one dimension, keep track of signs! If right is positive, a ball moving left has negative momentum. When setting up equations, assign consistent directions.

Mistake 3: Using F = ma for variable mass

When mass changes (like rockets), use $F = \frac{dp}{dt}$ , not $F = ma$ . The momentum form of Newton's second law is more general.

Mistake 4: Assuming constant force

Real forces vary with time. Always check whether a force is constant before using $J = F \cdot \Delta t$ . When in doubt, integrate: $J = \int F(t) \, dt$ .

Test Your Understanding

Summary

Impulse and momentum provide a powerful framework for analyzing motion and collisions. Integration is essential when forces vary with time.

Key Formulas

Quantity	Formula	Notes
Momentum	p = mv	Vector quantity (kg·m/s)
Impulse (constant F)	J = F·Δt	Area of rectangle under F-t curve
Impulse (variable F)	J = ∫F(t)dt	Area under F-t curve
Impulse-Momentum Theorem	J = Δp	Impulse equals momentum change
Conservation	Σp_before = Σp_after	No external forces

Key Takeaways

Momentum ( $\vec{p} = m\vec{v}$ ) quantifies "quantity of motion" and is the fundamental quantity in Newton's second law.
Impulse is force integrated over time. For variable forces, $J = \int F(t) \, dt$ — calculus is essential!
The impulse-momentum theorem ( $J = \Delta p$ ) connects force and motion through integration.
Momentum is conserved in collisions when there are no external forces, allowing us to analyze collisions without knowing the complex collision forces.
Safety engineering exploits $F = J/\Delta t$ : extending collision time reduces peak forces.
Physics simulations use impulse-based methods to update object velocities efficiently and accurately.

The Core Insight:

"The integral of force over time tells us how much an object's motion changes. This is the impulse-momentum theorem — calculus connecting force to velocity."

Coming Next: In Section 10, we'll explore Moment of Inertia and Rotational Dynamics — extending these ideas from linear motion to rotation, where integration plays an equally crucial role.