Compiling a Vector Programming Language to the Drosophila Hemibrain Connectome

Emma Leonhart

Abstract

We compile programs written in Sutra, a vector programming language, to execute on a spiking neural network model of the Drosophila melanogaster mushroom body, wired with real synaptic connectivity from the Janelia hemibrain v1.2.1 connectome (Scheffer et al. 2020). We report what compiles and runs on the connectome honestly, and what does not. Conditional branching compiles to fuzzy weighted superposition over KC-space prototype similarity. On the hemibrain MB (140 PN → 1,882 KC, n=35 seeds) the four-way conditional program achieves 560/560 correct decisions (σ=0, 16 scenarios × 35 runs). The same algorithm ported to the real 138,639-neuron Shiu whole-brain LIF (FlyWire v783 W, substrate-native bundle as weighted-drive superposition, spike-count readout) achieves 155/160 (96.9%) at n=10 seeds with no parameter tuning — the first Sutra control-flow operation measured on the full real connectome. Addressable memory via VSA bind/unbind + snap cleanup runs on the substrate as sign-flip binding and codebook snap in KC space. Bundle (a+b) runs on a spiking circuit and additionally validates on real FlyWire v783 wiring: the real 685-ALPN → 517-LHLN convergent projection reproduces W·(a+b) at cos=0.94 with no weight tuning. Snap runs on the real 138,639-neuron Shiu LIF whole-brain model (15M synapses from FlyWire v783 W) at 15/16 correct on random 50-neuron input patterns. Iteration (eigenrotation) does not run on the substrate at this protocol. The rotation operator we previously reported was the polar-decomposition nearest-orthogonal matrix Q to a 140-D subset of real W, with ‖W − Q‖_F / ‖W‖_F = 0.983 — a mathematical approximation of a subset of the connectome, not the connectome itself. We tested whether the real EPG ring attractor in FlyWire v783 + the Shiu LIF parameters carries ring dynamics under direct drive: 47/47 single-EPG drives at 200 Hz/100 ms produced zero recurrent EPG spikes, and a 5× drive / 5× window escalation (500 Hz, 500 ms) crossed only a noise-floor threshold (mean 0.4 recurrent spikes/drive). The EPG-only slice of real W does not implement the ring dynamics that Sutra's loop (condition) requires; the biological ring attractor lives in the wider Δ7+PEN+EPG+R subnetwork, whose recruitment for Sutra iteration is open research-scope work. We therefore retract the eigenrotation-on-connectome claim and narrow the paper to the operations that demonstrably execute on real W: bundle, bind, snap, and conditional branching via their weighted superposition. Scaling to the full FlyWire substrate is demonstrated for snap and bundle; scaling iteration to the broader CX ring attractor is future work. To our knowledge this is the first honest accounting of which VSA operations a real connectome-derived circuit does and does not implement at a given protocol.

The Substrate

The execution substrate is the right mushroom body of an adult Drosophila melanogaster, as reconstructed in the Janelia hemibrain v1.2.1 connectome. The circuit consists of:

The PN→KC connectivity is loaded directly from the connectome — it is the actual synaptic wiring of a real fly, not a random approximation. The APL neuron provides dynamical feedback inhibition following the biology described in Papadopoulou et al. 2011 and Lin et al. 2014. The readout layer uses a learned linear map from KC firing patterns to output vectors, fitted via ridge regression — the same shape of computation a real MBON performs via dopamine-gated plasticity. The circuit is simulated in Brian2 using leaky integrate-and-fire neurons.

The mushroom body is a natural substrate for vector symbolic architecture (VSA) because its core operation — sparse random projection from 140 PNs to 1,882 KCs — is structurally identical to VSA encoding. The dimensionality expansion from 140 to 1,882 provides the capacity for clean pattern discrimination that VSA requires.

What runs where. Sutra has two kinds of things in a program: scaffolding (scalars, tuples, bounded iteration counters) and vector operations (bundle, bind, similarity, projection, snap, rotation). Every vector operation is required to run on the substrate at runtime by the Substrate Rule (planning/sutra-spec/02-operations.md). In this paper: bundle(a, b) = a + b runs on the hemibrain LIF model as synaptic EPSP summation (cos=0.96 at dim=32 on synthetic weights) and on the Shiu whole-brain LIF with real FlyWire v783 W as native convergent drive (cos=0.97 on AB vs A+B; §Result 2). bind(a, role) = a * sign(role) runs on the hemibrain LIF through role-signed synapses with a shared bias rail (cos=0.94, sign-match=0.94 at dim=32). snap(q) runs as PN→KC projection with APL-enforced sparsity + cosine argmax over a compiled codebook on the hemibrain substrate; on real W (Shiu model) it retrieves 15/16 at n=16 codebook entries. Conditional branching is realized as fuzzy weighted superposition over these primitives (§Result 1, 560/560). Rotation is the operation where we cannot yet close the substrate-rule gap on real W: §Result 3 reports the negative test on the EPG-only slice, and we retract prior polar-decomposition-based numbers rather than paper over them.

Result 1: Conditional Branching

The compiler translates Sutra conditional programs into sequences of VSA operations that execute on the spiking substrate. The reference program (fly-brain/fuzzy_conditional.py, spec-aligned per planning/sutra-spec/03-control-flow.md) encodes four distinct decision-making programs using bind, bundle, snap, and similarity, each mapping two binary inputs (odor presence × hunger state) to one of four behavioral outputs (approach, ignore, search, idle).

How branching is compiled. Per the Sutra control-flow specification, a fuzzy conditional is realized as weighted superposition rather than a discrete if: result = Σ w_i · branch_i, where w_i are the clipped cosine scores of the snapped query against the four pre-compiled joint prototypes (smell × hunger → PH, PF, AH, AF). All four branches execute simultaneously on the substrate; the prototype-matching circuit determines the weights; the argmax against a behavior codebook defuzzifies. The four programs share the same prototype table and the same decision pipeline — they differ only in the prototype-to-behavior map (a compile-time table). There is no host-side if, no sign-flip on the query, and no program-dependent surgery of the input; the branch chosen on any given trial is a consequence of the circuit's KC-space similarity scores, not of a Python conditional.

Result (hemibrain MB, 140 PN → 1,882 KC): across thirty-five independent hemibrain simulations (different Brian2 seeds, independent Poisson spike trains, seeds 1000–1034), the four-way conditional program produced 560/560 correct decisions (16 scenarios × 35 runs), standard deviation zero, with all four program permutations distinct on every run (per-program accuracy 100% for A, B, C, and D on all 35 seeds). For reproducibility: python fly-brain/scale_eval_conditional.py --n-runs 35 (harness parameters: hemibrain v1.2.1, 140 PN → 1,882 KC, fixed-frame PN→KC seed, 300 ms simulation per snap, Brian2 2.10.1 LIF). Full log and analysis: planning/findings/2026-04-13-fuzzy-conditional-n35.md.

Result (Shiu whole-brain, 138,639 neurons, real FlyWire v783 W): The same fuzzy-weighted-superposition algorithm runs on the Shiu et al. 2024 whole-brain LIF with real FlyWire v783 W as the sparse connectivity matrix — 40-neuron random input populations per prototype, substrate-native bundle/snap/cosine, weighted-superposition realized as simultaneous driving of all four behavior populations at rates w_i · 200 Hz. At n=10 seeds: 155/160 correct (96.9%), per-run mean accuracy 0.969, std 0.075 (8 of 10 runs perfect 16/16; two runs at 15/16 and 12/16). Per-program accuracy: A 39/40, B 39/40, C 38/40, D 39/40. This is the same control-flow operation, executed on the full real connectome substrate rather than the hemibrain MB. The ~3% residual is weighted-drive collisions on particular random seed choices; no parameter tuning was done and no MB-equivalent decorrelation circuit is present on the raw spike-count readout. Reproducibility: python fly-brain/shiu_conditional.py --n-runs 10 against the Shiu PyTorch model (C:/Users/Immanuelle/shiu-fly-brain, CUDA, ~5 minutes on RTX 4070 Laptop). Full analysis: planning/findings/2026-04-13-shiu-conditional-branching.md.

The binding operation computes a * sign(b) in the PN input space — an input transformation analogous to antennal lobe lateral processing (Wilson 2013). The PN→KC synaptic weights remain fixed throughout; no synapse modification occurs during computation.

Result 2: Bundle and Snap on Real W

Bundle and snap are the two Sutra vector operations we have confirmed execute on real FlyWire v783 wiring, using the Shiu et al. 2024 whole-brain LIF model (138,639 neurons, 15,091,983 synapses, 91% prediction accuracy vs. ground-truth activity). All results below are substrate runs: PyTorch CUDA simulation of the Shiu LIF dynamics with real W as the sparse connectivity matrix, Poisson drive, spike counts decoded at the end of the window.

Bundle on real FlyWire W. Drive two disjoint 50-neuron populations A and B at 200 Hz for 100 ms; record per-neuron spike counts. The bundle response AB = drive(A ∪ B) reproduces the linear sum A + B at cos(AB, A+B) = 0.9718, with cos(AB, A) = 0.668 and cos(AB, B) = 0.707 — the textbook √2/2 projection signature of a linear bundle (fly-brain/shiu_bundle_test.py, planning/findings/2026-04-13-shiu-bundle-linear.md). The real 138,639-neuron W sums two inputs at its stability ceiling, with no weight tuning.

Snap on real FlyWire W. Compile a 16-entry codebook by driving 16 disjoint random 50-neuron patterns (seeds 2000–2015), then query with fresh Poisson seeds (5000–5015). Argmax cosine over the 138,639-D spike-count vector against the codebook returns the correct class on 15 of 16 queries; the single miss (class 4 → 11) is a random-overlap collision with gap 0.0354, not a dynamical failure. Correct-class margins are bimodal and well-separated from off-class scores (fly-brain/shiu_snap_test.py, planning/findings/2026-04-13-shiu-snap-15-of-16.md).

Stability and distinctness. The substrate is stable (cos between two Poisson replays of the same drive = 0.96) and discriminative (cos between disjoint drives = 0.00) — the precondition for snap to work at all (fly-brain/shiu_substrate_probe.py, planning/findings/2026-04-13-shiu-substrate-probe.md).

Reproducibility: python fly-brain/shiu_bundle_test.py and python fly-brain/shiu_snap_test.py against the Shiu LIF model (C:/Users/Immanuelle/shiu-fly-brain, PyTorch CUDA, ~60 s per experiment on RTX 4070 Laptop).

Result 3: Iteration Does Not Engage the EPG Ring on Real W — Negative Result

Sutra's loop (condition) specifies eigenrotation on the substrate: state ← R · state on neurons, with termination by KC-space prototype match (planning/sutra-spec/03-control-flow.md). In prior drafts we reported iteration via a polar-decomposition nearest-orthogonal matrix Q derived from a 140-D subset of real W. That Q is a mathematical approximation — ‖W − Q‖_F / ‖W‖_F = 0.983, so 98% of the Frobenius content of the real subset is discarded to achieve orthogonality. It is not the connectome's own dynamics.

We tested whether the EPG ring attractor in FlyWire v783 carries ring dynamics on the Shiu LIF substrate directly, without polar-decomposition surgery. The 47 EPG neurons were identified by FlyWire primary_type == "EPG" and mapped to Shiu tensor indices. Two protocols:

• Baseline protocol. Drive each of the 47 EPGs in isolation at 200 Hz for 100 ms; record 47-D EPG-only spike-count response. 47/47 drives produced zero recurrent EPG spikes — only the directly-driven neuron fired (8–13 spikes), every other EPG was silent (fly-brain/shiu_cx_bump_position.py, planning/findings/2026-04-13-shiu-cx-no-recurrence.md).
• Strong-drive protocol. Single-EPG at 500 Hz for 500 ms (5× rate, 5× window; 10 samples) and 5-adjacent-EPG clusters at 500 Hz for 500 ms (5 samples). Variant A produced a mean of 0.4 recurrent spikes across 10 drives (7/10 drives zero, max 2). Variant B produced non-trivial recurrence on only 1 of 5 clusters (15 spikes across 2 EPGs); the other 4 clusters produced ≤1 total recurrent spike (fly-brain/shiu_cx_strong_drive.py, planning/findings/2026-04-13-shiu-cx-strong-drive-marginal.md).

Direct EPG-to-EPG synapses are sparse in FlyWire v783; the biological ring-attractor dynamics live in the Δ7 + PEN + EPG + R subnetwork (Kim 2017, Turner-Evans 2020, Kakaria & de Bivort 2017), where Δ7 long-range inhibition and PEN-mediated heading velocity drive the ring. The EPG-only slice does not implement those dynamics on its own. The polar-decomposition Q we previously reported was therefore orthogonalizing a slice of real W that does not rotate as a ring on the real substrate — the operator was mathematically valid but biologically a different object.

We retract the prior eigenrotation-on-connectome claim. Implementing loop (condition) on the broader Δ7+PEN+EPG+R subnetwork is a research-scope program (stimulate EPGs via PEN inputs, let Δ7 inhibition shape the dynamics, read bump position over time) that we are actively pursuing but do not report as a current result.

Isolated small loops are not graph-present in real W. A strongly-connected-component analysis of the 138,639² signed W (fly-brain/shiu_scc_search.py) finds 2,624 SCCs — one giant component of 135,403 neurons containing the CX, MB, AL, and inter-region recurrence, and only 5 SCCs in the 10–500 size range that might serve as isolated loop substrates. All 5 small SCCs are R1-6 photoreceptor modules in the optic lobe, with no EPG / Δ7 / PEN / ER membership. The CX ring-attractor components are all inside the giant SCC, which means their closed-loop dynamics compete at run-time with feedback from the whole rest of the connectome — a structural explanation of why direct EPG drive did not sustain a bump. Isolable loops for Sutra loop (condition) must therefore be identified within the giant SCC by dynamics-aware metrics (community detection, effective time-constant separation), not by graph SCC alone. Full analysis: planning/findings/2026-04-13-shiu-scc-search.md.

What Runs Where

The four operations tested in this paper execute as follows:

1. Conditional branching — on the substrate. snap(bind(smell, hunger)) → cosine similarity against the four joint-input prototypes, in KC space on the hemibrain MB and in 138,639-D spike-count space on the Shiu whole-brain LIF. The host-side argmax over four scalar scores is a readout, not branching.
2. Bundle — on the substrate on real FlyWire W. Native convergent drive reproduces A + B at cos = 0.97 on the Shiu model (§Result 2). No host arithmetic.
3. Snap — on the substrate on real FlyWire W. 15/16 correct retrievals on a 16-entry random codebook against the 138,639-D spike-count vector (§Result 2).
4. Iteration (eigenrotation) — not a current on-connectome result. See §Result 3 for the negative test and the retraction of prior polar-decomposition numbers.

Scaffolding around these operations (scalars, tuples, the argmax readout, the four-program prototype-to-behavior table) runs on the host. Every vector operation in the runtime path either executes on the substrate or is marked as not yet substrate-realized.

In-Repo Specification and Compiler

To address concerns about external documentation and reproducibility, the Sutra language surface, operation model, control-flow semantics, and VSA math axioms are fully specified in the project repository under planning/sutra-spec/. The load-bearing files are 02-operations.md (the scaffolding-vs-vector-operation model and the substrate rule referenced throughout this paper), 03-control-flow.md (the loop (N) / loop (condition) semantics including eigenrotation, and the fuzzy-weighted-superposition conditional form used in §Result 1), 04-defuzzification.md (the is_true recursive-threshold control), 11-vsa-math.md (the eight VSA axioms and the vector-space structure they define), and 19-substrate-candidates.md (the substrate-compatibility rules for each operation). The compiler is at sdk/sutra-compiler/; the .su programs cited here compile through that pipeline into Python that calls the fly-brain/vsa_operations.py runtime. Everything named in this paper is therefore inspectable, runnable, and separate from the paper text — it is a specified language with an implementation, not a label attached to an ad-hoc script.

Methods

Encoding. Hypervectors are encoded as PN input currents via centered rate coding: zero components map to a baseline current (1.2), positive components to above-baseline (more spikes), negative components to below-baseline (fewer spikes).

Decoding. A learned linear readout W maps KC firing rates to output vectors. W is fitted once via ridge regression on ~80 (hypervector, KC firing pattern) pairs collected by running random inputs through the circuit — a program-independent calibration step, not a task-specific classifier. The same W is reused across all four conditional programs and all loop tests without refitting. This is the same computation shape a real MBON acquires via associative learning: a linear map from KC population activity to readout, learned from experience without access to the connectivity matrix.

Binding and bundling. Both are Brian2 spiking circuits (fly-brain/neural_vsa.py) and both additionally run as native dynamics on the Shiu LIF whole-brain model with real FlyWire v783 W. bundle(a, b) = a + b uses two Poisson input populations at rates f(a_i) and f(b_i) projecting onto a leaky-integrator output population through unit excitatory synapses; on real W (§Result 2) it is the native substrate response to driving both populations simultaneously, with no auxiliary circuit. bind(a, role) = a * sign(role) uses a single Poisson input per dimension projecting onto an output neuron through a synapse whose sign is fixed by sign(role_i), with a shared bias rail so role-negative dimensions have headroom for inhibition. In each case the operand vectors are consumed by synaptic integration; no host-side elementwise product, sum, or matmul is computed.

Conditional branching (fuzzy weighted superposition). The four-way conditional compiles to a prototype table compiled via snap() on the MB circuit, a fuzzy-weight computation in KC space, and a linear blend of behavior vectors indexed by the program's prototype-to-behavior map. Query construction is q = bind(smell_vec, hunger_vec); brain_query = snap(q); weights w_i = relu(cos(brain_query, prototype_i)) normalized to sum to one; result = Σ w_i · behavior_vec[program_map[prototype_i]]; winner is argmax_j cos(result, behavior_vec_j). Program identity enters only at the prototype-to-behavior table; the substrate-side pipeline is program-independent. See fly-brain/fuzzy_conditional.py and fly-brain/scale_eval_conditional.py.

Sparsity. A single graded APL neuron integrates KC activity and feeds back continuous inhibitory current to all KCs, producing ~7.8% KC activation — within the 2–10% range observed in vivo (Lin et al. 2014). Sparsity emerges from the circuit dynamics, not from a hand-coded override.

Shiu substrate. §Result 2 and §Result 3 run on the Shiu et al. 2024 whole-brain LIF model (138,639 AlphaLIF neurons, 15,091,983 synapses, real FlyWire v783 W as the sparse connectivity matrix, calibrated parameters wScale=0.275, vThreshold=-45 mV per the Shiu release). Simulation is PyTorch CUDA on an RTX 4070 Laptop, Poisson drive in rates, spike counts accumulated over the simulation window. The 47 EPG neurons for §Result 3 are identified by matching FlyWire consolidated_cell_types.csv.gz (primary_type == "EPG") to Shiu tensor indices via 2025_Completeness_783.csv. No parameter tuning was done — all runs use Shiu's released calibrated values.

Reproducibility

§Result 1 runs on Windows 11 / Python 3.13 / Brian2 2.10.1 without GPU; the hemibrain connectivity matrix (0.1 MB) is committed to the repository and the 35-seed conditional harness runs in ~30 minutes on a single CPU core. §Result 2 and §Result 3 run the Shiu LIF model on PyTorch CUDA (RTX 4070 Laptop, 8 GB VRAM); each Shiu experiment is ~30–90 s wall clock.

The Sutra language surface, operation model, and compiler are specified in planning/sutra-spec/ (canonical files: 02-operations.md, 03-control-flow.md, 11-vsa-math.md) and implemented in sdk/sutra-compiler/; the .su programs cited here compile through that pipeline to the fly-brain runtime — it is not an ad-hoc DSL built for this paper.

Future Work

1. Iteration via the broader CX ring subnetwork. Driving EPGs through their biological inputs (PEN1/PEN2 heading velocity, ER sensory drive) on the full Shiu substrate, with Δ7-mediated long-range inhibition shaping the bump dynamics, is the biologically correct way to recruit the ring attractor and is the primary open problem for iteration on real W. The negative EPG-only result in §Result 3 is the evidence that the narrower polar-decomposition approach does not suffice.
2. Scale the snap codebook. Capacity scaling on the Shiu substrate — how many prototypes can be discriminated before random-overlap collisions dominate — is measurable with the existing harness and has not yet been swept.
3. Biological learning rule. Replacing ridge regression with dopamine-gated plasticity for the MBON readout in §Result 1.