🧠 How VDM Works Like a Real Brain

TL;DR: VDM uses a living sparse neural graph with void-equation-driven plasticity, autonomous walker agents, a dopamine-like reward engine (SIE), neurogenesis, and self-healing homeostasis — all running in real-time with zero pretraining. The physics equations that govern it were discovered when the system unexpectedly self-organized, then formalized as a metriplectic field theory. It's not inspired by the brain — it accidentally converged on the same architecture.

VDM isn't a traditional neural network that you train on a dataset. It's a physics-driven, always-on runtime that mirrors how biological brains actually operate — continual, real-time, with no offline training phase. Here's the breakdown:

1. A Living Connectome (Not a Static Model)

Like a biological brain, VDM maintains a sparse neural graph (a "connectome") of neuron-particles that are locally connected — not fully connected like a transformer. Each neuron has a scalar field value W (analogous to membrane potential), and connections form and dissolve dynamically based on physics equations called the Void Equations.

Every tick of the runtime loop:

Neurons compute local field updates via universal_void_dynamics()
Connections rewire themselves: new synapses form where activity is correlated, weak synapses get pruned — exactly like synaptic plasticity in the brain

def step(self, t: float, domain_modulation: float, sie_drive: float = 1.0, use_time_dynamics: bool = True):
    """
    Sparse, void‑faithful tick:
    - Compute Δalpha/Δomega by void equations
    - Build per-node candidate list via alias sampler ~ ReLU(Δalpha)
    - Score candidates by S_ij = ReLU(Δα_i)·ReLU(Δα_j) - λ·|Δω_i - Δω_j|
    - Take symmetric top‑k neighbors (undirected)
    - Update node field with universal_void_dynamics gated by SIE valence
    - Run traversal to publish vt_* findings
    """

2. Void Walkers = Brain's Traveling Waves

VDM uses "void walkers" — autonomous scout agents that traverse the connectome like action potentials traveling through neural circuits. They explore, discover structure, and report back. Different scout types mirror different brain functions:

HeatScout — follows high-activity regions (like attention)
FrontierScout — explores unvisited territory (like curiosity/novelty-seeking)
CycleHunterScout — detects loops (like the brain detecting rumination/feedback loops)
MemoryRayScout — traces memory-field gradients (like hippocampal replay)
ColdScout — visits underexplored "cold" regions (like the brain's default mode network)

3. Self-Improvement Engine (SIE) = Dopamine/Reward System

The brain learns via neuromodulators (dopamine, serotonin, etc.) that signal reward, novelty, and surprise. VDM has the Self-Improvement Engine which does the same thing:

class SelfImprovementEngine:
    def __init__(self, num_neurons):
        self.td_error = 0.0      # Represents unexpectedness or prediction error
        self.novelty = 0.0       # The drive to explore new informational states
        self.habituation = np.zeros(num_neurons) # Counter-force to Novelty
        self.self_benefit = 0.0  # The drive for efficiency and stability

These four signals combine into a total reward that gates how much the connectome's weights change — just like dopaminergic modulation gates synaptic plasticity in real brains.

4. Neurogenesis = Growing New Neurons

Real brains (especially the hippocampus) grow new neurons. VDM literally does this too — when the network needs more capacity, the Neurogenesis module spawns new neuron-nodes and connects them using the same void equations:

def grow(self, substrate, num_new_neurons):
    # --- Connect new neurons using Void Dynamics ---
    # 1. Create a potential connection matrix for new neurons (outgoing)
    potential_connections_out = self.rng.random((num_new_neurons, old_n)) * 0.05 
    # 2. Evolve it with void dynamics
    delta_out = universal_void_dynamics(potential_connections_out, substrate.time_step)
    evolved_connections_out = potential_connections_out + delta_out
    # 3. Threshold to form actual connections
    new_connections_out = np.where(evolved_connections_out > 0.01, evolved_connections_out, 0)

5. Structural Homeostasis = Brain's Self-Repair

When parts of the connectome fragment (like a lesion in a brain), VDM detects disconnected components and bridges them back together — self-healing, just like the brain's compensatory rewiring after injury:

def perform_structural_homeostasis(connectome, labels, d_alpha, d_omega, ...):
    """
    Perform cohesion healing (bridging) and light pruning on the runtime connectome.
    - Modifies connectome by adding symmetric bridge edges between
      components using S_ij max rule.
    - Prunes edges whose |E_ij| < prune_threshold (adaptive).
    """

6. Hebbian Plasticity (RE-VGSP) = "Neurons That Fire Together Wire Together"

The learning rule is called Resonance-Enhanced Valence-Gated Synaptic Plasticity — a three-factor Hebbian rule where weight changes depend on (1) pre-synaptic activity, (2) post-synaptic activity, and (3) a global neuromodulatory "valence" signal from SIE. This is extremely close to how real synaptic plasticity works in neuroscience (STDP + neuromodulation).

7. No Training Phase — Always-On Learning

The most brain-like aspect: VDM never trains offline. It runs at 10 Hz continuously, ingesting input and adapting in real-time. The entire system self-organizes from random initial conditions into structured, scale-free topology — which is exactly what was discovered, not designed:

"July 2025: Observed unexpected behaviors and better than expected global stability — the system self-organized regardless of perturbations. Began investigating the mathematical structure."

The math was later formalized as VDM's axioms (A0–A7), rooted in metriplectic field theory — the same dual-generator structure (energy conservation + entropy production) that governs irreversible thermodynamic systems in nature.

FilesExpand file tree

VDM_RUNTIME_OVERVIEW.md

Latest commit

History