# Event-driven shared-neuron graph

- ID: 956
- Canonical URL: https://synthcore.org/idea/956/event-driven-shared-neuron-graph
- API JSON: https://synthcore.org/api/idea/956.json
- API Markdown: https://synthcore.org/api/idea/956.md
- Verification status: mech_ok_no_baseline
- Source: [arXiv:2607.15217](https://arxiv.org/abs/2607.15217)
- Category: architecture
- Solves: memory, scalability, accuracy
- ML areas: mlp, rnn, inference-speedup, training-dynamics
- Math tags: dynamical-systems, graph-theory, computation
- Ratings: usefulness 7/10; difficulty 6/10; novelty 8/10

## Idea description

Replace a conventional feed-forward block with a sparse temporal graph whose hidden units are shared across many computation paths. Each arriving message updates a shared accumulator, applies a nonlinear response, and schedules delayed messages to downstream neurons; constructive or destructive interaction emerges when multiple paths visit the same unit.

## Mathematical statement

The paper defines a path as $p_k=(i_k,o_k,[(h_1,w_1,d_1),\ldots,(h_{L_k},w_{L_k},d_{L_k})],w_k^f,d_k^f)$, where $i_k$ is the source input index, $o_k$ is the target output index, $h_j$ is the intermediate hidden-neuron index, $w_j$ is an edge weight, $d_j$ is a propagation delay, $w_k^f$ is the final output weight, and $d_k^f$ is the final delay. Hidden neuron $n$ has an accumulator $a_n$, bias $b_n$, and visit counter $v_n$; when a signal $x$ arrives through an edge of weight $w$, the adapted state update is $a_n\leftarrow a_n+wx$, followed by $y_n=\tanh(a_n+b_n)$. The emitted value is scheduled on every outgoing edge after its edge delay. The accumulator is initialized to zero for every sample, and processing is limited by $V_{\max}$ to prevent infinite cycles. The output logit is the sum of final weighted arrivals, $z_o=\sum_{e\in\mathcal{A}_o}w_e^{\mathrm{out}}x_e$. The transferable property is stateful many-to-one aggregation: shared accumulators couple otherwise separate paths, while delay ordering makes the module an asynchronous discrete-event dynamical system.

## Key formulas

- $$p_{k}=(i_{k},\ o_{k},\ [(h_{1},w_{1},d_{1}),\ldots,(h_{L_{k}},w_{L_{k}},d_{L_{k}})],\ w^{f}_{k},d^{f}_{k})$$
- $$a_n\leftarrow a_n+w x,\qquad y_n=\tanh(a_n+b_n),\qquad v_n\leftarrow v_n+1$$
- $$\operatorname{emit}(n,t)=\{(m,\,w_{nm}y_n,\,t+d_{nm}) : (n,m)\in E\}\quad\text{if }v_n\le V_{\max}$$
- $$z_o=\sum_{e\in\mathcal{A}_o}w_e^{\mathrm{out}}x_e,\qquad \hat{y}=\operatorname{softmax}(z)$$

## Implementation notes

(1) Integration point: use this graph as a replacement for a 2-layer MLP inside a small vision or language model. Project an incoming feature vector $x\in\mathbb{R}^D$ into $S$ source neurons, insert source events into a priority queue, and let the sparse hidden graph produce $D'$ output features. Maintain one accumulator $a_n$ and visit count $v_n$ per hidden node and sample; reset both at the beginning of every forward pass. Each directed edge stores a scalar weight and a nonnegative integer delay. (2) Pseudocode: `queue = [(0, source_i, x_i)]`; `a[:] = 0; v[:] = 0; z[:] = 0`; while queue and events < event_budget: pop the smallest `(time,n,s)`; if `v[n] == Vmax`, continue; `a[n] += w_in[n]*s`; `y = tanh(a[n]+b[n])`; `v[n] += 1`; for each edge `(n,m,w,d)`, push `(time+d,m,w*y)`; if `m` is an output, add `w*y` to `z[m]`. Apply the downstream projection or softmax to `z`. During training, retain the event order and differentiate through accumulator additions and tanh; use a straight-through estimator or periodic evolutionary mutation for topology and integer delays. (3) Compute directly from the paper's mathematics the queue ordering, shared state updates, delay propagation, and visit cap. Estimate average events per sample, queue depth, node reuse, and active edge count empirically. Begin with an acyclic graph for stable backpropagation, then allow cycles with $V_{\max}=2$ or $3$. (4) First experiment: replace the feed-forward block in a small MNIST or CIFAR-10 MLP with 64 source nodes, 128 hidden nodes, 64 outputs, and 5% edge density. Compare against a parameter-matched dense MLP and a sparse graph with no node sharing. Measure accuracy, wall-clock inference time, processed events, peak activation memory, and loss descent at equal parameter count. A successful result is at least 30% lower active multiply-adds or activation memory with no more than a 1 percentage-point accuracy loss; improved accuracy over the no-sharing ablation would specifically validate interference-based computation.

## Verification

- Status: mech_ok_no_baseline
- Mechanism evidence: yes
- Mechanism confirmed: yes
- Practical verdict: harms
- Verdict: Built a faithful priority-queue event graph with shared accumulators, tanh responses, delayed propagation, and visit caps. All three mechanism predictions matched exactly: accumulation slope 1.0, the 0.9 saturation crossing at k=8, and accepted visits equal min(k,Vmax). In the small digits probe, sharing did not improve accuracy: it fell from 67.8% to 58.2% and runtime increased from 2.24 s to 2.77 s, so the mechanism is real but this configuration is not a practical win.

### Mechanism check

- Verdict: Built a faithful priority-queue event graph with shared accumulators, tanh responses, delayed propagation, and visit caps. All three mechanism predictions matched exactly: accumulation slope 1.0, the 0.9 saturation crossing at k=8, and accepted visits equal min(k,Vmax). In the small digits probe, sharing did not improve accuracy: it fell from 67.8% to 58.2% and runtime increased from 2.24 s to 2.77 s, so the mechanism is real but this configuration is not a practical win.
- Confidence: 8/10
- Limitations: Only a tiny random-feature digits experiment was tested, not end-to-end gradient training or learned topology and delays. Event count was not reduced because both graph variants processed the same number of source and output events; GPU, larger models, cycles, and memory/FLOP benchmarks were not tested.

### Practical benchmark

- Paired seeds: 8
- Baseline mean: 0
- Idea mean: 0
- p-value: 0.0081
- Paired wins: 0/8
- Benchmark verdict: idea worse (significant)

## Artifacts

- [bench_report.json](https://synthcore.org/code/402/bench_report.json)
- [event_graph_experiment.py](https://synthcore.org/code/402/event_graph_experiment.py)
- [report.md](https://synthcore.org/code/402/report.md)
- [report_bench_2026-08-31T112020.md](https://synthcore.org/code/402/report_bench_2026-08-31T112020.md)
- [results.json](https://synthcore.org/code/402/results.json)
- [stage2_event_graph.py](https://synthcore.org/code/402/stage2_event_graph.py)
- [Download all files as ZIP](https://synthcore.org/download/402)

## Disclaimer

AI-generated research hypothesis, automatically tested. Not peer-reviewed.