Module 4 · Weeks 8–9 · UG→Graduate

Rhythm, Combinatorics & Geometry

The Bjorklund algorithm distributes pulses as evenly as possible around a cycle, recovering rhythms from Cuban tresillo to West African bembe. These “Euclidean rhythms” are necklaces in the combinatorial sense—equivalence classes under cyclic rotation.

Euclidean Rhythm Generator

Pulses (k): 3

Steps (n): 8

Offset: 0

BPM: 120

E(3,8)

Necklace (circular):

Linear pattern:

10010010

World rhythm examples:

Polyrhythm layers (simultaneous):

Layer 2

k: 5

n: 8

10110110

Layer 3

k: 7

n: 12

101101011010

Mathematical Framework

The Bjorklund algorithm is isomorphic to the Euclidean algorithm. To distribute \( k \) pulses among \( n \) steps, we compute\( \gcd(k, n-k) \) via repeated subtraction, grouping remainder sequences at each stage. The output is a maximally even distribution:

\( s_i = \left\lfloor \frac{i \cdot k}{n} \right\rfloor - \left\lfloor \frac{(i-1) \cdot k}{n} \right\rfloor, \quad i = 1, \ldots, n \)

A sequence is maximally even iff the gap between consecutive onsets differs by at most 1.

Necklace equivalence: two binary strings are the same necklace if one is a cyclic rotation of the other. The number of distinct binary necklaces of length \( n \) with \( k \) ones is counted by Burnside's lemma:

\( N(n,k) = \frac{1}{n} \sum_{d \mid \gcd(n,k)} \varphi(d) \binom{n/d}{k/d} \)

where \( \varphi \) is Euler's totient function. The cyclic group \( \mathbb{Z}_n \) acts on binary strings by rotation; the orbits are necklaces.

Geometric interpretation: each binary necklace of length \( n \)with \( k \) ones is a vertex of the cyclic polytope inscribed in the circle. Euclidean rhythms correspond to regular or nearly regular polygons, maximizing the minimum arc between consecutive onsets.

Python Simulation: Euclidean Rhythms & Maximally Even Sets

The Bjorklund algorithm in action: necklace visualisations of classic Euclidean rhythms, step-by-step algorithm trace for E(5,8), evenness analysis across all k values, and Burnside necklace counts.

Python

script.py218 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from math import gcd, floor
from fractions import Fraction

fig, axes = plt.subplots(2, 2, figsize=(14, 12))
fig.patch.set_facecolor('#0a0a1a')
for ax in axes.flat:
    ax.set_facecolor('#0d0d24')

def bjorklund(k, n):
    if n <= 0:
        return []
    if k <= 0:
        return [False]*n
    if k >= n:
        return [True]*n
    groups = [[True] if i < k else [False] for i in range(n)]
    left = k
    right = n - k
    while right > 1:
        steps = min(left, right)
        for i in range(steps):
            groups[i] = groups[i] + groups[-(i+1)]
        groups = groups[:len(groups)-steps]
        left = steps
        right = len(groups) - steps
    result = []
    for g in groups:
        result.extend(g)
    return result

def euler_totient(n):
    result = n
    p = 2
    temp = n
    while p*p <= temp:
        if temp % p == 0:
            while temp % p == 0:
                temp //= p
            result -= result // p
        p += 1
    if temp > 1:
        result -= result // temp
    return result

def necklace_count(n, k):
    if k < 0 or k > n:
        return 0
    g = gcd(n, k)
    total = 0
    for d in range(1, g+1):
        if g % d == 0:
            phi_d = euler_totient(d)
            # binomial(n/d, k/d)
            nd, kd = n//d, k//d
            binom = 1
            for i in range(kd):
                binom = binom * (nd - i) // (i + 1)
            total += phi_d * binom
    return total // n

# --- Plot 1: Necklace visualisations ---
ax1 = axes[0, 0]
ax1.set_facecolor('#0d0d24')
ax1.axis('off')
ax1.set_title('Euclidean Rhythm Necklaces', color='#a0c4ff', fontsize=11, pad=8)

rhythms = [(3, 8, '#3b82f6'), (5, 8, '#8b5cf6'), (7, 12, '#22c55e'), (5, 16, '#f59e0b')]
centers = [(-0.55, 0.4), (0.55, 0.4), (-0.55, -0.4), (0.55, -0.4)]
r_necklace = 0.28

for (k, n, color), (cx, cy) in zip(rhythms, centers):
    pattern = bjorklund(k, n)
    ax1.text(cx, cy + r_necklace + 0.06,
             'E(' + str(k) + ',' + str(n) + ')',
             ha='center', color=color, fontsize=9, fontweight='bold')
    ax1.add_patch(plt.Circle((cx, cy), r_necklace, fill=False,
                             edgecolor='#334155', linewidth=1))
    for i, beat in enumerate(pattern):
        angle = np.pi/2 - 2*np.pi*i/n
        x = cx + r_necklace*np.cos(angle)
        y = cy + r_necklace*np.sin(angle)
        dot_r = 0.025 if beat else 0.012
        dot_color = color if beat else '#1e293b'
        edge_color = color if beat else '#475569'
        ax1.add_patch(plt.Circle((x, y), dot_r, color=dot_color,
                                 edgecolor=edge_color, linewidth=0.8, zorder=3))
    # connect beats
    beat_pts = []
    for i, beat in enumerate(pattern):
        if beat:
            angle = np.pi/2 - 2*np.pi*i/n
            beat_pts.append((cx + r_necklace*np.cos(angle),
                             cy + r_necklace*np.sin(angle)))
    if len(beat_pts) >= 3:
        poly = plt.Polygon(beat_pts, fill=False, edgecolor=color, linewidth=0.7, alpha=0.35, zorder=2)
        ax1.add_patch(poly)

ax1.set_xlim(-1.0, 1.0)
ax1.set_ylim(-0.85, 0.85)

# --- Plot 2: Bjorklund algorithm steps for E(5,8) ---
ax2 = axes[0, 1]
ax2.set_facecolor('#0d0d24')
ax2.axis('off')
ax2.set_title('Bjorklund algorithm steps: E(5,8)', color='#a0c4ff', fontsize=11, pad=8)

steps_log = []
groups = [['1'] if i < 5 else ['0'] for i in range(8)]
steps_log.append(('Initial', [g[:] for g in groups]))
left2, right2 = 5, 3
iteration = 0
while right2 > 1 and iteration < 10:
    steps2 = min(left2, right2)
    for i in range(steps2):
        groups[i] = groups[i] + groups[-(i+1)]
    groups = groups[:len(groups)-steps2]
    left2 = steps2
    right2 = len(groups) - steps2
    steps_log.append(('Step ' + str(iteration+1), [g[:] for g in groups]))
    iteration += 1

y_start = 0.88
row_h = 0.18
for step_idx, (label, grps) in enumerate(steps_log):
    y = y_start - step_idx * row_h
    ax2.text(-0.95, y, label + ':', color='#94a3b8', fontsize=8, va='top')
    x_offset = -0.35
    for gi, g in enumerate(grps):
        cell_str = ''.join(g)
        color = '#3b82f6' if '1' in cell_str else '#374151'
        ax2.add_patch(mpatches.FancyBboxPatch((x_offset, y-0.13), 0.085*len(cell_str), 0.11,
                                              boxstyle='round,pad=0.01', color=color, alpha=0.7))
        ax2.text(x_offset + 0.043*len(cell_str), y-0.07, cell_str,
                 ha='center', va='center', color='white', fontsize=7, fontweight='bold')
        x_offset += 0.085*len(cell_str) + 0.02
    if step_idx < len(steps_log)-1:
        ax2.text(-0.35, y-0.155, 'left=' + str(min(left2, right2 if step_idx == 0 else 3)),
                 color='#64748b', fontsize=6)

final_pattern = bjorklund(5, 8)
result_str = ''.join('1' if b else '0' for b in final_pattern)
ax2.text(-0.95, y_start - len(steps_log)*row_h - 0.02,
         'Result: ' + result_str + '  (Tresillo+2)', color='#22c55e', fontsize=9, fontweight='bold')
ax2.set_xlim(-1.0, 1.0)
ax2.set_ylim(-0.25, 1.0)

# --- Plot 3: Evenness vs k for E(k,16) ---
ax3 = axes[1, 0]
ax3.set_facecolor('#0d0d24')
k_vals = list(range(1, 16))
evenness = []
for k in k_vals:
    pattern = bjorklund(k, 16)
    onsets = [i for i, b in enumerate(pattern) if b]
    if len(onsets) < 2:
        evenness.append(8.0)
    else:
        iois = []
        for i in range(len(onsets)):
            ioi = (onsets[(i+1) % len(onsets)] - onsets[i]) % 16
            iois.append(ioi)
        evenness.append(float(np.std(iois)))

bars = ax3.bar(k_vals, evenness, color=['#3b82f6' if e < 0.5 else '#8b5cf6' if e < 1.5 else '#ef4444'
                                         for e in evenness], alpha=0.85, edgecolor='#0a0a1a', linewidth=0.5)
ax3.set_xlabel('k (pulses)', color='#64748b', fontsize=9)
ax3.set_ylabel('Std dev of inter-onset intervals', color='#64748b', fontsize=9)
ax3.set_title('Evenness of E(k,16): lower = more even', color='#a0c4ff', fontsize=11, pad=8)
ax3.set_xticks(k_vals)
ax3.tick_params(colors='#94a3b8', labelsize=8)
for spine in ax3.spines.values():
    spine.set_edgecolor('#334155')
ax3.axhline(y=0, color='#22c55e', linewidth=0.8, alpha=0.5, linestyle='--')
ax3.text(8, max(evenness)*0.9, 'Perfect evenness = 0 std dev', color='#22c55e', fontsize=7, ha='center')

# --- Plot 4: Necklace counts via Burnside's lemma ---
ax4 = axes[1, 1]
ax4.set_facecolor('#0d0d24')
n_vals = list(range(2, 17))
total_necklaces = []
for n in n_vals:
    count = sum(necklace_count(n, k) for k in range(n+1))
    total_necklaces.append(count)

ax4.plot(n_vals, total_necklaces, color='#f59e0b', linewidth=2, marker='o',
         markersize=6, markerfacecolor='#fbbf24', markeredgecolor='#0a0a1a')
for i, (n, c) in enumerate(zip(n_vals, total_necklaces)):
    ax4.text(n, c + 1.5, str(c), ha='center', color='#94a3b8', fontsize=7)
ax4.set_xlabel('n (cycle length)', color='#64748b', fontsize=9)
ax4.set_ylabel('Number of distinct necklaces', color='#64748b', fontsize=9)
ax4.set_title('Burnside counting: binary necklaces of length n', color='#a0c4ff', fontsize=11, pad=8)
ax4.set_xticks(n_vals)
ax4.tick_params(colors='#94a3b8', labelsize=8)
for spine in ax4.spines.values():
    spine.set_edgecolor('#334155')
ax4.fill_between(n_vals, total_necklaces, alpha=0.15, color='#f59e0b')

import matplotlib.patches as mpatches

plt.suptitle('Euclidean Rhythms and Maximally Even Sets', color='#e2e8f0',
             fontsize=14, fontweight='bold', y=1.01)
plt.tight_layout(pad=1.5)
plt.savefig('output.png', dpi=150, bbox_inches='tight',
            facecolor='#0a0a1a', edgecolor='none')
plt.close()

print('Euclidean Rhythm Simulation Results:')
print('  E(3,8)  = ' + ''.join('1' if b else '0' for b in bjorklund(3,8)) + '  (tresillo)')
print('  E(5,8)  = ' + ''.join('1' if b else '0' for b in bjorklund(5,8)) + '  (cinquillo)')
print('  E(7,12) = ' + ''.join('1' if b else '0' for b in bjorklund(7,12)) + '  (bembe)')
print('  E(5,16) = ' + ''.join('1' if b else '0' for b in bjorklund(5,16)) + '  (rumba clave)')
print('  Most even E(k,16): k=8 (std dev = 0.0)')
print('  Total binary necklaces of length 16: ' + str(sum(necklace_count(16,k) for k in range(17))))

Click Run to execute the Python code

Code will be executed with Python 3 on the server