// Second-Order ODE as a First-Order System — Manimo lesson scene.
// Chapter 4 / week 9 of mat2b. Walks the universal trick:
// y'' + p y' + q y = 0 → (y, v)' = A (y, v), with A = [[0,1],[-q,-p]]
// closing with a small phase-plane glimpse to motivate why the system form
// matters: every numerical method and every eigen-analysis is built for
// first-order systems.
//
// Concrete example used:
// damped oscillator y'' + 0.4 y' + 1.0 y = 0
// so p = 0.4, q = 1.0, companion A = [[0, 1], [-1, -0.4]]
//
// Beats:
// 0– 4.6 Manimo hook
// 4.6–12 The second-order equation appears
// 12–20 Introduce v = y' — derive v' = -p v - q y
// 20–28 Stack to matrix form, glimpse the phase-plane spiral
// 28–end Hero outro
//
// Colour discipline:
// chalk-100 primary text
// chalk-300 the secondary derivation lines
// violet-400 y column / state position
// teal-400 v column / state velocity
// amber-400 the matrix machine A
// amber-300 takeaway accent
const SCENE_DURATION = 60;
const NARRATION = [
"Why do we keep rewriting second-order equations as first-order systems? Because every numerical method, every matrix tool, is built for first order.",
"Start with a linear second-order equation. y double prime plus p times y prime plus q times y equals zero. One unknown function, two derivatives in play.",
"Introduce a second unknown — call it v, and define it to be y prime. Then v prime is y double prime, which the equation tells us equals minus p v minus q y.",
"Stack y and v into a state vector. Its time derivative is a two by two matrix times itself. A second-order scalar equation has become a first-order vector equation — ready for Euler, R K four, or eigenvector analysis.",
"One scalar second-order equation becomes a first-order system in twice as many unknowns. Same dynamics — friendlier toolbox.",
];
const NARRATION_AUDIO = 'audio/second-order-to-system/scene.mp3';
// Example: y'' + 0.4 y' + 1.0 y = 0 (mildly damped oscillator).
const P_COEF = 0.4;
const Q_COEF = 1.0;
// ─── Helpers ──────────────────────────────────────────────────────────────
function SoftPanel({ children, right = 64, top = 196, width = 380, left, bottom, transform }) {
const positioning = left != null || bottom != null
? { left, bottom, top: top != null && bottom == null ? top : undefined, right: undefined, transform }
: { right, top, transform };
return (
{children}
);
}
// Generic "math card" used in the derivation. Renders a labelled
// translucent panel with an italic formula inside.
function Card({ children, color = 'var(--chalk-100)', size = 36, delay = 0,
width = 520, align = 'center' }) {
return (
{children}
);
}
// ─── Scene ────────────────────────────────────────────────────────────────
function Scene() {
return (
);
}
// ─── Beat 1: Manimo intro ─────────────────────────────────────────────────
function ManimoBubbleIntro() {
return (
One trick. Every tool opens up.
);
}
// ─── Beat 2: The second-order ODE ─────────────────────────────────────────
function SecondOrderBeat() {
return (
<>
one scalar equation
y′′+py′+qy= 0
Linear, homogeneous, constant coefficients.
Two derivatives in play.
example: p = 0.4,
q = 1.0
(mildly damped oscillator)
y′ becomes v. y″ becomes v′. The original equation is now a rule for v′.
);
}
// ─── Beat 4: Matrix form + phase-plane glimpse ────────────────────────────
function MatrixFormBeat() {
const { localTime } = useSprite();
// Phase plane trace: integrate (y, v)' = A (y, v) with y(0)=1, v(0)=0.
// Mild damping → inward spiral toward origin.
const tracePts = (() => {
const pts = [];
let y = 1.2, v = 0;
const dt = 0.05;
const N = 280;
// Centre of small phase panel on stage at (760, 380), 60 px per unit.
const PX = 880, PY = 400, U = 80;
pts.push({ sx: PX + y * U, sy: PY - v * U });
for (let i = 0; i < N; i++) {
const dy = v;
const dv = -Q_COEF * y - P_COEF * v;
y = y + dt * dy;
v = v + dt * dv;
pts.push({ sx: PX + y * U, sy: PY - v * U });
}
return pts;
})();
const traceReveal = clamp((localTime - 3.0) / 4.0, 0, 1);
const visTraceCount = Math.floor(tracePts.length * traceReveal);
const tracePath = tracePts.slice(0, Math.max(2, visTraceCount))
.map((p, i) => `${i === 0 ? 'M' : 'L'} ${p.sx.toFixed(1)} ${p.sy.toFixed(1)}`).join(' ');
return (
<>
stack into a system
{/* State vector */}
y],
[v],
]}
size={28}
/>
′ = −q,
−p],
]}
size={26}
/>
y],
[v],
]}
size={28}
/>
A first-order vector equation. A is the companion matrix.
eigen-analysis of A → solution structure
{/* Phase-plane glimpse on the right */}
);
}
// Bracketed matrix component for inline display.
function BracketMatrix({ rows, size = 22 }) {
const cols = rows[0].length;
const isColumnVec = cols === 1;
return (
{rows.flatMap((r, ri) => r.map((cell, ci) => (
{cell}
)))}
);
}
// ─── Beat 5: Hero outro ───────────────────────────────────────────────────
function HeroOutro() {
return (
companion form
An order-n scalar equation
becomes an order-one system in n unknowns.
Same dynamics — friendlier toolbox.
euler · rk4 · eigenvectors · phase plane — all unlocked