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.

Language Primitives vs Substrate Boundedness

Two claims need to be cleanly separated, because conflating them is what drives most of the skepticism around connectionist "general-purpose computation" results.

Claim 1 (the language): Sutra provides the primitive set needed for general-purpose programming. Conditional branching on computed state, unbounded data-dependent iteration, and addressable read/write memory are the operations every general-purpose language needs; Sutra defines all three (see planning/sutra-spec/02-operations.md, 03-control-flow.md, 04-defuzzification.md) and a compiler (sdk/sutra-compiler/) emits real code for them. This claim is about the language, not the hardware — the same way C supports general-purpose computation irrespective of whether you run it on a 486 or an ARM Cortex-M0.

Claim 2 (the substrate): this specific 140-D fly mushroom body is a bounded finite-state machine. So is every physical computer ever built. The relevant question is whether the finite bound is load-bearing against the primitive set — and for the programs we compile here (4-way conditionals, small-integer loops, small key-value stores), it is not. Scaling to the full ~130k-neuron FlyWire circuit, chaining mushroom bodies, or deploying on a neuromorphic substrate with the same motifs is an engineering extension of the same primitive set, not a new mechanism.

The paper below is about Claim 1. We demonstrate that each of Sutra's three primitives compiles to operations executing on the real hemibrain connectome — not that an individual fly brain is itself a universal computer. That language-vs-substrate distinction is the same one anyone writing a compiler lives with every day.

The three primitives required:

1. Conditional branching — decisions gated on computed state. Demonstrated in §Result 1: four permutation programs, each realized on the substrate via fuzzy weighted superposition (result = Σ w_i · branch_i) per planning/sutra-spec/03-control-flow.md. The branch selection is made by KC-space similarity, not a host-side test. 80/80 across five independent hemibrain runs, σ=0.

2. Unbounded iteration — repeat computation an arbitrary number of times with data-dependent termination. Specified in planning/sutra-spec/03-control-flow.md as eigenrotation through vector space with KC-space prototype match termination. loop (N) with a literal N unrolls at compile time into a flat algebraic expression (no runtime iteration required) and compiles through the bundle/bind/snap primitives demonstrated above. loop (condition) with data-dependent termination requires eigenrotation on the substrate, and §Result 3 reports that the EPG ring attractor on real W does not engage under direct drive at the protocols we tested. We do not claim iteration as a working primitive on real W at this time; it compiles in the language and executes under the synthetic-Givens rotation baseline retained in the repo, but the on-connectome realization is open work.

3. Read/write addressable memory — store, retrieve, and address intermediate state. The codebook + bind/unbind gives us this. A hypervector record = bind(k₁, v₁) + bind(k₂, v₂) + ... + bind(k_n, v_n) superposes n key–value slots in a single D-dimensional vector. Reading slot i — "what is the value bound to key k_i?" — is unbind(record, k_i), which for sign-flip binding is self-inverse: sign(k_i) * record ≈ v_i + crosstalk_from_other_slots. The crosstalk is suppressed by snap to the nearest codebook entry, so the readout returns the clean stored v_i. Writing to slot i is record' = record + bind(k_i, v_i_new) - bind(k_i, v_i_old) — again all realized as vector operations on the substrate. This is addressable memory in the VSA sense (Plate 1995, Kanerva 2009), not a static lookup: any key can be used to index, keys and values are themselves vectors in the same space, and the memory is composable with other ops.

What is on the substrate, what is on the host. We separate these cleanly because the paper's value depends on it, and because past iterations of this work did hide host arithmetic behind architectural labels. We do not do that here.

1. Conditional branching — on the substrate. The four-way decision that routes (smell, hunger) to one of four behaviors is snap(bind(smell, hunger)) → Jaccard similarity against the four joint-input prototypes, entirely in KC space. The branch that "fires" is the prototype with the highest KC-pattern overlap. No host-side test selects the branch. What the host does after the circuit finishes is a four-way argmax over four scalar scores — a readout, not branching. Readout is trivially not on the substrate the same way reading a CPU register onto a monitor is trivially not on the CPU; every biological system has readout.

2. Bundle and snap — on the substrate on real FlyWire W. See §Result 2. Bundle reproduces W·(a+b) ≈ W·a + W·b on the real 138,639-neuron Shiu LIF model at cos=0.97; snap retrieves 15/16 on disjoint random codebook entries. Both operations run as the substrate's own dynamics — Poisson drive in, spike counts out — with no host-side arithmetic in the runtime path.

3. Rotation — not a current on-connectome result. See §Result 3. The EPG-only slice of real W does not carry ring dynamics at the protocols we tested, and the polar-decomposition Q we previously cited is a mathematical approximation of a subset of real W (98% of Frobenius content discarded), not the connectome's own operator. We retract the prior eigenrotation-on-connectome numbers and move iteration on real W to future work.

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.

Honest Limits of the Current Substrate

Iteration on real W is not demonstrated. §Result 3 reports the negative finding: 47/47 single-EPG drives at 200 Hz / 100 ms and an additional 5× strong-drive escalation produced essentially no recurrent EPG activity on the Shiu LIF model of real FlyWire v783. The polar-decomposition Q we previously reported for iteration is a mathematical approximation — the nearest orthogonal matrix to a 140-D subset of real W, with ‖W − Q‖_F / ‖W‖_F = 0.983. We retract the prior eigenrotation-on-connectome numbers; the full-sweep 30/30 and k-ceiling 14/30 tables from previous drafts were numpy-applied Q or a synthetic-Givens baseline, neither of which constitutes "rotation on the real connectome" in the sense our Substrate Rule (planning/sutra-spec/02-operations.md) requires.

Why the EPG-only slice does not rotate. Direct EPG-to-EPG synapses in FlyWire v783 are sparse; the biological ring-attractor dynamics live in the Δ7 + PEN + EPG + R subnetwork (Kim 2017, Turner-Evans 2020). Δ7 neurons provide long-range inhibition around the ring; PEN1/PEN2 convey heading velocity; ER/R-ring neurons feed sensory drive. The polar-decomposition operation extracts an orthogonal matrix from a slice of W that, in isolation under direct Poisson drive, does not implement those dynamics. This is a structural property of the EPG-only subgraph under the Shiu LIF parameters, not a protocol artifact we expect to tune away at this scope.

Bundle and snap on real W have calibrated limits. The bundle cos = 0.97 is at the substrate's stability ceiling (self-replay cos = 0.96); bundle fidelity cannot exceed the shot-noise floor of the Poisson drive without longer integration windows. Snap at 15/16 fails on a random-overlap collision (gap 0.0354) not on a dynamical pathology; larger codebooks will see the collision rate grow with the square of codebook size and the inverse square root of integration time — standard VSA capacity scaling, not a substrate defect (planning/findings/2026-04-13-shiu-snap-15-of-16.md).

Scope of "runs on the connectome." This is a computational model — the Shiu LIF with real FlyWire v783 W as the sparse connectivity matrix, 91% spike-prediction accuracy against ground-truth fly activity (Shiu et al. 2024). We do not claim execution on living tissue or a neuromorphic chip. Physical deployment is separate engineering work.

Narrowed scope relative to prior drafts. Previous versions of this paper reported rotation-based iteration results via two pipelines (spiking rotation + cosine, numpy rotation + MB-Jaccard) totaling 14/30 and 30/30 respectively. Those numbers are real for what they measure (a polar-decomposition Q executed either on Brian2 with a 140-PN / 1,882-KC mushroom body or on numpy with the MB as readout), but they do not constitute iteration on the real connectome in the sense §Result 3 now tests. We have removed the 14/30 and 30/30 loop tables from this draft; the underlying scripts and findings remain in the repository as the diagnostic trail that led to the present scope.

Other concrete limits. The conditional evaluation is scaled to 35 independent hemibrain seeds (560/560, σ=0). Bundle on real W is at n=1 probe × 2 seeds on the Shiu model; snap is at n=16 codebook entries × 1 query per entry. Larger trial counts on the Shiu substrate are straightforward — each experiment is ~60 s GPU wall-clock. A prior implementation of conditional branching used a sign-flip "NOT key" on the query as a proxy for semantic negation; this was a category error (a random ±1 pattern has no principled relationship to the other polarity of a feature axis) and is superseded by the spec-aligned fuzzy-weighted-superposition form reported in §Result 1. The failure record is retained on disk at fly-brain/permutation_conditional.py with a deprecation banner.

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. Implement loop (condition) by 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. This 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.
4. Physical deployment. Stimulating real neurons at prescribed sites rather than simulating them is out of scope for this paper.