△ Mechanism confirmed, baseline not beaten 2026

Event-driven shared-neuron graph

Implementation & benchmark of arXiv:2607.15217 — NeuronSoup: Evolving Asynchronous, Shared-Neuron Temporal Graphs without Backpropagation

Usefulness7/10

Difficulty6/10

Novelty8/10

Architecture Memory Scalability Accuracy Mlp Rnn Inference speedup Training dynamics Dynamical systems Graph theory Computation

Source paper: NeuronSoup: Evolving Asynchronous, Shared-Neuron Temporal Graphs without Backpropagation arXiv:2607.15217 ⓘ · analyzed Aug 30, 2026

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

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.

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)$$

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.

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

Mechanism confirmed, baseline not beaten

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Confirmed ✓

Stage 2 · Practical benchmark result: Significantly worse ✗

Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works

Stage 1 — Mechanism check agent confidence 8/10

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.

Agent confidence: 8/10

Baseline: No-sharing graph: accuracy 0.6778, runtime 2.24 s, mean events/sample 192
Idea: Shared-neuron graph: accuracy 0.5822, runtime 2.77 s, mean events/sample 192
Mechanism checks: 3/3 exact predictions: accumulation slope 1.0 vs 1.0 predicted; saturation crossing 8 vs 8 predicted; visit-cap counts exact

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.

How to run: python3 event_graph_experiment.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.15217) Sep 2, 2026

Significantly WORSE than the tuned baseline (+140.8%, p=0.0081, wins 0 / 8 paired seeds).

Benchmark: Sequence modeling
Model: transformer_tiny
Paired seeds: 8
Baseline mean: 0.4544
Idea mean: 1.0941
Effect (Δ): 0.6397 (+140.8%; negative = idea better)
Wins: 0 / 8 paired seeds
p-value: 0.0081 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±12.5%
Mechanism: Confirmed ✓
Practical effect: Hurts
Baseline tuning: swept over 3 configs

Limitations:

Only the structurally matched sequence track was tested; no vision, tabular, or dynamics tracks were run. The graph used a fixed dense routing pattern and fixed delay rather than learned topology, sparse kernels, cycles, or an optimized event queue. The benchmark used 400 training and 200 test samples and 12 epochs rather than the track README defaults, to fit the stage budget. No wall-clock or activation-memory advantage was established; the implementation is a dense differentiable emulation of events.

How to run: python3 stage2_event_graph.py

Verdict computed by deterministic test code from paired-seed statistics — not by the language model.

Stage 2 — Benchmark Aug 31, 2026 latest Failed ✗

Agent confidence: 10/10

Implemented a differentiable delayed event-driven graph with shared accumulators and trained it end-to-end on the structurally matched multi-token sequence forecast track. The mechanism signature was confirmed quantitatively: 32 observed shared-node visits per sample versus 32 predicted. However, the idea had substantially worse test MSE than the swept transformer baseline (1.0941 vs 0.4544; paired delta +0.6397; permutation p=0.0081), so it is not a benchmark win.

Baseline: sequence / transformer_tiny; swept lr={0.001,0.003,0.01}; best lr=0.001; full 8-seed mean test MSE=0.454399, std=0.040811; per-seed=[0.427856,0.395630,0.462489,0.494523,0.440140,0.474409,0.526621,0.413526]
Idea: event-driven shared-neuron graph; swept the identical lr grid; best lr=0.001; full 8-seed mean test MSE=1.094060, std=0.084454; per-seed=[1.086983,0.921397,1.216696,1.144034,1.078718,1.046002,1.177429,1.081220]
Mechanism signature: trained-model measurement: mean_events_per_sample=1536, mean_shared_node_visits=32, predicted_shared_visits=32, observed_to_predicted_ratio=1.0, confirmed=true
Paired comparison: delta_mean=+0.639661 (idea-baseline, lower is better), idea_wins=0/8, permutation_p_value=0.0081, verdict=idea worse (significant)

Benchmark result