19  Advanced Dynamics: Regimes, Networks, and Resilience

Status: Draft

v0.4

19.1 Introduction

This chapter extends basic deterministic and stochastic dynamics to advanced topics: regime switching, network dynamics, and system resilience. These ideas apply wherever complex systems show multiple attractors, spatial or network structure, and varying stability, ecology and epidemiology are recurring examples, not the only domains.

19.2 Regime Switching and Tipping Points

19.2.1 What Are Regimes?

Regimes are distinct modes of system behaviour (Hamilton 1994; Scheffer et al. 2009):

  • Ecological: Healthy vs degraded ecosystems
  • Biological: Active vs dormant states
  • Clinical: Responder vs non-responder trajectories
  • Economic: Boom vs bust periods

Key feature: Transitions between regimes are often abrupt or threshold-driven (tipping points).

19.2.2 Switching State-Space Models

A switching SSM includes:

  1. Discrete regime variable: \(S_t \in \{1, \ldots, K\}\)
  2. Regime-specific dynamics: \(f_k(X_t, A_t, \theta_k)\)
  3. Transition probabilities: \(P(S_{t+1} \mid S_t, X_t, A_t)\)

19.2.3 State Process

\[ X_{t+1} = f_{S_t}(X_t, A_t, \theta_{S_t}, U_{t+1}) \]

Dynamics depend on current regime \(S_t\). The system can switch between regimes based on state, interventions, or stochastic transitions.

19.2.4 Tipping Points

Tipping points are critical thresholds where small changes trigger regime shifts (Scheffer et al. 2009):

  • Bifurcations: Qualitative changes in system behaviour
  • Critical transitions: Sudden shifts between attractors
  • Hysteresis: Path-dependent transitions

Understanding tipping points is crucial for intervention design, small interventions near tipping points can have large effects.

19.3 Network Models: Interaction Structure

19.3.1 Types of Networks

19.3.1.1 Interaction Networks

Definition: Direct causal or mechanistic interactions between entities.

Example: Predator-prey interactions, gene regulatory networks, neural connections.

Causal commitment: Edges represent direct causal influence (a modelling assumption).

19.3.1.2 Co-Occurrence Networks

Definition: Statistical associations (correlations) between entities.

Example: Species co-occurrence, symptom co-occurrence.

Causal commitment: None, edges are associations, not necessarily causal.

19.3.1.3 Effective Networks

Definition: Inferred networks from data (e.g., Granger causality, partial correlations).

Example: Functional connectivity in neuroscience, inferred ecological interactions.

Causal commitment: Depends on inference method, may or may not represent causal structure.

19.3.2 Network Structure and Causal Assumptions

Network structure provides a compact representation of interaction structure. The graph \(G = (V, E)\) where:

  • \(V\) is the set of vertices (nodes / variables / agents)
  • \(E\) is the set of edges (directed or undirected interactions, depending on the model)

Different network structures (chains, forks, colliders, modules) correspond to different dependency patterns, all captured by the same graph-theoretic framework established in the Structural layer.

19.3.3 Sign Constraints and Modularity

  • Sign constraints: Edges can be positive (facilitation) or negative (inhibition)
  • Modularity: Clusters of densely connected nodes (communities/modules)
  • Trophic structure: Hierarchical structure (e.g., food webs)

19.4 Dynamics on Networks: Collective Behaviour

On a graph, each node is an organism (an occasion at \(i\) concrescing under local \(f_i\)); neighbours supply environment via the edge structure; the shared update rule and topology form a society in the sense of Chapter 9.

19.4.1 Node Dynamics

Each node \(i\) has a state \(X^i_t\) that evolves according to:

\[ X^i_{t+1} = f_i(X^i_t, \{X^j_t : j \in \text{Pa}(i)\}, A_t, U^i_{t+1}) \]

where \(\text{Pa}(i)\) are the parents of node \(i\) in the network (its direct inputs).

19.4.2 Homogeneous vs Heterogeneous

  • Homogeneous: All nodes have the same dynamics \(f_i = f\) for all \(i\)
  • Heterogeneous: Different node types have different dynamics (e.g., producers vs consumers)

19.4.3 Edge Dynamics

  • Static edges: Fixed interactions with constant strength
  • Dynamic edges: Interactions change over time based on node states or external factors

19.4.4 System-Level Behaviour

Network dynamics compose into system-level behaviour:

  • Synchronisation: Nodes converge to common dynamics
  • Cascades: Local perturbations propagate through network
  • Collective attractors: System-level equilibria emerging from node interactions

The graph structure (which nodes influence which others) constrains the possible dynamics, while the dynamics determine how the system evolves given that structure.

19.5 Multiagent Networks: Autonomous Agents and Strategic Interactions

19.5.1 From Nodes to Agents

The network models we’ve discussed so far treat nodes as passive entities whose states evolve according to fixed dynamics. Multiagent networks extend this framework by treating nodes as autonomous agents, entities that make decisions, respond to their environment, and interact strategically with other agents (Gilbert 2008; Bonabeau 2002; Wooldridge 2009).

In an agent-based model, each agent is a decision-making unit with internal state and update rules. Agents interact through the network structure, which determines who can affect whom.

This reframing enables us to model systems where:

  • Individual decisions compose into collective behaviour
  • Agent-level interventions (targeting specific agents) have system-level effects
  • Strategic interactions (agents respond to others’ behaviours) create complex dynamics

19.5.2 Agent Decision-Making

Each agent \(i\) makes decisions based on:

  • Local state: Their own state \(X^i_t\)
  • Neighbor states: States of connected agents \(\{X^j_t : j \in \text{Pa}(i)\}\)
  • Higher-order interactions: Multi-way interactions with groups of agents (requires hypergraphs)
  • Context: Global context \(C\) (e.g., environment, policy)
  • Uncertainty: Agent-specific noise \(U^i_t\)

Agent policy (decision rule): \[ A^i_t = \pi^i(X^i_t, \{X^j_t : j \in \text{Pa}(i)\}, \{X^G_t : G \in \text{HyperPa}(i)\}, C, U^{i,a}_t) \]

where:

  • \(\pi^i\) is agent \(i\)’s policy (decision rule)
  • \(\text{Pa}(i)\) are parents in the network (pairwise interactions)
  • \(\text{HyperPa}(i)\) are hyperedges containing agent \(i\) (higher-order interactions)
  • \(U^{i,a}_t\) is randomness in agent \(i\)’s decision-making

Agent state dynamics: \[ X^i_{t+1} = f_i(X^i_t, A^i_t, \{X^j_t : j \in \text{Pa}(i)\}, \{X^G_t : G \in \text{HyperPa}(i)\}, C, U^{i,x}_{t+1}) \]

Agent states evolve based on their decisions, neighbours’ states, and higher-order group interactions.

19.5.3 Higher-Order Interactions: Beyond Pairwise Graphs

Standard graphs (Graphs.jl) represent pairwise interactions, edges connect two nodes. However, many multiagent systems involve higher-order interactions where multiple agents interact simultaneously (Battiston et al. 2020; Benson et al. 2018):

  • Group meetings: Multiple individuals interact together (not just pairwise)
  • Coalition formation: Groups of agents form alliances
  • Multi-agent coordination: More than two agents coordinate actions
  • Collective decision-making: Groups make decisions together

For representing and manipulating higher-order relational structures, we provide a pure Julia hypergraph implementation (scripts/hypergraph.jl) that offers:

  • Hypergraphs: Edges can connect multiple nodes (perfect for multi-way agent interactions)
  • Simplicial complexes: Higher-dimensional structures for complex relationships
  • Petri Nets: Useful for modelling agent state transitions and interactions

Example: In epidemiology, a hyperedge could represent a group meeting where multiple individuals interact simultaneously, not just pairwise contacts. This is essential for modelling superspreading events and group transmission.

19.5.4 Strategic Interactions

Agents may respond to other agents’ actions strategically:

  • Best response: Agent \(i\) chooses action to maximise utility given others’ actions
  • Nash equilibrium: No agent wants to deviate unilaterally
  • Learning: Agents adapt strategies based on outcomes

This creates game-theoretic dynamics where agent decisions depend on what other agents do, leading to complex emergent behaviour (Fudenberg and Tirole 1991; Nowak 2006).

19.5.5 Interventions in Multiagent Systems

Multiagent networks support multiple intervention types, all with clear \(do(\cdot)\) semantics:

Agent-level interventions: \(do(A^i_t = a)\)

  • Force agent \(i\) to take specific action
  • Example: Vaccinate individual \(i\) (epidemiology)
  • Example: Subsidise firm \(i\) (economics)

Policy interventions: \(do(\pi^i \leftarrow \pi^*)\)

  • Change agent \(i\)’s decision rule
  • Example: Change individual’s contact behaviour (epidemiology)
  • Example: Change firm’s pricing strategy (economics)

Network interventions: \(do(G \leftarrow G^*)\)

  • Modify network structure
  • Example: Isolate individual \(i\) (remove edges) (epidemiology)
  • Example: Create/destroy connections between agents

Hypergraph interventions: \(do(H \leftarrow H^*)\)

  • Modify higher-order structure (using hypergraph implementation)
  • Example: Ban group meetings (remove hyperedges) (epidemiology)
  • Example: Create/destroy multi-agent coalitions

19.5.6 Multiagent Networks as CDMs

Multiagent networks are a natural instantiation of Causal Dynamical Models (CDMs) (see Chapter 28):

CDM components:

  1. Graph structure: Agent network \(G\) (and hypergraph \(H\) for higher-order interactions)
  2. Latent process: Agent states \(X^i_t\) with dynamics \(f_i(\cdot)\)
  3. Observation model: Observed agent behaviours \(Y^i_t\)
  4. Explicit noise: \(U^{i,x}_t\), \(U^{i,y}_t\), \(U^{i,a}_t\) for each agent
  5. Intervention operators: Agent-level, policy, network, hypergraph interventions
  6. Counterfactual semantics: Agent-level counterfactuals with shared noise

CDM capabilities:

  • Inference: Use StateSpaceDynamics.jl to infer latent agent states from observed behaviours
  • Forecasting: Predict future agent behaviours and system-level outcomes
  • Interventions: Simulate effects of agent-level, policy, or network interventions
  • Counterfactuals: “What would agent \(i\)’s outcome have been if they had behaved differently?”

Each agent is a unit with internal state and update rules. The network structure determines who can influence whom, the dynamics specify how states update through time, and interventions modify either behaviour rules or the interaction structure.

19.5.7 Implementation: Multiagent Networks in Julia

19.5.7.1 Agents.jl: Agent-Based Modelling Framework

Agents.jl (Datseris et al. 2022) is a comprehensive Julia package for agent-based modelling that provides:

  • Agent definitions: Define agents with properties and behaviours
  • Spatial structures: Grids, graphs, continuous space
  • Network support: Agents can interact via networks (using Graphs.jl)
  • Scheduling: Flexible agent activation and interaction
  • Data collection: Built-in tools for collecting agent and system-level data
  • Visualisation: Tools for visualising agent-based models
# Find project root and include ensure_packages.jl
project_root = let
    current = pwd()
    while !isfile(joinpath(current, "Project.toml")) && !isfile(joinpath(current, "_quarto.yml"))
        parent = dirname(current)
        parent == current && break
        current = parent
    end
    current
end
include(joinpath(dirname(Base.active_project()), "scripts", "book_bootstrap.jl"))
# Agents.jl 7: agent types via @agent; models use StandardABM; RNG lives on the model
using Agents
using Agents: run!, dummystep, abmrng, abmspace
using Agents.Schedulers
@auto_using Graphs CairoMakie StableRNGs DataFrames

# Activate SVG output for responsive figures

# Set seed for reproducibility
rng = StableRNG(1234)

@agent struct Person(GraphAgent)
    state::Int
    behavior::Symbol
end

# Create network (using Graphs.jl)
g = erdos_renyi(50, 0.1, seed = 42)  # Random network with 50 agents, 10% connection probability

# GraphSpace(graph) — one position per graph vertex (Agents.jl 7)
space = GraphSpace(g)

function agent_step!(agent, model)
    rng = abmrng(model)
    graph = abmspace(model).graph
    node_id = agent.pos
    neighbor_nodes = Graphs.neighbors(graph, node_id)
    # One agent per node with agent id equal to node index (book convention)
    neighbors_agents = [model[n] for n in neighbor_nodes if hasid(model, n)]

    infected_neighbors = [n for n in neighbors_agents if n.state == 1]
    if !isempty(infected_neighbors) && agent.behavior == :normal
        if rand(rng) < 0.3
            agent.behavior = :distancing
        end
    end

    if agent.state == 0
        for neighbor in neighbors_agents
            if neighbor.state == 1 && agent.behavior == :normal
                if rand(rng) < 0.1
                    agent.state = 1
                    break
                end
            end
        end
    elseif agent.state == 1
        if rand(rng) < 0.05
            agent.state = 2
        end
    end
end

function model_step!(model)
end

model = StandardABM(Person, space;
    scheduler = Schedulers.Randomly(),
    rng = rng,
    agent_step! = agent_step!,
    model_step! = model_step!)

for i in 1:50
    add_agent!(i, model, 0, :normal)
end

for i in 1:5
    model[i].state = 1
end

data, _ = run!(model, 100;
    adata = [:state, :behavior],
    showprogress = false)

# Aggregate by time step for visualization (`run!` uses column `:time`)
data_agg = combine(groupby(data, :time),
    :state => (x -> sum(x .== 0)) => :susceptible,
    :state => (x -> sum(x .== 1)) => :infected,
    :state => (x -> sum(x .== 2)) => :recovered,
    :behavior => (x -> sum(x .== :normal)) => :normal,
    :behavior => (x -> sum(x .== :distancing)) => :distancing
)
101×6 DataFrame
76 rows omitted
Row time susceptible infected recovered normal distancing
Int64 Int64 Int64 Int64 Int64 Int64
1 0 45 5 0 50 0
2 1 44 6 0 45 5
3 2 43 7 0 42 8
4 3 42 8 0 36 14
5 4 40 9 1 32 18
6 5 39 8 3 27 23
7 6 39 8 3 24 26
8 7 39 7 4 23 27
9 8 39 7 4 22 28
10 9 38 6 6 22 28
11 10 38 6 6 19 31
12 11 38 6 6 19 31
13 12 38 5 7 17 33
⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮
90 89 38 0 12 17 33
91 90 38 0 12 17 33
92 91 38 0 12 17 33
93 92 38 0 12 17 33
94 93 38 0 12 17 33
95 94 38 0 12 17 33
96 95 38 0 12 17 33
97 96 38 0 12 17 33
98 97 38 0 12 17 33
99 98 38 0 12 17 33
100 99 38 0 12 17 33
101 100 38 0 12 17 33

Basic multiagent network: agents interacting on a network structure

Visualisation of epidemic dynamics and behaviour adoption from multiagent network simulation

This example shows how agents make decisions based on their neighbours’ states (network structure), and how these individual decisions compose into system-level epidemic dynamics.

Note on Agents.jl 7: The code uses @agent with GraphAgent, StandardABM, and add_agent!(node, model, …) so identifiers and positions are assigned by the library. run! collects a :time column; use abmrng(model) and abmspace(model) for RNG and space in stepping functions.

19.5.7.2 Higher-Order Interactions with Hypergraphs

ImportantExperimental API

CausalDynamics.Hypergraph is experimental and quarantined outside the main identify pipeline. Prefer ordinary DAGs / Graphs.jl for identification and estimation; treat the hypergraph helpers below as a pedagogical sketch of multi-way interactions, not a stable production surface.

For multi-way agent interactions we need a representation of higher-order (group) interactions, not only pairwise edges. The pedagogical hypergraph helpers below (from the book’s Julia stack) support:

  • Vertices: Agents in the system
  • Edges: Pairwise interactions between agents
  • Hyperedges: True multi-way interactions (groups of agents interacting simultaneously)

Unlike the pairwise representation (where a group meeting is decomposed into multiple edges), a hypergraph can represent a group meeting as a single hyperedge connecting all participants. That pattern matters in many multiagent systems (epidemic gatherings, committee decisions, coupled engineered components) wherever group dynamics are not reducible to pairs.

# Find project root and include ensure_packages.jl
project_root = let
    current = pwd()
    while !isfile(joinpath(current, "Project.toml")) && !isfile(joinpath(current, "_quarto.yml"))
        parent = dirname(current)
        parent == current && break
        current = parent
    end
    current
end
include(joinpath(project_root, "scripts", "ensure_packages.jl"))

@auto_using DAGMakie CairoMakie Graphs CausalDynamics

# Import hypergraph functions from CausalDynamics.jl
# This provides a clean API for higher-order causal interactions
using CausalDynamics: Hypergraph, add_hyperedge!, rem_hyperedge!, hyperedge_vertices
using CausalDynamics: incident_hyperedges, num_hyperedges, num_vertices, hyperedges

# Example: Multiagent network with group meetings
# Agents: A, B, C, D, E (vertices)
# Pairwise contacts: A-B, B-C, C-D (standard graph edges)
# Group meetings: Meeting1 = {A, B, C}, Meeting2 = {B, C, D} (hyperedges)

# Create hypergraph for multiagent system
hg = Hypergraph(5)  # 5 agents: A=1, B=2, C=3, D=4, E=5

# Add pairwise contacts (standard graph edges)
# Hypergraph forwards Graphs.jl functions to its underlying graph
Graphs.add_edge!(hg, 1, 2)  # A-B contact
Graphs.add_edge!(hg, 2, 3)  # B-C contact
Graphs.add_edge!(hg, 3, 4)  # C-D contact

# Add group meetings (hyperedges)
# Unlike edges (pairwise), hyperedges can connect any number of vertices
# This properly represents group interactions where all members interact simultaneously

# Meeting 1: Agents A, B, C interact together
meeting1 = add_hyperedge!(hg, [1, 2, 3])  # {A, B, C}

# Meeting 2: Agents B, C, D interact together
meeting2 = add_hyperedge!(hg, [2, 3, 4])  # {B, C, D}

# Query hypergraph structure
println("Number of agents (vertices): ", num_vertices(hg))
println("Number of pairwise contacts (edges): ", Graphs.ne(hg))
println("Number of group meetings (hyperedges): ", num_hyperedges(hg))
println()
println("Meeting 1 participants: ", hyperedge_vertices(hg, meeting1))
println("Meeting 2 participants: ", hyperedge_vertices(hg, meeting2))
println()
println("Hyperedges containing agent B (vertex 2): ", incident_hyperedges(hg, 2))

# Prepare the hypergraph structure for DAGMakie visualisation
# Convert the hypergraph to Graphs.jl format for visualisation
g_viz = SimpleDiGraph(num_vertices(hg))
# Add pairwise edges to the graph
for e in Graphs.edges(hg)
    if !Graphs.has_edge(g_viz, Graphs.src(e), Graphs.dst(e))
        Graphs.add_edge!(g_viz, Graphs.src(e), Graphs.dst(e))
    end
end
Number of agents (vertices): 5
Number of pairwise contacts (edges): 3
Number of group meetings (hyperedges): 2

Meeting 1 participants: Set([2, 3, 1])
Meeting 2 participants: Set([4, 2, 3])

Hyperedges containing agent B (vertex 2): Set([2, 1])

Visualisation of multiagent network with pairwise contacts and group meetings

Key insight: Higher-order interactions (hypergraphs) matter whenever group effects cannot be reduced to pairwise links. Representing a group as one hyperedge supports interventions such as \(do(H \leftarrow H^*)\) (e.g. banning group meetings in epidemiology, or isolating a subsystem in an engineered network). Treat the helpers above as a sketch; prefer ordinary DAGs for identification and estimation. For richer categorical composition, ACSets.jl and related AlgebraicJulia tooling go further.

19.5.8 Network Structure and Attractor Dynamics

The structure of agent networks (both pairwise graphs and higher-order hypergraphs) fundamentally shapes how systems evolve towards attractor states. This connection between network topology and attractor dynamics is central to understanding complex systems:

Pairwise networks (Graphs.jl):

  • Network topology constrains possible dynamics
  • Collective attractors emerge from node interactions
  • Basin of attraction depends on network connectivity
  • Resilience depends on network structure (e.g., hub removal affects recovery)

Higher-order networks (hypergraphs):

  • Hypergraph structure creates different attractor landscapes
  • Group interactions can stabilize or destabilize attractors
  • Multi-way interactions affect basin boundaries
  • Hypergraph interventions can shift systems between attractor states

Example: In epidemiology, the contact network structure determines:

  • Disease-free attractor: Stable when network is sparse or vaccination coverage is high
  • Endemic attractor: Stable when network is dense and transmission is high
  • Basin of attraction: Region of state space (initial conditions) that converge to each attractor
  • Tipping point: Critical network structure or vaccination threshold that triggers attractor transition

The hypergraph structure (group meetings) can create additional attractor states:

  • Group transmission attractor: Stable when hyperedges (group meetings) are frequent
  • Isolated group attractor: Stable when hyperedges are removed (social distancing)

Connection to FEP: The Free Energy Principle (see From Structure to Time: FEP and Attractors) explains why systems evolve towards attractor states. Network structure (graph/hypergraph) determines the free energy landscape, and systems minimise free energy by evolving towards attractor states. Interventions that modify network structure (e.g., \(do(G \leftarrow G^*)\) or \(do(H \leftarrow H^*)\)) change the free energy landscape, potentially shifting attractors or changing basin boundaries.

19.5.8.1 Interventions in Multiagent Networks

Interventions can target specific agents, policies, or network structure:

101×2 DataFrame
76 rows omitted
Row time infected
Int64 Int64
1 0 4
2 1 6
3 2 7
4 3 7
5 4 8
6 5 8
7 6 7
8 7 7
9 8 6
10 9 5
11 10 5
12 11 5
13 12 4
⋮ ⋮ ⋮
90 89 0
91 90 0
92 91 0
93 92 0
94 93 0
95 94 0
96 95 0
97 96 0
98 97 0
99 98 0
100 99 0
101 100 0

Intervention in multiagent network: vaccinating specific agents

Comparison of baseline vs vaccination intervention on epidemic dynamics

Key insight: Agent-level interventions (\(do(A^i_t = a)\)) have system-level effects through network propagation. This connects to Chapter 13-14 (interventions in dynamical systems) and Chapter 22-23 (interventional forecasting and policy evaluation).

19.5.8.2 Spatial Models with Distance Calculations

For spatial agent-based models (using GridSpace or ContinuousSpace), Agents.jl 7 provides neighbourhood search and scheduling utilities. The following example demonstrates distance-weighted interactions on a grid:

Spatial model with distance calculations:
  Agents: 20
  Grid size: (10, 10)
  Simulation steps: 50
  Final healthy: 0
  Final infected: 20

Note on Agents.jl 7 (grid example): Agent IDs are read-only fields on @agent types; compare with agent.id. For spatial models, distance calculations can be implemented based on the space type:

  • GridSpace: Manhattan distance = |x₁ - x₂| + |y₁ - y₂|
  • ContinuousSpace: Euclidean distance = √((x₁ - x₂)² + (y₁ - y₂)²)
  • GraphSpace: Path distance via graph algorithms

This example demonstrates how distance-based interactions enable more realistic spatial agent models, where interactions depend on physical proximity rather than just network connections.

19.5.8.3 Integration with StateSpaceDynamics.jl for Inference

For inference in multiagent networks, we can combine Agents.jl (simulation) with StateSpaceDynamics.jl (inference):

Fitting LDS via EM...  10%|█████                                             |  ETA: 0:00:05 ( 0.26  s/it)
Fitting LDS via EM... 100%|██████████████████████████████████████████████████| Time: 0:00:00 (30.57 ms/it)

([4.539720818244438 7.046264882307417 … 24.967134930529745 22.339885478366167], [3.94761421999677 8.35783174350412 … 29.209533905609067 22.064096688132793])

Inferring latent agent states from observed behaviours using state-space models

Observed infections vs state-space model fit and inferred latent state trajectory

This connects Observable (observed behaviours) → Dynamical (inferred latent states) → Structural (agent mechanisms), using state-space models to summarise complex multiagent dynamics in a lower-dimensional latent process.

Key insight: State-space inference enables us to infer latent agent states (e.g., infection status) from observed behaviours (e.g., contacts, symptoms), connecting to Chapter 12 (state-space models) and Chapter 19 (observational methods).

19.5.9 Example Applications

19.5.9.1 Epidemiological Multiagent Networks

Agents: Individuals in a population Network: Contact network (who interacts with whom) Higher-order: Group meetings (hyperedges) Agent decisions: Contact behaviour (who to meet, when) Interventions:

  • Vaccinate specific individuals: \(do(A^i_t = \text{vaccinated})\)
  • Change contact behaviour: \(do(\pi^i \leftarrow \pi^*)\) (e.g., social distancing)
  • Isolate individuals: \(do(G \leftarrow G^*)\) (remove edges)
  • Ban group meetings: \(do(H \leftarrow H^*)\) (remove hyperedges)

State-space model:

  • Latent: Individual infection status, immunity
  • Observed: Contacts, symptoms, test results
  • Inference: Infer who is infected from observed contacts/symptoms

19.5.9.2 Economic Multiagent Networks

Agents: Firms, consumers Network: Supply chains, market connections Higher-order: Cartels, coalitions (hyperedges) Agent decisions: Pricing, purchasing, production Interventions:

  • Subsidise specific firms: \(do(A^i_t = \text{subsidised})\)
  • Change pricing strategy: \(do(\pi^i \leftarrow \pi^*)\)
  • Create new market connections: \(do(G \leftarrow G^*)\)
  • Break up cartels: \(do(H \leftarrow H^*)\) (remove hyperedges)

19.5.9.3 Ecological Multiagent Networks

Agents: Individual organisms Network: Interaction network (predation, competition, mutualism) Higher-order: Group behaviours (flocking, herding) Agent decisions: Foraging, movement, reproduction Interventions:

  • Remove specific individuals: \(do(A^i_t = \text{removed})\)
  • Change behaviour: \(do(\pi^i \leftarrow \pi^*)\) (e.g., migration patterns)
  • Modify interactions: \(do(G \leftarrow G^*)\)

19.5.10 Connection to CDM Framework

Multiagent networks are a natural instantiation of CDMs (see Chapter 28):

  • Graph structure: Agent network \(G\) (and hypergraph \(H\) for higher-order interactions)
  • Latent process: Agent states \(X^i_t\) with dynamics \(f_i(\cdot)\)
  • Observation model: Agent behaviours \(Y^i_t\) (what is measured/recorded)
  • Interventions: Agent-level, policy, network, and hypergraph interventions
  • Counterfactuals: Agent-level alternative concrescences (same creative advance \(\mathbf{u}\) per organism; Ch. 9)

This provides a concrete, implementable example of CDMs that readers can run and experiment with, bridging theory (CDM framework) and practice (multiagent systems).

19.6 Resilience and Robustness: System Stability

19.6.1 Stability

19.6.1.1 Local Stability

Local stability measures response to small perturbations near equilibrium (Strogatz 2014):

  • Eigenvalues: Linear stability analysis
  • Lyapunov exponents: Rate of divergence/convergence
  • Jacobian: Local linearisation

19.6.1.2 Global Stability

Global stability measures response to large perturbations:

  • Basin of attraction: Region of state space that converges to equilibrium
  • Global Lyapunov function: Energy-like function that decreases

19.6.2 Resilience

Resilience is the ability to recover from perturbations (Holling 1973):

  • Engineering resilience: Speed of return to equilibrium
  • Ecological resilience: Ability to maintain function despite perturbations
  • Recovery time: Time to return to equilibrium after perturbation

19.6.3 Robustness

Robustness is the ability to maintain function under variation (Kitano 2004):

  • Local robustness: Robustness to small parameter changes
  • Nonlocal robustness: Robustness to large parameter changes
  • Structural robustness: Robustness to structural perturbations (edge/node removal)

19.6.4 Resilience and Robustness as Causal Functionals

Resilience and robustness can be defined as model-based causal functionals, quantities computed from fitted generative models:

  • Resilience metrics: Computed from model dynamics (e.g., recovery time, basin size)
  • Robustness metrics: Computed from model structure (e.g., sensitivity to parameter changes)
  • Causal questions: “How does intervention \(A\) affect system resilience?” requires causal modelling

19.6.5 Intervention Effects on Resilience

Causal questions about resilience:

  • “How does removing a keystone species affect ecosystem resilience?”
  • “How does early intervention affect recovery from later shocks?”
  • “What interventions maximise system robustness?”

These require understanding how interventions modify system dynamics and structure, affecting attractor stability and recovery properties.

19.6.6 Network Structure, Attractors, and Resilience

The connection between network structure, attractor dynamics, and resilience is fundamental to understanding complex systems:

Network topology → Attractor structure → Resilience:

  • Graph structure (pairwise interactions) determines possible attractor states
  • Hypergraph structure (higher-order interactions) creates additional attractor states
  • Attractor stability depends on network connectivity and structure
  • Basin of attraction determines which perturbations lead to which attractors
  • Resilience depends on attractor stability and basin size

Example: Multiagent epidemic network:

  • Sparse network: Small basin for disease-free attractor, system easily transitions to endemic
  • Dense network: Large basin for endemic attractor, system resists transition to disease-free
  • Hypergraph structure: Group meetings (hyperedges) can create additional attractor states
  • Intervention: Removing hyperedges (banning group meetings) can shift attractor landscape, changing basin boundaries and resilience

Tools for analysis:

  • Graphs.jl: Analyse pairwise network structure and its effect on attractor dynamics
  • Hypergraphs (pedagogical helpers): Analyse higher-order interactions affecting attractors
  • Decapodes.jl: Compose subsystems and analyse how composition affects attractor landscape
  • Lux.jl + OrdinaryDiffEq.jl: Learn dynamics from data via UDEs and identify attractor structure

Connection to CDMs: In a CDM framework, network structure (graph/hypergraph) is part of the graph structure component, attractor dynamics are part of the latent process component, and resilience is a causal functional computed from the model. Interventions that modify network structure (\(do(G \leftarrow G^*)\) or \(do(H \leftarrow H^*)\)) affect attractor dynamics and resilience, enabling causal reasoning about system stability.

19.7 Stratum context

This chapter addresses advanced topics in the Dynamical layer: temporal processes that extend basic ODEs and SDEs:

  • Regime switching: Multiple dynamic attractors, tipping points
  • Network dynamics: Interaction structure and collective behaviour
  • Resilience and robustness: System stability as causal functionals

All these concepts operate in the Dynamical layer: time has entered, but we are still describing latent dynamics rather than measurement and data.

19.8 Key Takeaways

  1. Regime switching: Systems can have multiple dynamic attractors with threshold-driven transitions
  2. Network models: Interaction structure creates complex system behaviour
  3. Dynamics on networks: Node and edge dynamics compose into system-level behaviour
  4. Multiagent networks: Nodes as autonomous agents enable modelling of individual decisions composing into collective behaviour
  5. Higher-order interactions: Hypergraphs enable modelling of multi-way agent interactions beyond pairwise (pedagogical / experimental helpers)
  6. Interventions in multiagent systems: Agent-level, policy, network, and hypergraph interventions with clear \(do(\cdot)\) semantics
  7. Multiagent networks as CDMs: Natural instantiation of Causal Dynamical Models where agents are stateful decision-making units
  8. Network structure and attractors: Graph and hypergraph structure determines attractor landscape, basin boundaries, and system resilience
  9. Resilience: Ability to recover from perturbations, a causal functional that depends on attractor stability and basin size
  10. Robustness: Ability to maintain function under variation, a causal functional that depends on network structure and attractor dynamics
  11. Still dynamical: These advanced topics focus on dynamics; measurement and estimation live in the Observable layer

19.9 Tooling notes for the examples

The worked examples in this chapter assume:

  • Agents.jl 7: @agent types, StandardABM, automatic data collection via run!, and neighbourhood utilities on GraphSpace / GridSpace
  • GraphMakie.jl (fork with Graphs 1.x): Enhanced graph layouts, better styling options, support for larger graphs
  • Decapodes.jl (fork with CombinatorialSpaces 0.9): Better composition capabilities and stability
  • DiagrammaticEquations.jl (fork): Updated compatibilities enable better integration

Key improvements in code examples:

  • Automatic data collection using run! (DataFrame column :time) instead of manual loops
  • Enhanced graph visualizations with better layouts
  • More efficient agent access using model[id] syntax
  • Progress meters for long simulations (set showprogress = true)

19.10 Further Reading

  • Hamilton (1994): Time Series Analysis: Regime switching models
  • Scheffer et al. (2009): “Early-warning signals for critical transitions”
  • Newman (2018): Networks: Network theory
  • Barrat et al. (2008): Dynamical Processes on Complex Networks
  • Datseris et al. (2022): Agents.jl package for agent-based modelling in Julia
  • Battiston et al. (2020): “Networks beyond pairwise interactions”, Higher-order networks and hypergraphs
  • Fairbanks (2025): ACSets.jl framework for higher-order relational structures (JuliaCon 2025)
  • Gilbert (2008): Agent-Based Models: Introduction to agent-based modelling
  • Wooldridge (2009): An Introduction to MultiAgent Systems: Multiagent systems theory
  • Fudenberg and Tirole (1991): Game Theory: Strategic interactions
  • Holling (1973): “Resilience and stability of ecological systems”
  • State-Space Models: Inferring Structure from Observations: How to infer these dynamics from observations
  • CDMs: The Unified Framework: How multiagent networks instantiate Causal Dynamical Models