Module 7: Collective Intelligence & Swarm Physics

A honeybee colony of 30,000–60,000 individuals makes remarkably accurate collective decisions without any central controller. The mechanisms — quorum sensing, cross-inhibition, marginal value foraging, and response threshold task allocation — are mathematically equivalent to neural decision circuits, optimization algorithms, and self-organizing physical systems. Swarm intelligence is distributed computation in biological hardware.

7.1 Swarm Decision-Making

When a honeybee colony outgrows its hive, it swarms: the queen and approximately 10,000 workers leave and cluster on a nearby branch while several hundred scout bees search for a new nest site. Thomas Seeley's landmark research, detailed in Honeybee Democracy (2010), revealed that the swarm's decision process involves:

1. Independent Discovery

Scout bees (3–5% of the swarm) independently search for candidate nest cavities within a ~10 km radius. Each scout evaluates cavity volume (~40 L preferred), entrance size (~15 cm²), height, and sun exposure using a surprisingly consistent set of criteria.

2. Quality-Dependent Recruitment

Scouts return to the swarm cluster and perform waggle dances. Crucially, the duration of the dance is proportional to site quality — a scout that found an excellent site dances for minutes, while one that found a mediocre site dances briefly. This ensures that better sites recruit more followers.

3. Cross-Inhibition (Stop Signals)

Scouts committed to one site deliver stop signals(brief head-butts) to dancers advertising competing sites. This mutual inhibition ensures that the swarm does not split — only one site can win. The stop signal mechanism is functionally analogous to lateral inhibition in neural circuits.

4. Quorum Threshold

A decision is reached when the number of scouts at a particular site exceeds a quorum threshold (~20–30 bees present simultaneously at the site). Quorum-sensing scouts return to the swarm and trigger the departure by producing piping signals (vibrations that warm up flight muscles colony-wide).

Mathematical Model

The dynamics of scout recruitment to site \(i\) can be described by a system of coupled ODEs. Let \(N_i\) be the number of scouts committed to site \(i\), with \(N_{\text{total}}\) uncommitted scouts available:

\[ \frac{dN_i}{dt} = \underbrace{\alpha_i\!\left(N_{\text{total}} - \sum_j N_j\right)}_{\text{recruitment}} - \underbrace{\beta \cdot N_i}_{\text{cross-inhibition}} + \underbrace{\gamma \cdot \frac{N_i^2}{N_i^2 + K^2}}_{\text{quorum sensing}} \]

where:

\(\alpha_i\) is the recruitment rate for site \(i\), proportional to site quality \(q_i\)
\(\beta\) is the cross-inhibition rate (stop signals from all competing factions)
\(\gamma\) is the quorum amplification strength
\(K\) is the quorum threshold (half-activation number of scouts)

The quorum term \(N_i^2/(N_i^2 + K^2)\) provides a sigmoidal switch: once the population at a site exceeds \(K\), positive feedback accelerates commitment, creating a winner-take-all dynamic. This is mathematically equivalent to a neural decision circuit — specifically, the mutual inhibition model of Usher and McClelland (2001) for perceptual decision-making in primate cortex.

Accuracy vs. Speed Trade-off

Seeley et al. (2012) demonstrated that swarms achieve ~90% accuracy in choosing the best site, even when alternatives differ by only 20% in quality. The cross-inhibition mechanism is key: without stop signals, competing populations grow unchecked and the swarm may split or stall. The speed-accuracy trade-off is governed by the ratio \(\beta/\alpha\): stronger inhibition (\(\beta \uparrow\)) improves accuracy but slows decision time. In typical conditions, swarm decisions take 2–5 days.

7.2 Optimal Foraging Theory

Honeybee foraging involves individual-level optimization (which flowers to visit, when to leave a patch) and colony-level allocation (how many foragers to send to each patch). Both levels can be understood through the framework of optimal foraging theory (OFT), pioneered by Charnov (1976) and extended by Pyke (1984).

Marginal Value Theorem

The marginal value theorem (MVT; Charnov, 1976) predicts the optimal time a forager should spend in a patch before departing. A bee arriving at a flower patch obtains energy \(E(t)\) as a decelerating function of time (nectar is depleted). The total foraging cycle includes travel time\(t_{\text{travel}}\) and patch time \(t_{\text{patch}}\). The long-term average rate of energy gain is:

\[ \bar{R} = \frac{E(t_{\text{patch}})}{t_{\text{travel}} + t_{\text{patch}}} \]

The optimal departure time \(t^*\) maximizes \(\bar{R}\). Setting\(d\bar{R}/dt_{\text{patch}} = 0\):

\[ \left.\frac{dE}{dt}\right|_{t=t^*} = \frac{E(t^*)}{t_{\text{travel}} + t^*} = \bar{R}^* \]

This is the marginal value condition: leave the patch when the instantaneous rate of gain (marginal value) equals the average rate for the entire environment. Graphically, the optimal departure time is found where a line from\(-t_{\text{travel}}\) on the time axis is tangent to the gain curve \(E(t)\).

For a diminishing-returns gain function \(E(t) = E_{\max}(1 - e^{-\lambda t})\), the optimal patch time satisfies:

\[ \lambda E_{\max} e^{-\lambda t^*} = \frac{E_{\max}(1 - e^{-\lambda t^*})}{t_{\text{travel}} + t^*} \]

This transcendental equation must be solved numerically. Key prediction: when travel time increases, foragers should stay longer in each patch (because the opportunity cost of leaving is higher). This has been confirmed in honeybee studies.

Colony-Level Optimization via Waggle Dance

Returning foragers communicate patch quality through waggle dance duration, which is proportional to the profitability of the food source (energy gain rate minus travel cost). High-quality patches attract more recruits, while poor patches are gradually abandoned. This creates a distributed gradient ascenton the colony's fitness landscape, reallocating forager effort toward the most profitable patches without any central planner.

The colony-level allocation converges to an approximate solution of the multi-armed bandit problem. Compared to the ant colony optimization (ACO) algorithm, honeybee foraging has key differences:

Honeybee System

Direct communication (waggle dance)
Quality-proportional recruitment
Individual memory of patch locations
Negative feedback via forager return time

Ant Colony (ACO)

Indirect communication (pheromone trails)
Positive feedback (trail reinforcement)
No individual memory (stigmergy)
Trail evaporation for negative feedback

7.3 Self-Organization Without Central Control

Honeybee colonies exhibit emergent order at multiple scales. Complex global patterns arise from simple local interaction rules — no individual bee has a plan for the colony's overall behavior. This is self-organizationin the strict physical sense.

Comb Construction

Honeycomb construction emerges from local rules. Each worker deposits wax when the local temperature is in the optimal range (35–40°C for wax plasticity) and when neighboring cells provide a template. The wax deposition rate depends on:

\[ r_{\text{deposit}} = r_0 \cdot f(T) \cdot g(\rho_{\text{neighbors}}) \]

where \(f(T)\) is a temperature-dependent plasticity function (bell-shaped, peaking at ~38°C) and \(g(\rho)\) depends on the density of neighboring workers. The hexagonal pattern emerges naturally: circular cells packed together and deformed by surface tension at working temperature spontaneously form hexagons — the solution that minimizes wax usage for a given cell volume (the honeycomb conjecture, proven by Hales, 2001).

Task Allocation: Response Threshold Model

Division of labor in the colony follows the response threshold model (Bonabeau et al., 1996; Page & Mitchell, 1998). Each bee has an individual threshold \(\theta_i\) for each task. When the stimulus level \(s\)for a particular task (e.g., temperature deviation in the brood area) exceeds a bee's threshold, it switches to that task. The probability of engaging in a task follows a sigmoidal response:

\[ P(\text{task}) = \frac{s^n}{s^n + \theta^n} \]

where \(n\) controls the steepness of the response. With \(n = 2\), the transition is gradual; with \(n \geq 4\), it becomes switch-like. The elegant feature is that thresholds vary across individuals (due to both genetics and experience), so as demand increases, progressively more bees are recruited — providing automatic load balancing.

Temporal polyethism (age-based task switching) further structures the division of labor. Young bees (1–12 days) are nurses with low foraging thresholds; middle-aged bees (12–20 days) are builders and food processors; older bees (20+ days) are foragers. This progression is regulated by juvenile hormone (JH), which rises steadily with age. JH levels are modulated by social interactions: contact with older foragers suppresses JH rise in younger bees (via ethyl oleate pheromone), maintaining the age distribution.

Thermoregulatory Self-Organization

The hive maintains brood temperature at 34.5 ± 0.5°C through collective control. Individual bees follow simple rules:

If T > 36°C: fan wings (evaporative cooling) or fetch water to deposit on comb surfaces

If T < 33°C: activate flight muscles isometrically (shivering thermogenesis), cluster more tightly

If 33°C < T < 36°C: continue current task (dead zone for stability)

These local rules produce PID-like control at the colony level, with the thermal mass of the hive providing integral action and the bee density gradient providing proportional response.

7.4 Lévy Flights & Search Patterns

When searching for new food sources, honeybee foragers do not perform simple random walks (Brownian motion). Instead, their flight patterns follow truncated Lévy flights — random walks with a heavy-tailed distribution of step lengths. This search strategy has been observed in many foraging animals (albatrosses, spider monkeys, marine predators) and is thought to be evolutionarily optimal for locating sparse, randomly distributed resources.

Step Length Distribution

A Lévy flight is characterized by a power-law distribution of step lengths:

\[ P(\ell) \sim \ell^{-\mu} \qquad\text{for}\quad \ell > \ell_{\min} \]

where \(\mu\) is the Lévy exponent. The key constraint is\(1 < \mu < 3\): for \(\mu \leq 1\) the distribution is not normalizable; for \(\mu \geq 3\) the variance is finite and the central limit theorem drives the walk toward Brownian motion. The critical regimes are:

\(\mu = 2\): Inverse-square Lévy flight — optimal for searching in environments with randomly and sparsely distributed targets (Viswanathan et al., 1999). Balances between local exploitation (many short steps) and long-range exploration (occasional long flights).

\(\mu \to 3\): Approaches Brownian motion — efficient for dense, uniformly distributed resources where local search is sufficient.

\(\mu \to 1\): Ballistic motion — straight-line flights, useful when targets are known to be far away.

Mean First-Passage Time

The efficiency of a search strategy can be quantified by the mean first-passage time (MFPT) to locate a target. For Lévy flights in \(d\)dimensions with target density \(\rho\):

\[ \langle T \rangle \propto \rho^{-1} \cdot \ell_{\min}^{\mu-1} \cdot f(\mu, d) \]

For \(d = 2\) (planar foraging), the MFPT is minimized at \(\mu \approx 2\)when targets are sparse and non-depleting, confirming the optimality of the inverse-square Lévy flight. When targets are destructively sampled (visited once), the optimal strategy shifts toward \(\mu \approx 1.5\) (more ballistic).

Comparison: Lévy vs. Brownian

The mean-squared displacement after \(N\) steps differs fundamentally:

\[ \langle r^2 \rangle \sim \begin{cases} N & \text{Brownian motion (diffusive)} \\ N^{2/({\mu-1})} & \text{Lévy flight with } 1 < \mu < 3 \\ N^2 & \text{Ballistic (}\mu \to 1\text{)} \end{cases} \]

Lévy flights are superdiffusive: the searcher covers territory faster than Brownian motion, with occasional long-range relocations that prevent over-searching the same area. Bee foragers appear to use a composite strategy: Lévy-like exploration when searching for new patches, and systematic local scanning (correlated random walk) when exploiting a known patch.

7.5 Swarm Decision-Making Diagram

Schematic of the nest-site selection process. Scouts discover three candidate sites of different quality, return to the swarm cluster to advertise via waggle dances, and send stop signals to competing factions. The best site (A) reaches quorum first.

7.6 Simulation: Agent-Based Swarm Decision Model

This simulation models 500 scouts choosing between 3 nest sites of different quality. The model implements quality-dependent recruitment, cross-inhibition (stop signals), and quorum sensing. We compare the swarm dynamics with a neural integrator model to demonstrate the mathematical equivalence.

Swarm Decision-Making: Agent-Based Model vs Neural Integrator

Python

script.py215 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

np.random.seed(42)

# ─── Parameters ───
N_total = 500       # total scouts
dt = 0.1            # time step (hours)
T_max = 80          # total simulation time (hours)
steps = int(T_max / dt)

# Site qualities
qualities = [0.9, 0.5, 0.2]  # Site A (best), B (medium), C (poor)
n_sites = len(qualities)
site_names = ['Site A (q=0.9)', 'Site B (q=0.5)', 'Site C (q=0.2)']
site_colors = ['#22c55e', '#f59e0b', '#ef4444']

# Model parameters
alpha_base = 0.02   # base recruitment rate
beta = 0.015        # cross-inhibition rate
gamma = 0.03        # quorum amplification
K = 20              # quorum threshold
noise_scale = 0.5   # stochastic noise

# ─── ODE simulation (swarm model) ───
N = np.zeros((steps, n_sites))
t_arr = np.arange(steps) * dt

for t in range(1, steps):
    N_committed = np.sum(N[t-1])
    N_uncommitted = max(0, N_total - N_committed)

for i in range(n_sites):
        alpha_i = alpha_base * qualities[i]
        recruitment = alpha_i * N_uncommitted
        inhibition = beta * N[t-1, i] * (N_committed - N[t-1, i]) / max(N_committed, 1)
        quorum = gamma * N[t-1, i]**2 / (N[t-1, i]**2 + K**2) * N_uncommitted
        noise = noise_scale * np.sqrt(max(N[t-1, i], 0)) * np.random.randn()

dN = (recruitment - inhibition + quorum + noise) * dt
        N[t, i] = max(0, N[t-1, i] + dN)

# Normalize if total exceeds N_total
    total = np.sum(N[t])
    if total > N_total:
        N[t] *= N_total / total

# ─── Neural integrator model (for comparison) ───
# dx_i/dt = alpha_i * I - beta * sum(x_j!=i) + sigma(x_i)
x_neural = np.zeros((steps, n_sites))
I_input = 1.0  # constant input

for t in range(1, steps):
    for i in range(n_sites):
        excitation = alpha_base * qualities[i] * I_input * N_total
        inhibition_sum = beta * sum(x_neural[t-1, j] for j in range(n_sites) if j != i)
        sigmoid = gamma * x_neural[t-1, i]**2 / (x_neural[t-1, i]**2 + K**2) * N_total * 0.5
        noise = noise_scale * np.sqrt(max(x_neural[t-1, i], 0)) * np.random.randn()

dx = (excitation - inhibition_sum + sigmoid + noise) * dt
        x_neural[t, i] = max(0, x_neural[t-1, i] + dx)

total = np.sum(x_neural[t])
    if total > N_total:
        x_neural[t] *= N_total / total

# ─── Find decision time (quorum) ───
quorum_time = None
for t in range(steps):
    if np.max(N[t]) >= K:
        quorum_time = t * dt
        break

# ─── Plotting ───
fig, axes = plt.subplots(2, 2, figsize=(14, 11))
fig.patch.set_facecolor('#0a0a0a')

# Panel 1: Swarm model dynamics
ax1 = axes[0, 0]
for i in range(n_sites):
    ax1.plot(t_arr, N[:, i], color=site_colors[i], linewidth=2.5, label=site_names[i])
ax1.axhline(y=K, color='#fbbf24', linewidth=1.5, linestyle='--', alpha=0.7, label=f'Quorum (K={K})')
if quorum_time:
    ax1.axvline(x=quorum_time, color='white', linewidth=0.8, linestyle=':', alpha=0.5)
    ax1.annotate(f'Decision at {quorum_time:.1f}h', xy=(quorum_time, K),
                xytext=(quorum_time+8, K+50), color='#fbbf24', fontsize=9,
                arrowprops=dict(arrowstyle='->', color='#fbbf24', lw=1))
ax1.set_xlabel('Time (hours)', color='white', fontsize=11)
ax1.set_ylabel('Number of committed scouts', color='white', fontsize=11)
ax1.set_title('Swarm Decision Model', color='#fde047', fontsize=13, fontweight='bold')
ax1.legend(facecolor='#1a1a2e', edgecolor='#374151', fontsize=9, labelcolor='white')
ax1.set_facecolor('#0a0a0a')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.15, color='white')

# Panel 2: Neural integrator comparison
ax2 = axes[0, 1]
for i in range(n_sites):
    ax2.plot(t_arr, x_neural[:, i], color=site_colors[i], linewidth=2.5, label=site_names[i])
ax2.axhline(y=K, color='#fbbf24', linewidth=1.5, linestyle='--', alpha=0.7, label=f'Threshold (K={K})')
ax2.set_xlabel('Time (hours)', color='white', fontsize=11)
ax2.set_ylabel('Neural activity (a.u.)', color='white', fontsize=11)
ax2.set_title('Neural Integrator (Equivalent)', color='#fde047', fontsize=13, fontweight='bold')
ax2.legend(facecolor='#1a1a2e', edgecolor='#374151', fontsize=9, labelcolor='white')
ax2.set_facecolor('#0a0a0a')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.15, color='white')

# Panel 3: Multiple runs showing stochasticity
ax3 = axes[1, 0]
n_runs = 20
decision_times = []
correct_decisions = 0

for run in range(n_runs):
    N_run = np.zeros((steps, n_sites))
    for t in range(1, steps):
        N_committed = np.sum(N_run[t-1])
        N_uncommitted = max(0, N_total - N_committed)
        for i in range(n_sites):
            alpha_i = alpha_base * qualities[i]
            recruitment = alpha_i * N_uncommitted
            inhibition = beta * N_run[t-1, i] * (N_committed - N_run[t-1, i]) / max(N_committed, 1)
            quorum_term = gamma * N_run[t-1, i]**2 / (N_run[t-1, i]**2 + K**2) * N_uncommitted
            noise = noise_scale * np.sqrt(max(N_run[t-1, i], 0)) * np.random.randn()
            dN = (recruitment - inhibition + quorum_term + noise) * dt
            N_run[t, i] = max(0, N_run[t-1, i] + dN)
        total = np.sum(N_run[t])
        if total > N_total:
            N_run[t] *= N_total / total

# Record which site won
    final = N_run[-1]
    winner = np.argmax(final)
    if winner == 0:
        correct_decisions += 1

# Find decision time
    for t in range(steps):
        if np.max(N_run[t]) >= K:
            decision_times.append(t * dt)
            break

# Plot just site A for each run
    alpha_val = 0.3
    ax3.plot(t_arr, N_run[:, 0], color='#22c55e', linewidth=0.8, alpha=alpha_val)

ax3.set_xlabel('Time (hours)', color='white', fontsize=11)
ax3.set_ylabel('Scouts committed to best site (A)', color='white', fontsize=11)
ax3.set_title(f'Stochastic Variability ({n_runs} runs)', color='#fde047', fontsize=13, fontweight='bold')
ax3.set_facecolor('#0a0a0a')
ax3.tick_params(colors='white')
ax3.grid(True, alpha=0.15, color='white')
accuracy = correct_decisions / n_runs * 100
ax3.text(0.95, 0.95, f'Accuracy: {accuracy:.0f}%\nMean decision: {np.mean(decision_times):.1f}h',
        transform=ax3.transAxes, ha='right', va='top', color='#fde047', fontsize=10,
        bbox=dict(boxstyle='round', facecolor='#1a1a2e', edgecolor='#374151'))

# Panel 4: Effect of cross-inhibition strength
ax4 = axes[1, 1]
beta_values = [0, 0.005, 0.015, 0.04]
beta_colors = ['#ef4444', '#f59e0b', '#22c55e', '#3b82f6']

for beta_val, col in zip(beta_values, beta_colors):
    N_beta = np.zeros((steps, n_sites))
    for t in range(1, steps):
        N_committed = np.sum(N_beta[t-1])
        N_uncommitted = max(0, N_total - N_committed)
        for i in range(n_sites):
            alpha_i = alpha_base * qualities[i]
            recruitment = alpha_i * N_uncommitted
            inhibition = beta_val * N_beta[t-1, i] * (N_committed - N_beta[t-1, i]) / max(N_committed, 1)
            quorum_term = gamma * N_beta[t-1, i]**2 / (N_beta[t-1, i]**2 + K**2) * N_uncommitted
            dN = (recruitment - inhibition + quorum_term) * dt
            N_beta[t, i] = max(0, N_beta[t-1, i] + dN)
        total = np.sum(N_beta[t])
        if total > N_total:
            N_beta[t] *= N_total / total

# Plot ratio of best to second-best
    ratio = N_beta[:, 0] / (N_beta[:, 1] + 1)
    ax4.plot(t_arr, ratio, color=col, linewidth=2, label=f'beta={beta_val}')

ax4.set_xlabel('Time (hours)', color='white', fontsize=11)
ax4.set_ylabel('Scout ratio (Site A / Site B)', color='white', fontsize=11)
ax4.set_title('Effect of Cross-Inhibition Strength', color='#fde047', fontsize=13, fontweight='bold')
ax4.legend(facecolor='#1a1a2e', edgecolor='#374151', fontsize=9, labelcolor='white')
ax4.set_facecolor('#0a0a0a')
ax4.tick_params(colors='white')
ax4.grid(True, alpha=0.15, color='white')
ax4.set_ylim(0, 30)

plt.tight_layout(pad=2.0)
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a0a')
plt.close()

print("Swarm Decision-Making Analysis")
print("=" * 50)
print(f"\nModel Parameters:")
print(f"  Total scouts: {N_total}")
print(f"  Site qualities: {qualities}")
print(f"  Quorum threshold K = {K}")
print(f"\nResults (single run):")
print(f"  Decision time: {quorum_time:.1f} hours" if quorum_time else "  No quorum reached")
print(f"  Winner: Site {['A','B','C'][np.argmax(N[-1])]}")
print(f"  Final populations: A={N[-1,0]:.0f}, B={N[-1,1]:.0f}, C={N[-1,2]:.0f}")
print(f"\nStochastic analysis ({n_runs} runs):")
print(f"  Accuracy (chose best site): {accuracy:.0f}%")
print(f"  Mean decision time: {np.mean(decision_times):.1f} +/- {np.std(decision_times):.1f} hours")
print(f"\nNeural equivalence:")
print(f"  Recruitment = excitatory input")
print(f"  Stop signals = lateral inhibition")
print(f"  Quorum = sigmoid activation threshold")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

References

Seeley, T. D. (2010). Honeybee Democracy. Princeton University Press.
Seeley, T. D., Visscher, P. K., Schlegel, T., Hogan, P. M., Franks, N. R., & Marshall, J. A. R. (2012). Stop signals provide cross inhibition in collective decision-making by honeybee swarms. Science, 335(6064), 108–111.
Charnov, E. L. (1976). Optimal foraging, the marginal value theorem. Theoretical Population Biology, 9(2), 129–136.
Pyke, G. H. (1984). Optimal foraging theory: A critical review. Annual Review of Ecology and Systematics, 15, 523–575.
Bonabeau, E., Theraulaz, G., & Deneubourg, J.-L. (1996). Quantitative study of the fixed threshold model for the regulation of division of labour in insect societies. Proceedings of the Royal Society B, 263(1376), 1565–1569.
Page, R. E., & Mitchell, S. D. (1998). Self-organization and the evolution of division of labor. Apidologie, 29(1-2), 171–190.
Viswanathan, G. M., Buldyrev, S. V., Havlin, S., da Luz, M. G. E., Raposo, E. P., & Stanley, H. E. (1999). Optimizing the success of random searches. Nature, 401(6756), 911–914.
Hales, T. C. (2001). The honeycomb conjecture. Discrete & Computational Geometry, 25(1), 1–22.
Usher, M., & McClelland, J. L. (2001). The time course of perceptual choice: The leaky, competing accumulator model. Psychological Review, 108(3), 550–592.
Passino, K. M., Seeley, T. D., & Visscher, P. K. (2008). Swarm cognition in honey bees. Behavioral Ecology and Sociobiology, 62(3), 401–414.

M6. Stinger & Venom Biophysics M8. Evolution & Colony Genetics