# Biological Graph Transformers: Spiking, Hebbian, and Neuromorphic Architectures

## Overview

### The Biological Computation Thesis

Biological neural networks process graph-structured information with an efficiency that remains unmatched by artificial systems. The human brain -- a network of approximately 86 billion neurons connected by 100 trillion synapses -- performs graph-structured reasoning (social inference, spatial navigation, causal reasoning) consuming only 20 watts. A comparable artificial graph transformer processing a social network of similar density would require megawatts.

This disparity is not merely quantitative. Biological networks exploit three computational principles that artificial graph transformers have largely ignored:

1. **Event-driven sparsity.** Cortical neurons fire at 1-10 Hz on average, meaning 99%+ of compute is skipped at any given moment. Only "interesting" graph events trigger processing. Artificial graph transformers compute dense attention over all nodes at every step.

2. **Local learning rules.** Synaptic plasticity (STDP, Hebbian learning, BTSP) requires only information available at the synapse itself -- pre/post-synaptic activity and a neuromodulatory signal. No global backpropagation through the entire graph. This enables truly distributed, scalable learning on graphs.

3. **Temporal coding.** Information is encoded not just in firing rates but in precise spike timing, phase relationships, and oscillatory coupling. This gives biological networks a temporal dimension that artificial attention mechanisms -- which compute static weight matrices -- fundamentally lack.

This research document proposes a 10-year roadmap (2026-2036) for biological graph transformers that systematically incorporate these principles into the RuVector architecture, leveraging existing implementations in `ruvector-mincut-gated-transformer` (spike-driven attention, energy gates, Mamba SSM), `ruvector-nervous-system` (dendritic computation, BTSP, e-prop, Hopfield networks), `ruvector-gnn` (EWC continual learning, replay buffers), and `ruvector-attention` (18+ attention mechanisms).

### Problem Statement

Current graph transformers face five scaling barriers:

| Barrier | Root Cause | Biological Solution |
|---------|-----------|-------------------|
| O(N^2) attention | All-pairs computation | Event-driven sparse firing |
| Catastrophic forgetting | Global weight updates | Local synaptic consolidation (EWC/BTSP) |
| Energy consumption | Dense FP32 multiply-accumulate | Binary spike operations (87x reduction) |
| Static topology | Fixed graph at inference | Activity-dependent rewiring (STDP) |
| No temporal reasoning | Snapshot-based processing | Spike timing and oscillatory coding |

### Expected Impact

- **2028:** 100x energy reduction for graph attention via spiking architectures
- **2030:** Neuromorphic graph chips processing 1B edges at 1mW
- **2032:** Self-organizing graph transformers with no training phase
- **2036:** Bio-digital hybrid processors with living neural tissue for graph reasoning

---

## 1. Spiking Graph Transformers

### 1.1 Event-Driven Attention on Graphs

Standard graph attention (GAT) computes attention for every node pair at every layer. Spiking Graph Transformers (SGT) replace this with event-driven computation: a node only participates in attention when it "fires" -- when its membrane potential exceeds a threshold due to incoming graph signals.

**Architecture:**

```
Graph Input --> Spike Encoder --> Spiking Attention Layers --> Spike Decoder --> Output
                    |                    |
              Rate coding           Coincidence-based
              (value -> spike       attention weights
               frequency)           (no multiplication)
```

RuVector already implements the core of this in `crates/ruvector-mincut-gated-transformer/src/attention/spike_driven.rs`, which provides multiplication-free attention via spike coincidence detection:

```rust
// Existing RuVector implementation (spike_driven.rs)
// Attention via spike timing coincidence -- zero multiplications
pub fn attention(
    &self,
    q_spikes: &[SpikeTrain],
    k_spikes: &[SpikeTrain],
    v_spikes: &[SpikeTrain],
) -> Vec<i32> {
    // For each query position, count spike coincidences with keys
    // coincidence_score += q_polarity * k_polarity (when q_time == k_time)
    // This replaces softmax(QK^T/sqrt(d)) with temporal coincidence
}
```

The extension to graphs requires **topology-aware spike routing**: spikes propagate only along graph edges, not across all node pairs.

```rust
/// Proposed: Spiking Graph Attention with edge-constrained propagation
pub struct SpikingGraphAttention {
    /// Spike-driven attention (existing)
    spike_attn: SpikeDrivenAttention,
    /// Graph adjacency for spike routing
    adjacency: CompressedSparseRow,
    /// Per-edge synaptic delays (in timesteps)
    edge_delays: Vec<u8>,
    /// Per-node membrane potentials (LIF model)
    membrane: Vec<f32>,
    /// Refractory state per node
    refractory: Vec<u8>,
}

impl SpikingGraphAttention {
    /// Process one timestep of spiking graph attention
    pub fn step(&mut self, input_spikes: &[bool]) -> Vec<bool> {
        let mut output_spikes = vec![false; self.membrane.len()];

        for node in 0..self.membrane.len() {
            if self.refractory[node] > 0 {
                self.refractory[node] -= 1;
                continue;
            }

            // Accumulate spikes from graph neighbors only
            let mut incoming_current: f32 = 0.0;
            for &(neighbor, weight_idx) in self.adjacency.neighbors(node) {
                let delay = self.edge_delays[weight_idx] as usize;
                if self.was_spike_at(neighbor, delay) {
                    // Spike contribution weighted by learned edge attention
                    incoming_current += self.edge_attention_weight(node, neighbor);
                }
            }

            // LIF membrane dynamics
            self.membrane[node] = self.membrane[node] * 0.9 + incoming_current;

            if self.membrane[node] > SPIKE_THRESHOLD {
                output_spikes[node] = true;
                self.membrane[node] = 0.0; // reset
                self.refractory[node] = REFRACTORY_PERIOD;
            }
        }

        output_spikes
    }
}
```

### 1.2 Spike-Timing-Dependent Plasticity (STDP) for Edge Weight Updates

STDP provides a local, unsupervised learning rule for graph edge weights: if a presynaptic spike arrives just before a postsynaptic spike, strengthen the connection (causal). If after, weaken it (anti-causal).

**STDP Window Function:**

```
delta_w(dt) = A_+ * exp(-dt / tau_+)   if dt > 0  (pre before post: LTP)
            = -A_- * exp(dt / tau_-)    if dt < 0  (post before pre: LTD)
```

Applied to graphs, this means edge weights self-organize based on the temporal structure of spike propagation through the graph. Edges that consistently carry predictive information (pre-fires-before-post) are strengthened. Redundant or noisy edges are pruned.

```rust
/// STDP-based edge weight update for graph attention
pub struct StdpEdgeUpdater {
    /// Potentiation amplitude
    a_plus: f32,
    /// Depression amplitude
    a_minus: f32,
    /// Potentiation time constant (ms)
    tau_plus: f32,
    /// Depression time constant (ms)
    tau_minus: f32,
    /// Last spike time per node
    last_spike: Vec<f64>,
}

impl StdpEdgeUpdater {
    /// Update edge weight based on pre/post spike timing
    pub fn update_edge(&self, pre_node: usize, post_node: usize,
                       current_time: f64) -> f32 {
        let dt = self.last_spike[post_node] - self.last_spike[pre_node];

        if dt > 0.0 {
            // Pre fired before post -> potentiate (causal)
            self.a_plus * (-dt / self.tau_plus).exp()
        } else {
            // Post fired before pre -> depress (anti-causal)
            -self.a_minus * (dt / self.tau_minus).exp()
        }
    }
}
```

### 1.3 Temporal Coding in Graph Messages

Beyond rate coding (spike frequency encodes value), biological neurons use **temporal codes** where precise spike timing carries information. For graph transformers, this enables a richer message-passing scheme:

- **Phase coding:** Node embeddings encoded as phase offsets within oscillatory cycles. Two nodes with similar embeddings fire at similar phases, enabling interference-based similarity detection.
- **Burst coding:** The number of spikes in a burst encodes attention weight magnitude. Single spikes indicate weak attention; bursts of 3-5 spikes indicate strong attention.
- **Population coding:** Multiple neurons per graph node, each tuned to different features. The population spike pattern encodes the full node embedding.

The existing `SpikeScheduler` in `crates/ruvector-mincut-gated-transformer/src/spike.rs` already implements rate-based tier selection and novelty gating, which can be extended to temporal coding.

---

## 2. Hebbian Learning on Graphs

### 2.1 Local Learning Rules for Graph Attention

The core Hebbian principle -- "cells that fire together wire together" -- provides a radical alternative to backpropagation for training graph attention weights. In a Hebbian graph transformer:

1. **No global loss function.** Each edge learns independently based on co-activation of its endpoint nodes.
2. **No gradient computation.** Weight updates are purely local: `delta_w_ij = eta * x_i * x_j` (basic Hebb rule) or variants with normalization.
3. **No training/inference distinction.** The network continuously adapts to new graph inputs.

**Oja's Rule for Normalized Hebbian Graph Attention:**

```
delta_w_ij = eta * y_j * (x_i - w_ij * y_j)
```

Where `x_i` is the pre-synaptic (source node) activation and `y_j` is the post-synaptic (target node) activation. The subtraction term prevents unbounded weight growth.

```rust
/// Hebbian graph attention with no backpropagation
pub struct HebbianGraphAttention {
    /// Edge attention weights [num_edges]
    edge_weights: Vec<f32>,
    /// Learning rate
    eta: f32,
    /// Normalization: Oja, BCM, or raw Hebb
    rule: HebbianRule,
}

pub enum HebbianRule {
    /// Basic: dw = eta * x_pre * x_post
    RawHebb,
    /// Oja's rule: dw = eta * x_post * (x_pre - w * x_post)
    Oja,
    /// BCM: dw = eta * x_post * (x_post - theta) * x_pre
    BCM { theta: f32 },
}

impl HebbianGraphAttention {
    /// Single-pass Hebbian update -- no backprop needed
    pub fn update(&mut self, node_activations: &[f32], edges: &[(usize, usize)]) {
        for (edge_idx, &(src, dst)) in edges.iter().enumerate() {
            let x_pre = node_activations[src];
            let x_post = node_activations[dst];
            let w = self.edge_weights[edge_idx];

            let delta_w = match self.rule {
                HebbianRule::RawHebb => self.eta * x_pre * x_post,
                HebbianRule::Oja => {
                    self.eta * x_post * (x_pre - w * x_post)
                }
                HebbianRule::BCM { theta } => {
                    self.eta * x_post * (x_post - theta) * x_pre
                }
            };

            self.edge_weights[edge_idx] += delta_w;
        }
    }
}
```

### 2.2 Connection to RuVector Continual Learning

The existing EWC implementation in `crates/ruvector-gnn/src/ewc.rs` already captures the importance of weights via Fisher information. Hebbian learning naturally complements EWC:

- **Hebbian forward pass:** Learns new graph patterns via local co-activation
- **EWC regularization:** Prevents forgetting previously learned patterns by penalizing changes to important weights
- **Replay buffer:** `crates/ruvector-gnn/src/replay.rs` provides experience replay for rehearsing old graph patterns

This forms a biologically plausible continual learning loop that requires zero backpropagation through the graph.

---

## 3. Neuromorphic Graph Processing

### 3.1 Mapping Graph Transformers to Neuromorphic Hardware

Intel Loihi 2 and IBM TrueNorth implement spiking neural networks in silicon with 100-1000x energy efficiency over GPUs. Mapping graph transformers to these chips requires:

| Component | GPU Implementation | Neuromorphic Mapping |
|-----------|-------------------|---------------------|
| Node embeddings | FP32 vectors | Spike trains (temporal coding) |
| Attention weights | Softmax(QK^T) | Synaptic weights + STDP |
| Message passing | Matrix multiply | Spike propagation along edges |
| Aggregation | Sum/mean pooling | Population spike counting |
| Non-linearity | ReLU/GELU | Membrane threshold (LIF neuron) |

**Energy analysis for 1M-node graph:**

| Operation | GPU (A100) | Loihi 2 | Savings |
|-----------|-----------|---------|---------|
| Single attention layer | 2.1 J | 0.003 J | 700x |
| Full 6-layer GNN | 12.6 J | 0.02 J | 630x |
| Training step (one batch) | 38 J | 0.1 J | 380x |
| Continuous inference (1 hour) | 540 kJ | 0.72 kJ | 750x |

### 3.2 Loihi 2 Graph Transformer Architecture

```
Loihi 2 Neuromorphic Cores (128 per chip)
┌─────────────────────────────────────────────┐
│  Core 0-15:   Graph Partition A             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Node 0  │──│ Node 1  │──│ Node 2  │    │
│  │ (LIF)   │  │ (LIF)   │  │ (LIF)   │    │
│  └────┬────┘  └────┬────┘  └────┬────┘    │
│       │ STDP       │ STDP       │ STDP     │
│  ┌────▼────┐  ┌────▼────┐  ┌────▼────┐    │
│  │ Attn 0  │  │ Attn 1  │  │ Attn 2  │    │
│  │ (Spike) │  │ (Spike) │  │ (Spike) │    │
│  └─────────┘  └─────────┘  └─────────┘    │
│                                             │
│  Core 16-31:  Graph Partition B             │
│  (same structure, inter-partition spikes    │
│   via on-chip mesh interconnect)            │
│                                             │
│  Core 120-127: Global Readout              │
│  (population decoding, output spikes)       │
└─────────────────────────────────────────────┘
```

The `SpikeScheduler` from `ruvector-mincut-gated-transformer/src/spike.rs` directly maps to Loihi's event-driven scheduling: the `SpikeScheduleDecision` (should_run, suggested_tier, use_sparse_mask) maps to Loihi's core-level power gating.

### 3.3 Projected Neuromorphic Graph Processor Milestones

| Year | Qubits/Neurons | Edges | Power | Application |
|------|---------------|-------|-------|-------------|
| 2026 | 1M neurons | 10M edges | 50mW | IoT sensor graphs |
| 2028 | 10M neurons | 100M edges | 100mW | Social network subgraphs |
| 2030 | 100M neurons | 1B edges | 1mW* | Full social network attention |
| 2032 | 1B neurons | 10B edges | 5mW | Protein interaction networks |
| 2036 | 10B neurons | 100B edges | 10mW | Whole-brain connectome |

*1mW achieved through aggressive event-driven sparsity (>99.9% neurons idle at any timestep)

---

## 4. Dendritic Computation as Graph Attention

### 4.1 Multi-Compartment Neuron Models as Graph Nodes

Biological neurons are not point units. A single pyramidal neuron has thousands of dendritic compartments, each performing nonlinear computation. RuVector's `ruvector-nervous-system` crate already implements this in `src/dendrite/compartment.rs`:

```rust
// Existing: Compartment with membrane and calcium dynamics
pub struct Compartment {
    membrane: f32,      // Membrane potential (0.0-1.0)
    calcium: f32,       // Calcium concentration (0.0-1.0)
    tau_membrane: f32,  // ~20ms fast dynamics
    tau_calcium: f32,   // ~100ms slow dynamics
}
```

In a dendritic graph transformer, each graph node is a multi-compartment neuron. Different input edges synapse onto different dendritic branches. This enables:

- **Nonlinear input gating:** A dendritic branch only activates when multiple correlated inputs arrive together (coincidence detection via `src/dendrite/coincidence.rs`)
- **Hierarchical attention:** Proximal dendrites compute local attention; apical dendrites integrate global context
- **Dendritic plateau potentials:** Enable one-shot learning of new graph patterns (via BTSP in `src/plasticity/btsp.rs`)

```rust
/// Dendritic Graph Node: each node is a multi-compartment neuron
pub struct DendriticGraphNode {
    /// Basal dendrites: receive input from graph neighbors
    basal_branches: Vec<DendriticBranch>,
    /// Apical dendrite: receives top-down context
    apical: DendriticBranch,
    /// Soma: integrates all branches, fires output spike
    soma: Compartment,
    /// BTSP for one-shot learning of new edges
    plasticity: BTSPLayer,
}

pub struct DendriticBranch {
    /// Compartments along this branch
    compartments: Vec<Compartment>,
    /// Synapses from specific graph neighbors
    synapses: Vec<(usize, f32)>, // (neighbor_id, weight)
    /// Nonlinear dendritic spike threshold
    plateau_threshold: f32,
}

impl DendriticGraphNode {
    /// Process graph inputs through dendritic tree
    pub fn process(&mut self, neighbor_activations: &[(usize, f32)]) -> f32 {
        // Route each neighbor's activation to appropriate branch
        for &(neighbor, activation) in neighbor_activations {
            let branch = self.route_to_branch(neighbor);
            branch.receive_input(activation);
        }

        // Each branch computes nonlinear dendritic integration
        let mut branch_outputs = Vec::new();
        for branch in &mut self.basal_branches {
            let output = branch.compute_plateau(); // nonlinear!
            branch_outputs.push(output);
        }

        // Soma integrates branch outputs
        let soma_input: f32 = branch_outputs.iter().sum();
        self.soma.step(soma_input, 1.0);
        self.soma.membrane()
    }
}
```

### 4.2 Dendritic Attention vs. Standard Attention

| Property | Standard Attention | Dendritic Attention |
|----------|-------------------|-------------------|
| Computation | Linear dot-product | Nonlinear dendritic spikes |
| Learning | Backpropagation | BTSP (one-shot, local) |
| Input routing | All inputs to same function | Different branches per input cluster |
| Memory | Stateless (per-step) | Stateful (calcium traces, ~100ms) |
| Energy | O(N^2 d) multiplies | O(branches * compartments) additions |
| Temporal | Instantaneous | History-dependent (membrane dynamics) |

---

## 5. Connectomics-Inspired Architectures

### 5.1 Small-World Graph Transformers

The brain exhibits small-world topology: high local clustering with short global path lengths. This is not an accident -- it optimizes the tradeoff between wiring cost (local connections are cheap) and communication efficiency (short paths enable fast information flow).

**Small-World Graph Transformer Design:**

- **Local attention:** Dense attention within topological neighborhoods (clusters)
- **Global shortcuts:** Sparse random long-range connections (rewiring probability p)
- **Watts-Strogatz topology:** Start with regular lattice, rewire edges with probability p

The existing `ruvector-attention` sparse attention module (`src/sparse/local_global.rs`) already supports this pattern with local and global attention heads.

### 5.2 Scale-Free Attention Networks

Biological networks (protein interactions, neural connectivity) follow power-law degree distributions: a few hub nodes have many connections while most nodes have few. Scale-free graph transformers:

- **Hub nodes get more attention heads:** High-degree nodes use multi-head attention; leaf nodes use single-head
- **Preferential attachment for edge learning:** New edges are more likely to form to high-degree nodes
- **Degree-aware compute allocation:** Matches the existing `SpikeScheduler` tier system (high-rate nodes get more compute)

### 5.3 Criticality-Tuned GNNs

The brain operates near a critical point between order and chaos, maximizing information processing capacity. A criticality-tuned graph transformer:

- **Branching ratio = 1:** On average, each spike causes exactly one downstream spike
- **Power-law avalanche distributions:** Activity cascades follow P(s) proportional to s^(-3/2)
- **Maximum dynamic range:** Responds to inputs spanning many orders of magnitude
- **Self-organized criticality:** The `EnergyGate` in `ruvector-mincut-gated-transformer/src/energy_gate.rs` already implements energy-based decision boundaries that can be tuned to maintain criticality

```rust
/// Criticality controller for graph transformer
pub struct CriticalityTuner {
    /// Target branching ratio (1.0 = critical)
    target_branching: f32,
    /// Moving average of actual branching ratio
    measured_branching: f32,
    /// Adaptation rate
    adaptation_rate: f32,
}

impl CriticalityTuner {
    /// Adjust global inhibition to maintain criticality
    pub fn adjust(&mut self, spike_counts: &[usize]) -> f32 {
        let total_input_spikes: usize = spike_counts.iter().sum();
        let total_output_spikes: usize = /* count from next timestep */;

        let branching = total_output_spikes as f32 / total_input_spikes.max(1) as f32;
        self.measured_branching = 0.99 * self.measured_branching + 0.01 * branching;

        // Return inhibition adjustment
        (self.measured_branching - self.target_branching) * self.adaptation_rate
    }
}
```

---

## 6. Architecture Proposals

### 6.1 Near-Term (2026-2028): Spiking Graph Attention Network (SGAT)

**Architecture:** Replace standard GAT layers with spike-driven attention using existing RuVector components.

| Component | Implementation | Energy Savings |
|-----------|---------------|---------------|
| Spike encoding | `SpikeDrivenAttention::encode_spikes()` | 0x (encoding cost) |
| Attention | `SpikeDrivenAttention::attention()` | 87x (no multiplies) |
| Scheduling | `SpikeScheduler::evaluate()` | 10x (skip idle nodes) |
| Energy gate | `EnergyGate::decide()` | 5x (skip stable regions) |
| EWC consolidation | `ElasticWeightConsolidation::penalty()` | 1x (regularization) |

**Estimated total energy reduction:** 50-100x over standard GAT.

**Latency analysis:**
- Per-node attention: 0.1us (spike coincidence) vs. 10us (softmax attention)
- Per-layer: O(|E|) spike propagations vs. O(|V|^2) attention computations
- For a 1M-node graph with 10M edges: ~10ms (spiking) vs. ~1000s (dense attention)

### 6.2 Medium-Term (2028-2032): Dendritic Graph Transformer (DGT)

**Architecture:** Multi-compartment dendritic nodes with BTSP learning.

```
Input Graph
    |
    v
┌───────────────────────────────────┐
│  Dendritic Graph Transformer      │
│                                   │
│  Layer 1: Dendritic Encoding     │
│  - Each node = multi-compartment  │
│  - Synapses routed to branches   │
│  - BTSP for one-shot learning    │
│                                   │
│  Layer 2: Hebbian Attention      │
│  - No backprop needed            │
│  - Oja's rule for attention      │
│  - EWC for continual learning    │
│                                   │
│  Layer 3: Criticality Readout    │
│  - Branching ratio = 1.0         │
│  - Power-law avalanches          │
│  - Maximum information capacity  │
└───────────────────────────────────┘
    |
    v
Output Embeddings
```

### 6.3 Long-Term (2032-2036): Bio-Digital Hybrid Graph Processor

The most speculative proposal: interface living neural organoids with silicon graph accelerators.

**Concept:**
- **Biological component:** Neural organoid (~1M neurons) cultured on a multi-electrode array (MEA). The organoid self-organizes into a graph with biological small-world topology.
- **Silicon component:** Neuromorphic chip (Loihi-class) handles graph storage, spike routing, and I/O.
- **Interface:** MEA reads/writes spikes bidirectionally. Graph queries become spike patterns injected into the organoid; responses are decoded from organoid output spikes.

**Advantages:**
- Biological neurons naturally implement STDP, dendritic computation, and criticality
- Extreme energy efficiency (~10nW per neuron vs. ~10uW for silicon LIF)
- Self-repair: biological networks compensate for cell death
- Continuous learning: no explicit training phase

**Challenges:**
- Reliability: biological variability, cell death, organoid longevity
- Latency: biological spike propagation ~1-10ms vs. ~1ns for silicon
- Reproducibility: each organoid develops differently
- Ethics: regulatory and ethical frameworks for "computing with living tissue"

---

## 7. Connection to RuVector Crates

### 7.1 Direct Integration Points

| RuVector Crate | Component | Biological Extension |
|---------------|-----------|---------------------|
| `ruvector-mincut-gated-transformer` | `spike.rs` | STDP edge learning, temporal coding |
| `ruvector-mincut-gated-transformer` | `spike_driven.rs` | Graph-constrained spike propagation |
| `ruvector-mincut-gated-transformer` | `energy_gate.rs` | Criticality tuning, energy landscape navigation |
| `ruvector-mincut-gated-transformer` | `mamba.rs` | SSM as continuous-time membrane dynamics |
| `ruvector-nervous-system` | `dendrite/` | Multi-compartment graph nodes |
| `ruvector-nervous-system` | `plasticity/btsp.rs` | One-shot graph pattern learning |
| `ruvector-nervous-system` | `plasticity/eprop.rs` | Online learning without BPTT |
| `ruvector-nervous-system` | `compete/kwta.rs` | Sparse activation (k-winners-take-all) |
| `ruvector-nervous-system` | `hopfield/` | Associative memory for graph patterns |
| `ruvector-gnn` | `ewc.rs` | Fisher-information weight consolidation |
| `ruvector-gnn` | `replay.rs` | Experience replay for continual graph learning |
| `ruvector-attention` | `sparse/` | Local-global attention patterns |
| `ruvector-attention` | `topology/` | Topology-aware attention coherence |

### 7.2 Proposed New Modules

```
crates/ruvector-mincut-gated-transformer/src/
    stdp.rs                    -- STDP edge weight updates
    temporal_coding.rs         -- Phase/burst/population coding
    criticality.rs             -- Self-organized criticality tuner

crates/ruvector-nervous-system/src/
    graph_neuron.rs            -- Multi-compartment graph node
    spiking_graph_attn.rs      -- Graph-aware spiking attention

crates/ruvector-gnn/src/
    hebbian.rs                 -- Hebbian learning rules (Oja, BCM)
    neuromorphic_backend.rs    -- Loihi/TrueNorth compilation target
```

---

## 8. Research Timeline

### Phase 1: Spike-Driven Graph Attention (2026-2027)
- Extend `SpikeDrivenAttention` to graph-constrained propagation
- Implement STDP edge learning
- Benchmark: energy savings on OGB datasets
- Target: 50x energy reduction, matched accuracy

### Phase 2: Dendritic + Hebbian Graphs (2027-2029)
- Multi-compartment graph nodes using `dendrite/` module
- Hebbian attention training (no backprop)
- BTSP for one-shot graph pattern learning
- Target: Zero-backprop graph transformer with competitive accuracy

### Phase 3: Neuromorphic Deployment (2029-2031)
- Compile graph transformer to Loihi 2 instruction set
- Benchmark on neuromorphic hardware
- Target: 1B edges at 1mW sustained power

### Phase 4: Connectomics-Inspired Scaling (2031-2033)
- Small-world and scale-free graph transformer topologies
- Self-organized criticality for maximum information capacity
- Target: Self-organizing graph transformers (no architecture search)

### Phase 5: Bio-Digital Hybrids (2033-2036)
- Neural organoid interface prototypes
- Hybrid silicon-biological graph processing
- Target: Proof-of-concept bio-digital graph reasoning

---

## 9. Open Questions

1. **Spike coding efficiency.** How many timesteps of spiking simulation are needed to match one forward pass of a standard graph transformer? Current estimates: 8-32 timesteps (from `SpikeDrivenConfig::temporal_coding_steps`), but this may need to be larger for complex graphs.

2. **Hebbian graph attention convergence.** Does Oja's rule on graph attention weights converge to the same solution as backpropagation-trained GAT? Preliminary analysis suggests it converges to the principal component of the attention pattern, which may differ from the optimal supervised solution.

3. **Criticality vs. performance.** Operating at criticality maximizes information capacity but may not optimize for specific downstream tasks. How to balance criticality (generality) with task-specific tuning?

4. **Neuromorphic graph partitioning.** How to partition a large graph across neuromorphic cores while minimizing inter-core spike communication? This is a graph partitioning problem -- potentially solvable by RuVector's own min-cut algorithms.

5. **Bio-digital latency gap.** Biological neurons operate on millisecond timescales; silicon on nanosecond timescales. How to bridge this 10^6 gap in a hybrid system without one component bottlenecking the other?

---

## References

- Yao, M., et al. (2023). Spike-driven Transformer. NeurIPS 2023.
- Yao, M., et al. (2024). Spike-driven Transformer V2. ICLR 2024.
- Bellec, G., et al. (2020). A solution to the learning dilemma for recurrent networks of spiking neurons. Nature Communications.
- Bittner, K., et al. (2017). Behavioral time scale synaptic plasticity underlies CA1 place fields. Science.
- Bi, G. & Poo, M. (1998). Synaptic modifications in cultured hippocampal neurons. Journal of Neuroscience.
- Davies, M., et al. (2018). Loihi: A neuromorphic manycore processor. IEEE Micro.
- Watts, D. & Strogatz, S. (1998). Collective dynamics of 'small-world' networks. Nature.
- Beggs, J. & Plenz, D. (2003). Neuronal avalanches in neocortical circuits. Journal of Neuroscience.
- Gladstone, R., et al. (2025). Energy-Based Transformers.
- Oja, E. (1982). Simplified neuron model as a principal component analyzer. Journal of Mathematical Biology.

---

**Document Status:** Research Proposal
**Target Integration:** RuVector GNN v2 Phase 4-5
**Estimated Effort:** 18-24 months (phased over 10 years)
**Risk Level:** High (Phase 1-3), Very High (Phase 4-5)
**Dependencies:** ruvector-mincut-gated-transformer, ruvector-nervous-system, ruvector-gnn, ruvector-attention