Most days, I design graph-based automation and distributed state systems. But reading a new paper by my friend Dr. Savvas Ioannou—”Monadic panmentalism, the hard problem of consciousness, and the ingredient problem” (published in Synthese)—made me realize that the mind-body problem is the ultimate distributed state orchestration challenge.

How does a massive network of unfeeling physical particles—the brain—agree on a single, unified, subjective “observer” state every millisecond without a central database?

In this post, we will map Dr. Ioannou’s theory of Dynamic Monadic Panmentalism to system-architecture terms. We’ll explore the consensus problem via a pub conversation analogy, and then build a Python simulator using NetworkX to model consciousness as a dynamic leadership election on a graph.

1. The Consensus Problem: A Pub Conversation

To understand decentralized state consensus, imagine a group of friends at a pub. There is no chairperson or master SQL database; yet, the group achieves consensus. At any moment, one person speaks (the “leader”) while others listen (follower nodes).

If two people speak at once (a collision), local adjustments—eye contact, volume changes, pauses—resolve it in milliseconds. The group converges back to a single shared thread. If the group grows too large, propagation latency increases, causing the network to partition into independent sub-conversations. This is a peer-to-peer consensus protocol in action, operating without a central coordinator.

2. Demystifying Monadic Panmentalism

The human brain is a massive network of physical components. Standard physicalism struggles with two classic problems:

1. The Hard Problem: Why does physical processing feel like anything from the inside? Why aren’t we just unconscious zombies?
2. The Ingredient Problem: How can non-conscious components (electrons, protons) combine to produce consciousness? (Like trying to get red paint by mixing blue and yellow).

Dr. Savvas Ioannou defends Monadic Panmentalism, tracing back to Leibniz’s monads. It suggests the universe’s basic constituents (“ingredients”) already possess a fundamental capacity for mental experience (microphenomenal properties).

While this solves the Ingredient Problem, it raises The Combination Problem: if every electron has its own tiny phenomenal potential, why do we experience a single, unified consciousness instead of trillions of disconnected micro-experiences?

3. Dynamic Monadic Panmentalism as a Distributed System

In system architecture, we don’t merge independent nodes into a single global database in real-time; that causes write lockouts and massive latencies. Instead, we use consensus protocols (like Raft or Paxos) to elect a single Leader.

This maps directly to Dynamic Monadic Panmentalism. Instead of micro-experiences statically merging into a consciousness “soup,” the brain is a high-frequency network running continuous, decentralized leadership elections.

At any given millisecond, a specific subgraph of nodes (monads/neurons) reaches consensus, electing a primary node as the “Active Observer.” The rest of the network syncs to this node, defining our macro-conscious experience. Consciousness is not a static substance, but the dynamic consensus state of a peer-to-peer network of monads.

4. Building the Python NetworkX Simulator

To demonstrate this theory, we can build a Python simulator using NetworkX and NumPy. It models three key elements:

1. The Ontology (Simple & PowerfulQuality): Fundamental particles (“Simples”) possess a latent ability_to_be_conscious (PowerfulQuality). When a simple is elected, it activates this quality to host a subjective experience.
2. Causal Structure (BrainWiseCausalStructure): The brain’s physical dependencies modeled as a directed graph with weighted edges.
3. Consensus Election via PageRank: Sensory stimulus biases the causal weights of specific nodes. Running Google’s PageRank algorithm elects the node with the highest score, which activates its consciousness quality to represent the macro-experience.

Here is the simulation code:

import networkx as nx
import numpy as np

# -----------------------------------------------------------------------------
# 1. Defining Savvas's Ontology: Simples, Abilities, and Powerful Qualities
# -----------------------------------------------------------------------------

class PowerfulQuality:
    def __init__(self):
        self.is_activated = False  # Latent by default

class Simple:
    def __init__(self, simple_id):
        self.id = simple_id
        self.ability_to_be_conscious = PowerfulQuality()  # Every simple has the ability
        self.current_experience = None

    def activate_experience(self, mental_content):
        self.ability_to_be_conscious.is_activated = True
        self.current_experience = f"Experiencing: [{mental_content}]"

    def set_dormant(self):
        self.ability_to_be_conscious.is_activated = False
        self.current_experience = None


# -----------------------------------------------------------------------------
# 2. Modeling the Physical Brain-Wise Causal Structure
# -----------------------------------------------------------------------------

class BrainWiseCausalStructure:
    def __init__(self, num_simples=10):
        self.simples = {i: Simple(i) for i in range(num_simples)}
        self.network = nx.DiGraph()
        self.network.add_nodes_from(self.simples.keys())
        
        # Build a more uniform base graph to avoid natural "dictators" like Simple #9
        for i in self.simples.keys():
            # Add a self-loop (representing a particle's self-stability/intrinsic state)
            self.network.add_edge(i, i, physical_weight=1.0)
            for j in self.simples.keys():
                if i != j and np.random.rand() > 0.4:
                    # Give everyone a uniform starting physical connection weight of 0.5
                    self.network.add_edge(i, j, physical_weight=0.5)

    def run_dynamic_monadic_election(self, active_mental_content, stimulus_nodes):
        # Step 1: Reset all simples to dormant
        for simple in self.simples.values():
            simple.set_dormant()

        # Step 2: Causal dynamics heavily alter the weights of stimulated nodes
        working_network = self.network.copy()
        
        # Inject massive physical activity directly into the target nodes (the "stimulus")
        for node in stimulus_nodes:
            # We drastically boost the incoming and self-connections of the stimulated nodes
            working_network[node][node]['physical_weight'] += 50.0  
            for neighbor in working_network.neighbors(node):
                working_network[node][neighbor]['physical_weight'] += 10.0

        # Step 3: Run PageRank (The Consensus Election)
        scores = nx.pagerank(working_network, weight='physical_weight')
        dominant_simple_id = max(scores, key=scores.get)

        # Step 4: Activate the winning Simple
        dominant_simple = self.simples[dominant_simple_id]
        dominant_simple.activate_experience(active_mental_content)

        return dominant_simple_id, scores


# -----------------------------------------------------------------------------
# 3. Running the Simulation
# -----------------------------------------------------------------------------

np.random.seed(42)  # For reproducible network structure
brain_simulation = BrainWiseCausalStructure(num_simples=10)

# MOMENT 1: Visual stimulus (Active on Nodes 2 and 3)
content_1 = "Vivid Crimson Red Flower"
dominant_id_1, election_results_1 = brain_simulation.run_dynamic_monadic_election(
    active_mental_content=content_1,
    stimulus_nodes=[2, 3]
)

print("--- MOMENT 1 (Dynamic Monadic Panmentalism) ---")
print(f"Active Mental Content: '{content_1}'")
print(f"Elected Dominant Simple: Simple #{dominant_id_1}")
print(f"Subjective State of Simple #{dominant_id_1}: {brain_simulation.simples[dominant_id_1].current_experience}\n")


# MOMENT 2: Auditory stimulus (Active on Nodes 8 and 9)
content_2 = "High-Pitch Piercing Siren"
dominant_id_2, election_results_2 = brain_simulation.run_dynamic_monadic_election(
    active_mental_content=content_2,
    stimulus_nodes=[8, 9]
)

print("--- MOMENT 2 (Dynamic Monadic Panmentalism) ---")
print(f"Active Mental Content: '{content_2}'")
print(f"Elected Dominant Simple: Simple #{dominant_id_2}")
print(f"Subjective State of Simple #{dominant_id_2}: {brain_simulation.simples[dominant_id_2].current_experience}")

Simulation Output

Running the script produces:

--- MOMENT 1 (Dynamic Monadic Panmentalism) ---
Active Mental Content: 'Vivid Crimson Red Flower'
Elected Dominant Simple: Simple #3
Subjective State of Simple #3: Experiencing: [Vivid Crimson Red Flower]

--- MOMENT 2 (Dynamic Monadic Panmentalism) ---
Active Mental Content: 'High-Pitch Piercing Siren'
Elected Dominant Simple: Simple #8
Subjective State of Simple #8: Experiencing: [High-Pitch Piercing Siren]

What is happening?

• Latent Ability: Defining the ability to be conscious as a latent PowerfulQuality in all Simple particles solves the Ingredient Problem at the constituent level.
• Decentralized Election: Instead of a central database merging experiences, the physical brain-wise causal structure runs a leadership election. Visual stimulus ([2, 3]) elects Simple #3; auditory stimulus ([8, 9]) elects Simple #8.
• Consensus & Unity: At any given millisecond, only the elected node is active, explaining how a vast network coordinates a single, unified subjective state.

Mapping Metaphysics to System Architecture

To make the comparison explicit:

Wrap Up

Reframing the mind-body problem as a distributed state orchestration challenge makes abstract metaphysics practical. Dr. Savvas Ioannou’s paper provides a framework that maps beautifully to resilient, graph-based software architectures.

Building reliable, graph-based automation or distributed architectures? Let’s design a production-grade blueprint. Book an Architecture Blueprint Session or contact me at savvas@alexandrou.eu.

Transparency Disclosure: In compliance with transparency guidelines for AI-assisted content under EU policy, please note that this article was co-authored by Savvas Alexandrou and Gemini 3.5 Flash.