The Mathematics of Coupled Oscillators

The mathematical core of a CPG is simpler than the biology suggests. Start with the simplest possible oscillator.

Represent one rhythmic unit by a single variable, its phase $\theta$, a number that advances continuously and wraps around at $2\pi$. Its dynamics are one equation:

$\dot{\theta} = \omega$

The phase advances at constant rate $\omega$, the intrinsic frequency. Output any periodic function of the phase, typically a sinusoid, and you have a rhythm.

The reason to work with phase rather than the output signal directly is that phase makes relationships between oscillators expressible. Two oscillators are in step if their phases match, in antiphase if they differ by $\pi$, and locomotion is largely about maintaining such relationships.

A phase alone has no amplitude, so practical CPGs use an amplitude-phase formulation, adding a second variable r whose dynamics converge to a target amplitude. That gives independent control of how fast the rhythm runs and how large the resulting motion is, which maps directly onto frequency and stride length.

Everything that follows is built from coupling these units together.

The amplitude equation is where the robustness comes from, and it is worth seeing why.

A typical form drives the amplitude toward a target R:

$\ddot{r} = a\left(\frac{a}{4}(R - r) - \dot{r}\right)$

The details matter less than the behaviour: whatever amplitude the system starts at, it converges smoothly to R and stays there.

Combined with the advancing phase, the system's trajectory in state space settles onto a closed loop, a circle of radius R traversed at rate $\omega$. That closed orbit is a limit cycle, and it is attracting: perturb the state off it and the dynamics bring it back.

Contrast this with tracking a stored trajectory. If a disturbance knocks a trajectory-tracking robot off its reference, the controller must detect the error and drive it to zero, and the reference itself keeps advancing on its own clock regardless of what the robot is doing.

A limit cycle system has no reference to fall behind. Push it and it returns to the orbit, having naturally adjusted its phase rather than accumulating a tracking error.

This is stability as a property of the system's dynamics rather than as a job assigned to a controller, and it is why CPG-driven robots tolerate rough terrain without special handling.

One oscillator gives rhythm. Locomotion needs coordination, and coordination comes from coupling.

Add to each oscillator's phase equation a term depending on its neighbours' phases:

$\dot{\theta}_i = \omega_i + \sum_{j} w_{ij} \sin(\theta_j - \theta_i - \phi_{ij})$

Three ingredients control everything.

$w_{ij}$ is the coupling strength: how hard oscillator j pulls on oscillator i.

$\phi_{ij}$ is the desired phase bias: the relationship the coupling drives toward.

The sine term is the error. When the actual phase difference $\theta_j - \theta_i$ equals $\phi_{ij}$, the sine is zero and the coupling does nothing. Otherwise it pushes to correct the difference, in the direction that reduces it.

So the coupling is a restoring force on phase relationships. Given enough coupling strength relative to the spread of intrinsic frequencies, the oscillators lock into the specified relative phases and run at a common frequency.

That locking is the whole mechanism. A gait is nothing more than a set of phase relationships between limbs, and the coupling parameters encode it.

The claim becomes concrete when you write out the quadruped gaits. Number the legs left front, right front, left hind, right hind, and give each leg's phase as a fraction of the cycle.

Trot        LF 0.0   RF 0.5   LH 0.5   RH 0.0
            diagonal pairs move together

Pace        LF 0.0   RF 0.5   LH 0.0   RH 0.5
            lateral pairs move together

Bound       LF 0.0   RF 0.0   LH 0.5   RH 0.5
            front pair, then hind pair

Walk        LF 0.0   RF 0.5   LH 0.25  RH 0.75
            one foot lifted at a time

Every gait is the same oscillator network with different phase biases. Nothing else changes: not the equations, not the number of oscillators, not the amplitude dynamics.

This is a large simplification of the control problem. Switching gait means interpolating a handful of numbers, and because the coupling drives smoothly toward the new relationships, the transition is continuous rather than a discontinuous jump between two stored trajectories.

Animals switch gaits at particular speeds, and the same structure appears in CPG models: as drive changes, the stable phase configuration can shift, which is the subject of the next lesson.

The pipeline is short, and each stage maps to a parameter you can set. Frequency sets speed, amplitude sets stride, and phase biases set the gait, with the limit cycle providing robustness underneath all of it.

Swimming uses the same machinery with a different coupling topology, and the result is worth seeing because it explains the salamander.

Arrange oscillators in a chain along the body, each coupled to its immediate neighbours, and set a small constant phase lag between adjacent segments. Segment 2 lags segment 1 by a small amount, segment 3 lags segment 2 by the same amount, and so on.

The result is a travelling wave: the bending pattern propagates from head to tail, which is precisely how a lamprey or eel swims.

Two parameters carry the behaviour. The total phase lag across the body determines how many wavelengths fit along it, and setting it to about one full cycle produces roughly one wavelength on the body, matching what real anguilliform swimmers do. Reversing the sign of the lag reverses the wave direction and swims the robot backwards.

Standing waves come from the same chain with zero lag, so all segments bend in phase.

So one chain of coupled oscillators produces a travelling wave for swimming or a standing wave for walking, depending on a single parameter. That is the mathematical form of the evolutionary hypothesis: the same circuit, differently modulated, does both.

The whole controller is short enough to read.

import numpy as np

def cpg_step(theta, r, omega, R, W, PHI, a, dt):
    n = len(theta)
    dtheta = omega.copy()

    # phase coupling: pull toward the desired phase biases
    for i in range(n):
        for j in range(n):
            if W[i, j] != 0:
                dtheta[i] += W[i, j] * np.sin(theta[j] - theta[i] - PHI[i, j])

    # amplitude converges smoothly toward its target
    dr = a * (R - r)

    theta = (theta + dtheta * dt) % (2 * np.pi)
    r = r + dr * dt

    joint_cmd = r * np.cos(theta)      # output signal
    return theta, r, joint_cmd

The control interface is exactly three things. omega sets speed. R sets stride amplitude. PHI sets the gait.

Notice what is absent. There is no trajectory, no reference to track, no error to compute, no plan to store or re-plan. The commands emerge from integrating a small set of coupled differential equations, and the cost is a handful of arithmetic operations per timestep, cheap enough for a microcontroller.

That is the practical payoff of the whole formulation, and the next lesson shows it running on a real amphibious robot.

A summary of the design surface, since tuning a CPG means choosing these.

Two gotchas that appear immediately in practice.

Coupling strength is a genuine trade-off. Too weak and the oscillators fail to lock, so the gait falls apart under load or when intrinsic frequencies differ. Too strong and the network becomes rigid, unable to be entrained by sensory feedback, which throws away one of the architecture's main advantages.

Turning comes from asymmetry, not steering. There is no steering input. You turn by making one side's amplitude larger than the other's, or by biasing the phase relationship between them, so direction is a modulation of the same rhythm rather than a separate control channel.

That pattern, everything as modulation of one running pattern, is what the next lesson demonstrates on hardware.