Estuary Mapping Framework Simulator

Constructor Theory

• Origin: David Deutsch & Chiara Marletto
• Concept: Shifts focus from “laws of motion” (what will happen) to “counterfactuals” (what transformations are possible).

In Simulation: Constructors (diamond shapes) are entities that cause transformations without undergoing net change themselves, such as rituals, processes, and habits. Constraints (circles) define the boundary conditions that allow order to emerge.

Energy Landscape & Attractor Dynamics

• Concept: Organisations show Hysteresis, where the state depends on history.
• Basins of Attraction: Certain states (e.g., “Bureaucratic Stagnation”) act as deep wells that trap actants.

The goal is to change the map so that the Energy Cost of Virtue ($E_v$) is lower than the Energy Cost of Sin ($E_s$).

Cognitive Heuristics in Agent Modelling

Agents (blue dots) exhibit behavioral patterns derived from cognitive psychology:

• Loss Aversion (λ): Agents resist moving from their current position if the perceived energy cost of the new state is higher, even if long-term potential is better. This creates “frictional heat” in the simulation.
• Social Proof (Herding): Agents cluster together. When a cluster forms, the local energy gradient is lowered, making it harder for individual agents to leave.
• Hyperbolic Discounting: Agents prefer low-energy, short-time interventions over high-impact, long-time strategic shifts.

Loss Aversion (Prospect Theory)

• Creators: Daniel Kahneman & Amos Tversky (1979)
• Concept: People feel losses more intensely than equivalent gains; it is approximately 2x as painful.

Where $\Delta E = E_{target} - E_{current}$ is the energy difference and $\lambda$ is the loss aversion coefficient (1.0–3.0). Agents resist moving to higher-energy states, creating organisational inertia.

// Loss Aversion: Resistance to higher energy states
const energyDiff = targetEnergy - currentEnergy;
if (energyDiff > 0) {
    // Moving uphill: Apply loss aversion penalty
    if (Math.random() > Math.pow(0.5, energyDiff * lossAversionLambda)) {
        return; // Reject move
    }
}

Social Proof (Herding Behavior)

• Creator: Robert Cialdini (1984)
• Concept: When uncertain, people look to others’ behavior for guidance: “if everyone else is doing it, it must be correct.”

Nearby agents ($n$) reduce the local energy cost, creating “social gravity wells.” It becomes energetically cheaper to stay within the herd than to break away.

// Social Gravity: Local clusters reduce effective energy cost
const nearbyCount = this.getNearbyAgents(radius).length;
const socialDiscount = Math.min(0.4, nearbyCount * 0.05);

// The herd makes the current location feel "safer" (lower energy)
const effectiveEnergy = baseEnergy - socialDiscount;

Boids Algorithm (Flocking)

• Creator: Craig Reynolds (1986)
• Concept: Emergent collective behavior from three simple rules.

Separation: Avoid crowding neighbors (inverse-square falloff).

// Flocking Behavior (Boids)
const cohesion = this.steerToward(averagePosition);
const alignment = this.steerToward(averageHeading);
const separation = this.avoid(neighbors);

// Sum of vectors with weights
this.acceleration.add(cohesion.mult(0.01));
this.acceleration.add(alignment.mult(0.05));
this.acceleration.add(separation.mult(0.1));

Gradient Descent

• Origin: Mathematical optimization (Cauchy, 1847)
• Concept: Move in the direction of steepest descent to find local minima.

Agents descend the energy landscape, seeking “basins of attraction” (stable low-energy states). The gradient $\nabla E$ is sampled from the energy grid, and $\eta$ is the learning rate (0.3 in stable zones).

// Gradient Descent on Energy Landscape
const gradX = (energyGrid[x+1][y] - energyGrid[x-1][y]) / 2;
const gradY = (energyGrid[x][y+1] - energyGrid[x][y-1]) / 2;

// Move towards lower energy (downhill)
this.velocity.x -= gradX * learningRate;
this.velocity.y -= gradY * learningRate;

Inductance (Bond Graph Theory)

• Origin: Henry Paynter (1961)
• Concept: Energy storage in momentum, reflecting resistance to changes in flow rate.

Where $I$ is inductance (0–1). Clustered agents build momentum inertia that resists sudden direction changes, which models organisational momentum.

// Inductance: Resistance to change in velocity
const inductance = 0.8; // High organizational inertia
this.velocity.x = (prevVx * inductance) + (newVx * (1 - inductance));
this.velocity.y = (prevVy * inductance) + (newVy * (1 - inductance));

Sunk Cost Fallacy

• Researchers: Hal Arkes & Catherine Blumer (1985)
• Concept: Past investment irrationally influences future decisions: “we’ve come too far to stop now.”

Agents older than $t_{threshold}$ (~10 seconds) receive progressive inductance boosts, making them harder to dislodge from current trajectories.

// Sunk Cost: Older agents become harder to move
const age = Date.now() - this.createdAt;
if (age > threshold) {
    // Increase inductance based on age
    this.inductance += 0.001; 
}

Abilene Paradox (Groupthink)

• Creator: Jerry B. Harvey (1974)
• Concept: Groups collectively decide on a course of action that no individual member actually wants.

When cluster inductance exceeds $I_{max} = 0.6$, a “phantom vector” emerges that pushes the entire group toward high-energy “sin” basins, representing collective drift toward suboptimal outcomes.

// Abilene Paradox: Collective drift to undesired outcome
// If cluster cohesion is too high, drift towards "Sin" basin
if (clusterInductance > 0.6) {
   const phantomVector = getVectorToSinBasin();
   this.applyForce(phantomVector.mult(0.5));
}

Institutional Isomorphism

• Researchers: Paul DiMaggio & Walter Powell (1983)
• Concept: Organisations under similar environmental pressures become structurally similar over time.

Agents adopt properties (inductance, loss aversion) of nearby successful neighbors with higher flow rates. $\mu = 0.05$ controls the gradual mimicry rate.

// Mimetic Isomorphism: Copy successful neighbors
const neighbor = this.getNearestHighFlowNeighbor();
if (neighbor) {
    // Adopt neighbor's properties
    this.inductance = lerp(this.inductance, neighbor.inductance, 0.05);
    this.lossAversion = lerp(this.lossAversion, neighbor.lossAversion, 0.05);
}

Hooke’s Law (Entanglement Springs)

• Creator: Robert Hooke (1678)
• Concept: The force exerted by a spring is proportional to its displacement from equilibrium.

Entanglement bonds apply spring forces when stretched beyond their rest length $d_0$. This creates the physical coupling between entangled actants, where pulling one drags the other.

// Entanglement Spring Force
const dx = connectedNode.x - this.x;
const dy = connectedNode.y - this.y;
const distance = Math.sqrt(dx*dx + dy*dy);
const force = (distance - restLength) * springConstant;

// Apply restoring force
this.applyForce(new Vector(dx, dy).normalize().mult(force));

Hyperbolic Discounting

• Researcher: George Ainslie (1975)
• Concept: People prefer smaller, immediate rewards over larger, delayed rewards, with preference reversals near the present.

Where $A$ is reward magnitude, $D$ is delay, and $k$ is the discount rate. Agents prefer low-energy, short-time interventions (West vectors) over high-impact, long-time strategic shifts (East vectors).

// Preference for immediate small gains over long-term value
const shortTermGain = assessVector(WEST); // Do it now
const longTermGain = assessVector(EAST);  // Build capacity

// Discount future value
const discountedLongTerm = longTermGain / (1 + discountRate * delay);

if (shortTermGain > discountedLongTerm) {
    this.move(WEST);
}

Hysteresis

• Origin: James Alfred Ewing (1881), physics
• Concept: A system’s current state depends on its history, not just current inputs.

Organisations display path-dependency: the sequence of past decisions constrains future options. This is why certain “attractor basins” (e.g., bureaucratic stagnation) are difficult to escape once entered.

// State depends on history
// Once trapped in a basin, small fluctuations can't escape
if (isInBasin && inputForce < escapeThreshold) {
    this.state = "TRAPPED"; // Remains trapped even if force > 0
} else {
    this.state = "flowing";
}

Energy Cost of Change

• Framework: Behavioral architecture / Nudge theory
• Creators: Richard Thaler & Cass Sunstein (2008)

The goal of strategic design is to ensure $E_v$ (Energy Cost of Virtue) is lower than $E_s$ (Energy Cost of Sin). Make the “right thing” the path of least resistance.

// Strategic Design: Lowers energy cost of desired state
class Constructor {
    update() {
        // Create local energy well (Virtue)
        grid[this.x][this.y] -= 0.5; 
        
        // This makes Ev < Es (Virtue cheaper than Sin)
    }
}