Angular Momentum Display: Three Weighted Rotating Arms
- Fellow Traveler
- 2 days ago
- 9 min read
Classical Method vs. Ledger Method
The Physical Setup
System: Three rigid arms connected at pivot joints, free to rotate in a vertical plane.
○ Fixed pivot (ceiling/stand)
|
● Mass m₁, arm length L₁, angle θ₁
|
○ Joint 1
|
● Mass m₂, arm length L₂, angle θ₂
|
○ Joint 2
|
● Mass m₃, arm length L₃, angle θ₃
What makes this hard:
Each segment's position depends on all previous angles
The equations of motion are coupled and nonlinear
The system is chaotic—tiny changes in initial conditions produce wildly different trajectories
Energy sloshes between segments unpredictably
PART A: Classical Method (Lagrangian Mechanics)
A1. Define Generalized Coordinates
We choose angles measured from vertical:
θ₁ = angle of first arm from vertical
θ₂ = angle of second arm from vertical (not relative to first arm)
θ₃ = angle of third arm from vertical
State vector: (θ₁, θ₂, θ₃, θ̇₁, θ̇₂, θ̇₃)
A2. Position of Each Mass
The position of each mass depends on all previous angles:
Mass 1:
x₁ = L₁ sin(θ₁)
y₁ = -L₁ cos(θ₁)
Mass 2:
x₂ = L₁ sin(θ₁) + L₂ sin(θ₂)
y₂ = -L₁ cos(θ₁) - L₂ cos(θ₂)
Mass 3:
x₃ = L₁ sin(θ₁) + L₂ sin(θ₂) + L₃ sin(θ₃)
y₃ = -L₁ cos(θ₁) - L₂ cos(θ₂) - L₃ cos(θ₃)
A3. Velocities (This Is Where It Gets Ugly)
Differentiate positions with respect to time:
Mass 1:
ẋ₁ = L₁ cos(θ₁) θ̇₁
ẏ₁ = L₁ sin(θ₁) θ̇₁
Mass 2:
ẋ₂ = L₁ cos(θ₁) θ̇₁ + L₂ cos(θ₂) θ̇₂
ẏ₂ = L₁ sin(θ₁) θ̇₁ + L₂ sin(θ₂) θ̇₂
Mass 3:
ẋ₃ = L₁ cos(θ₁) θ̇₁ + L₂ cos(θ₂) θ̇₂ + L₃ cos(θ₃) θ̇₃
ẏ₃ = L₁ sin(θ₁) θ̇₁ + L₂ sin(θ₂) θ̇₂ + L₃ sin(θ₃) θ̇₃
A4. Kinetic Energy
T = ½m₁(ẋ₁² + ẏ₁²) + ½m₂(ẋ₂² + ẏ₂²) + ½m₃(ẋ₃² + ẏ₃²)
Expanding this produces cross-terms like:
T = ½m₁L₁²θ̇₁²
+ ½m₂[L₁²θ̇₁² + L₂²θ̇₂² + 2L₁L₂cos(θ₁-θ₂)θ̇₁θ̇₂]
+ ½m₃[L₁²θ̇₁² + L₂²θ̇₂² + L₃²θ̇₃²
+ 2L₁L₂cos(θ₁-θ₂)θ̇₁θ̇₂
+ 2L₁L₃cos(θ₁-θ₃)θ̇₁θ̇₃
+ 2L₂L₃cos(θ₂-θ₃)θ̇₂θ̇₃]
This is already a wall of symbols, and we haven't even started.
A5. Potential Energy
V = m₁gy₁ + m₂gy₂ + m₃gy₃
= -m₁gL₁cos(θ₁)
- m₂g[L₁cos(θ₁) + L₂cos(θ₂)]
- m₃g[L₁cos(θ₁) + L₂cos(θ₂) + L₃cos(θ₃)]
A6. Lagrangian and Equations of Motion
Form the Lagrangian:
L = T - V
Apply Euler-Lagrange equations for each coordinate:
d/dt(∂L/∂θ̇ᵢ) - ∂L/∂θᵢ = 0 for i = 1, 2, 3
This produces three coupled second-order nonlinear differential equations.
For a triple pendulum with general masses and lengths, each equation fills most of a page. The terms include:
θ̈₁, θ̈₂, θ̈₃ (angular accelerations)
Products of angular velocities: θ̇₁θ̇₂, θ̇₁θ̇₃, θ̇₂θ̇₃
Trigonometric functions: sin(θᵢ - θⱼ), cos(θᵢ - θⱼ)
A7. Numerical Integration
Because these equations are nonlinear and coupled, we solve them numerically:
Rewrite as six first-order equations
Choose initial conditions: (θ₁⁰, θ₂⁰, θ₃⁰, θ̇₁⁰, θ̇₂⁰, θ̇₃⁰)
Use Runge-Kutta or similar integrator
Step forward in time
Record trajectory
What you get:
Position of each mass over time
Angular velocities over time
Total energy (should be conserved in ideal case)
What's implicit or often skipped:
Where energy is at any moment (which segment has how much)
Why certain trajectories are forbidden
What happens when energy transfers between segments
Endpoint condition (when does it "settle"?)
PART B: Ledger Method (Same Physics, Different Discipline)
B1. Templates Required
From the Physics Template Library:
# | Template | Role in This Problem |
1 | Inertial Motion | Default behavior without interaction |
2 | Force–Acceleration | Gravity acts on each mass |
3 | Constraint | Joints enforce fixed arm lengths |
4 | Momentum Conservation | Total angular momentum conserved (if no external torque) |
5 | Torque & Rotation | Forces at distance from pivot produce angular acceleration |
6 | Energy Partition | Energy shuffles between segments; total fixed |
9 | Friction | (If damped) Mechanical → heat |
20 | Equilibrium | (If damped) When motion stops |
B2. The Ledger View of the State
At any instant, the Ledger contains:
Ledger Entry:
θ₁, θ₂, θ₃ — angles
θ̇₁, θ̇₂, θ̇₃ — angular velocities
KE₁, KE₂, KE₃ — kinetic energy per segment
PE₁, PE₂, PE₃ — potential energy per segment
E_total — total mechanical energy
The Ledger doesn't just store the configuration—it stores the energy budget per segment.
B3. Draft Space
Question: What states are allowed at the next instant?
Draft definition: All configurations (θ₁', θ₂', θ₃', θ̇₁', θ̇₂', θ̇₃') such that:
Constraint Template satisfied:
Arms remain rigid (L₁, L₂, L₃ unchanged)
Joints remain connected
Top pivot remains fixed
Energy Partition Template satisfied:
E_total remains constant (no Ink in frictionless case)
Energy may redistribute among KE₁, KE₂, KE₃, PE₁, PE₂, PE₃
Locality satisfied:
Each segment can only directly influence its neighbors
No action at a distance within the system
What's forbidden:
Arms passing through each other
Energy appearing from nowhere
Segment 3 directly affecting segment 1 without going through segment 2
B4. Vote: What Selects the Next State?
At each Δt, multiple "Votes" occur simultaneously:
Vote 1: Gravity Each mass experiences F = mg downward. Using Force–Acceleration + Torque & Rotation templates:
τᵢ = rᵢ × Fᵢ
θ̈ᵢ contribution from gravity
Vote 2: Tension at joints Each joint transmits force between segments. Using Constraint Template:
Joint forces adjust to maintain rigid connections
These are "constraint forces"—they do no net work but redirect motion
Vote 3: Angular momentum transfer When segment 1 slows, segment 2 may speed up. Using Momentum Conservation + Torque & Rotation:
Total angular momentum constant (if top pivot allows rotation)
Or: Angular momentum of each segment changes due to internal torques
The Vote is the combination of all these interactions selecting one trajectory from the Draft space.
B5. Ink: What's the Irreversibility Cost?
Case A: Ideal (frictionless) system
No Ink is spent. This is a reversible system.
Total mechanical energy is exactly conserved
Play the movie backward and it's still valid physics
The Ledger updates, but no entropy is produced
This is unusual. Most real processes spend Ink. The ideal pendulum is pedagogically useful precisely because it's an Ink-free limiting case.
Case B: Damped system (friction at joints)
Now Ink is spent at every Vote:
Ink per timestep:
ΔE_friction = energy dissipated at joints
Heat_joint1 += f(θ̇₁, damping_coefficient)
Heat_joint2 += f(θ̇₂, damping_coefficient)
Heat_joint3 += f(θ̇₃, damping_coefficient)
The Ledger must now track:
Ledger Entry (damped):
θ₁, θ₂, θ₃, θ̇₁, θ̇₂, θ̇₃
KE₁, KE₂, KE₃
PE₁, PE₂, PE₃
E_mechanical (decreasing)
Heat_total (increasing)
E_total = E_mechanical + Heat_total (constant)
B6. Energy Budget Per Segment (The Ledger Addition)
This is what the classical method doesn't force you to track.
At each timestep, the Ledger records:
Segment | KE | PE | Total |
Arm 1 | ½I₁θ̇₁² | m₁gy₁ | KE₁ + PE₁ |
Arm 2 | ½m₂v₂² | m₂gy₂ | KE₂ + PE₂ |
Arm 3 | ½m₃v₃² | m₃gy₃ | KE₃ + PE₃ |
System | ΣKE | ΣPE | E_total |
Why this matters:
You can now see the energy sloshing:
Segment 1 slows → its KE drops
Segment 3 speeds up → its KE rises
The PE of each segment rises and falls with height
Total is constant (or decreasing if damped)
Classical mechanics allows you to compute this, but doesn't require it. Ledger mechanics requires it—the Energy Partition Template won't validate without it.
B7. Constraint Template: Why the Arms Don't Fly Apart
Classical mechanics buries this in "constraint forces" that are solved implicitly through the Lagrangian.
Ledger mechanics makes it explicit:
Constraint Template applied:
For each joint j:
|position(mass_j) - position(pivot_j)| = Lⱼ # arm length fixed
If violated:
project back to allowed configuration
constraint force = whatever is needed to maintain this
The Constraint Template prunes the Draft space. It removes all configurations where arms stretch, compress, or disconnect.
This is the same physics, but now the constraint is visible as a first-class citizen rather than hidden in the mathematics.
B8. Equilibrium Template: When Is It "Done"?
Classical answer: In ideal case, never. The system oscillates forever.
Ledger answer (damped case):
Apply Equilibrium Template:
function isInEquilibrium(system):
if max(|θ̇₁|, |θ̇₂|, |θ̇₃|) > ε: return false
if mechanical_energy > E_min + ε: return false
return true
Equilibrium means:
All angular velocities ≈ 0
All arms hanging straight down (minimum PE configuration)
No gradients driving further motion
All mechanical energy converted to heat
The Ledger endpoint is richer than "motion stopped."
B9. Numerical Implementation: Side by Side
Classical Implementation
def simulate_triple_pendulum_classical(θ₀, θ̇₀, T, dt):
"""
Standard Lagrangian approach
"""
state = [θ₀[0], θ₀[1], θ₀[2], θ̇₀[0], θ̇₀[1], θ̇₀[2]]
trajectory = [state]
for t in range(0, T, dt):
# Compute θ̈ from equations of motion (the messy part)
θ̈ = compute_accelerations(state) # Pages of algebra inside
# Update state
state = runge_kutta_step(state, θ̈, dt)
trajectory.append(state)
return trajectory
What you track: θ₁, θ₂, θ₃, θ̇₁, θ̇₂, θ̇₃
Ledger Implementation
def simulate_triple_pendulum_ledger(θ₀, θ̇₀, T, dt, damping=0):
"""
Same physics, Ledger bookkeeping
"""
# Initialize Ledger
ledger = {
'θ': list(θ₀),
'θ̇': list(θ̇₀),
'KE': compute_KE_per_segment(θ₀, θ̇₀),
'PE': compute_PE_per_segment(θ₀),
'E_mech': None,
'Heat': [0, 0, 0], # Per joint
'E_total': None
}
ledger['E_mech'] = sum(ledger['KE']) + sum(ledger['PE'])
ledger['E_total'] = ledger['E_mech']
history = [copy(ledger)]
for t in range(0, T, dt):
# === DRAFT ===
# All configurations reachable in dt that satisfy:
# - Constraint Template (arms rigid)
# - Energy Partition Template (E_total constant or decreasing)
# === VOTE ===
# Gravity + joint tensions + damping select actual trajectory
θ̈ = compute_accelerations(ledger['θ'], ledger['θ̇'])
# Apply damping (if any)
if damping > 0:
θ̈_damped, ΔE_friction = apply_damping(ledger['θ̇'], damping)
θ̈ = θ̈_damped
else:
ΔE_friction = [0, 0, 0]
# === INK ===
# Record irreversible energy loss (if damped)
for i in range(3):
ledger['Heat'][i] += ΔE_friction[i]
# === LEDGER UPDATE ===
# Update angles and velocities
ledger['θ'], ledger['θ̇'] = integrate_step(
ledger['θ'], ledger['θ̇'], θ̈, dt
)
# Update energy budget per segment
ledger['KE'] = compute_KE_per_segment(ledger['θ'], ledger['θ̇'])
ledger['PE'] = compute_PE_per_segment(ledger['θ'])
ledger['E_mech'] = sum(ledger['KE']) + sum(ledger['PE'])
# === VALIDATION ===
# Energy Partition Template check
E_check = ledger['E_mech'] + sum(ledger['Heat'])
assert abs(E_check - ledger['E_total']) < ε, "Ledger violation!"
history.append(copy(ledger))
return history
What you track: θ, θ̇, KE per segment, PE per segment, Heat per joint, E_total
B10. What the Ledger Method Adds
Aspect | Classical Only | Classical + Ledger |
Equations | Same | Same |
Trajectory | Same | Same |
Energy total | Can compute | Must compute |
Energy per segment | Optional | Required |
Constraints | Implicit (Lagrange multipliers) | Explicit (Template) |
Irreversibility | Hidden in damping term | Explicit as Ink |
Endpoint | "Motion stops" | "No gradients, energy fully dissipated" |
Debugging | Check E_total | Check E_total AND segment budgets AND Ink trail |
Forbidden states | Implicit in math | Explicit in Draft pruning |
B11. Visualization: The Energy Sloshing
Classical visualization: Plot θ₁(t), θ₂(t), θ₃(t)
Ledger visualization: Plot energy budget over time
Time →
KE₁ ████░░░░░████░░░░░████░░░░░░░░
KE₂ ░░░░████░░░░░████░░░░░████░░░░
KE₃ ░░░░░░░░██░░░░░░░░██░░░░░░░██░
PE ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
Heat ░░░░░░░░░░░░░░░░░░░░░░░░░░████ (damped case)
─────────────────────────────
E_tot ════════════════════════════════ (constant line)
You can literally see energy flowing between segments, and in the damped case, draining into heat.
B12. The Chaos Question
Classical observation: Triple pendulum is chaotic. Tiny changes in initial conditions lead to wildly different trajectories.
Ledger interpretation:
The Draft space at each instant is enormous—many trajectories are allowed by the constraints. The Vote (gravity + tensions) selects one. But the selection is exquisitely sensitive to the exact state.
In Ledger terms:
The Draft space is well-defined (all configurations satisfying constraints and energy budget)
The Vote mechanism is deterministic (same physics every time)
But the input to the Vote (exact current state) determines which allowed trajectory is selected
Measurement uncertainty in initial conditions means we can't predict which Draft will be Voted into the Ledger
Chaos is not randomness. It's deterministic Vote selection operating on a state we can't measure precisely enough.
B13. Exercise for the Student
Task: Consider the three-segment system with:
m₁ = m₂ = m₃ = 1 kg
L₁ = L₂ = L₃ = 1 m
Initial condition: θ₁ = 90°, θ₂ = θ₃ = 0°, all θ̇ = 0
Light damping at each joint
Questions:
What is the initial Draft space? What configurations are allowed at t = 0 + dt?
What Votes occur during the first timestep? (List the interactions.)
Where does Ink accumulate? Draw a rough sketch of Heat_joint1, Heat_joint2, Heat_joint3 over time.
What is the Equilibrium state? What does the Ledger contain when the system is "done"?
If your simulation shows E_total drifting upward, which Canon constraint is violated? What's wrong with your model?
B14. Meta-Reflection
The triple pendulum is a perfect test case because:
The classical math is genuinely hard. Pages of Lagrangian algebra. This isn't a toy problem.
The Ledger method doesn't simplify the math. The same coupled differential equations must be solved.
But the Ledger method changes what you're obligated to track. Energy per segment. Ink per joint. Explicit constraints. Validation checks.
And it changes what you can debug. When something goes wrong, you know where in the system the problem is—not just "energy isn't conserved" but "segment 2 is gaining energy it shouldn't have."
And it transfers. Once you've done this for a triple pendulum, the same reasoning applies to:
Molecular dynamics (atoms connected by bonds)
Robotic arms (actuated multi-segment systems)
Supply chains (connected flows with constraints)
Neural pathways (signals propagating through connected nodes)
The grammar is the same. Draft → Vote → Ink → Ledger. The templates change. The discipline doesn't.
Henry, want me to generate actual simulation code (Python) that implements both approaches side by side, with visualization of the energy sloshing?
Comments