✓✓ Beats tuned baseline 2026

PPMI-Gated BCM Sparse Graph Encoder

Implementation & benchmark of arXiv:2608.20408 — Columnar-Embedder: A Biologically Inspired Cortical Architecture for Binary Sparse Distributed Graph Representations

Usefulness7/10

Difficulty5/10

Novelty7/10

Architecture Memory Speedup Stability Graph nn Embedding Training Probability Statistics Dynamical systems

Source paper: Columnar-Embedder: A Biologically Inspired Cortical Architecture for Binary Sparse Distributed Graph Representations arXiv:2608.20408 ⓘ · analyzed Sep 1, 2026

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

Idea description

Replace a dense graph embedding table or end-to-end GNN encoder with a fixed-width binary SDR learned from streaming random-walk context pairs. Use PPMI to amplify informative node-context pairs and a local BCM update to learn detector columns, followed by k-winner-take-all binarization. The resulting sparse code can be used directly for node classification, link prediction, retrieval, or as input to a small downstream predictor.

Formulas

$$\operatorname{PPMI}(u,v)=\max\left\{0,\log\frac{p(u,v)}{p(u)p(v)}\right\},\qquad p(u,v)=\frac{C_{uv}}{N},\quad p(u)=\frac{C_{u\cdot}}{N},\quad p(v)=\frac{C_{\cdot v}}{N}.$$

$$y_j=\operatorname{ReLU}(w_j^\top x),\qquad \Delta w_j=\eta\,g(u,v)\,x\,y_j(y_j-\theta_j),\qquad g(u,v)=\frac{\operatorname{PPMI}(u,v)}{\max_{a,b}\operatorname{PPMI}(a,b)+\varepsilon}.$$

$$\theta_j\leftarrow(1-\alpha)\theta_j+\alpha y_j^2,\qquad z_j=\mathbf{1}\left[j\in\operatorname{TopK}(y,k)\right],\qquad \lVert z\rVert_0=k.$$

Mathematical statement

For a random-walk stream, let C_uv be the number of times node u occurs with context node v within a window, let C_u_dot be the row marginal, C_dot_v the column marginal, and N the total pair count. Define p(u,v)=C_uv/N, p(u)=C_u_dot/N, and p(v)=C_dot_v/N. The PPMI signal is PPMI(u,v)=max(0, log(p(u,v)/(p(u)p(v)))); zero-count pairs receive zero weight. For an input feature vector x in R^d, each output column j has weight w_j in R^d and response y_j=ReLU(w_j^T x). The local BCM rule is Delta w_j=eta g(u,v)x y_j(y_j-theta_j), with learning rate eta and normalized PPMI gate g. The sliding threshold theta_j is updated by theta_j=(1-alpha)theta_j+alpha y_j^2. The BCM term potentiates a column when y_j^2 exceeds its running threshold and depresses it otherwise. A binary SDR with m columns and exactly k active bits is formed by selecting the k largest responses.

Implementation notes

Integrate this as a graph-nn embedding layer, replacing node2vec's dense embedding table or preceding a lightweight classifier. First generate an online stream of random walks; for each walk, emit every center-context pair (u,v) within a window of radius r. Maintain a Count-Min Sketch or bounded hash table for C_uv and exact or hashed node marginals C_u_dot and C_dot_v. Use additive smoothing delta when computing probabilities, and periodically freeze or refresh the PPMI normalization maximum. Represent x as e_u+e_v followed by a fixed random projection into dimension d, or use concatenated hashed one-hot features. For each pair, compute the smoothed PPMI gate, responses y=ReLU(W^T x), and thresholds theta. Update each column with w_j += eta*g*x*y_j*(y_j-theta_j), then update theta_j with the exponential average of y_j squared. Normalize each weight column after a minibatch and clip its norm to prevent Hebbian divergence. At inference, compute responses for a node-context summary, retain the k largest columns, and store only their indices. For link prediction, test SDR Jaccard overlap, Hamming distance, and a small MLP on two SDRs. Start on Cora or PubMed, comparing a 256-bit SDR with 256-dimensional node2vec and GraphSAGE at matched downstream accuracy. Measure wall-clock training, peak memory, bytes per node, and accuracy after sequential graph updates. A useful success signal is accuracy within two percentage points while using at least four times less embedding storage and degrading less under edge corruption or distribution shift.

Verification

Beats tuned baseline

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Significant win ✓

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

How to read this: The implementation beat the baseline, but the claimed mechanism did not reproduce at benchmark scale. The gain may come from another effect; treat the cause as unresolved.

Stage 1 — Mechanism check agent confidence 9/10

Built a NumPy MVP of PPMI computation, normalized gating, local BCM updates, threshold tracking, and exact-k binary SDR inference in ppmi_bcm_experiment.py. The mechanism manifested: zero PPMI produced exactly zero updates across 8 inputs, update norm scaled linearly with gate from 0 to 1 at relative error below 5e-15, and the BCM threshold closed form matched the iterative update within 9e-16 while all potentiation/depression sign cases matched prediction. The downstream toy result was not a win: SDR accuracy was 0.625 versus 0.825 for the dense random baseline, although storage was 32x smaller (4 versus 128 bytes/node).

Agent confidence: 9/10

Baseline: Toy SBM dense 32-float random projection: accuracy=0.825, storage=128 bytes/node
Idea: PPMI-gated BCM 32-column, k=4 binary SDR: accuracy=0.625, storage=4 bytes/node; zero-gate maximum update norm=0, gate-scaling relative error <5e-15, threshold closed-form maximum error=8.9e-16

Limitations: Only a synthetic 80-node SBM and a dense random-projection baseline were tested; no Cora/PubMed, node2vec, GraphSAGE, link prediction, corruption robustness, streaming count-min sketch, GPU implementation, wall-clock scalability, or multi-seed statistical comparison was evaluated.

How to run: python3 ppmi_bcm_experiment.py

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

Beats the tuned baseline by 6.3% (p=0.0169, wins 7 / 8 paired seeds; metric: lower is better).

Benchmark: Cycle_topology_graph
Model: mlp_tiny
Paired seeds: 8
Baseline mean: 0.5087
Idea mean: 0.4769
Effect (Δ): -0.0319 (−6.3%; negative = idea better)
Wins: 7 / 8 paired seeds
p-value: 0.0169 (permutation test, 20 000 shuffles)
Smallest detectable effect: ±5.0%
Mechanism: Not confirmed ✗
Practical effect: Helps
Baseline tuning: swept over 0 configs

Limitations:

The benchmark used a small synthetic fixed-size topology classification track, not Cora/PubMed or a large streaming graph. Node2vec, GraphSAGE, link prediction, corruption robustness, large-scale memory, wall-clock scaling, and Count-Min Sketch streaming were not tested. The signature confirmed field is false because the observed pair gates were all approximately 1.

How to run: python3 ppmi_bcm_bench.py

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

Stage 2 — Benchmark Sep 1, 2026 latest Worked ✓

Agent confidence: 7/10

Implemented PPMI-gated BCM SDR preprocessing with the same mlp_tiny supervised architecture as baseline on the structurally matched cycle_topology_graph task. Across 8 paired seeds, idea error was 0.476875 versus baseline 0.508750, delta=-0.031875, permutation p=0.0169, so the harness criterion for a significant win was met. The mechanism signature was not confirmed because all observed gates were approximately 1, so this is task-level evidence rather than confirmation of PPMI suppression.

Baseline: cycle_topology_graph/mlp_tiny; best cfg lr=0.01, eta=0.002; mean test err=0.508750; std=0.020917
Idea: PPMI-Gated BCM SDR + mlp_tiny; best cfg lr=0.001, eta=0.002; mean test err=0.476875; std=0.019990; 7/8 paired wins; delta=-0.031875; p=0.0169

Benchmark result