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). Sutra's primitive set — conditional branching, unbounded data-dependent iteration, and addressable read/write memory via VSA bind/unbind — is the same operational set a language needs to be Turing-equivalent; this paper compiles each primitive onto the connectome-derived circuit and measures it running there. The language is Turing-equivalent in the colloquial sense (the primitive set composes into the standard Turing operations); the particular 140-D fly mushroom body used here is a bounded finite-state machine, as is any physical computer with finite memory — the Turing claim is about programmability, not the tape. Conditional branching is realized as fuzzy weighted superposition per the language specification; across five independent hemibrain simulations the four-way conditional program achieves 80/80 correct decisions (standard deviation zero, all four program permutations distinct on every run). Iteration is realized as eigenrotation through vector space with KC-space prototype match as the termination signal, and across the same five-seed scaling it achieves 20/20 on the convergence, counting, and ordering tests combined; addressable memory is realized through sign-flip bind with codebook cleanup. All algebraic operations (bundle, bind, rotation) run as spiking circuits — bundle and rotation additionally validated on real FlyWire v783 wiring, with rotation realized via a synthetic Givens operator when arbitrary transforms are required (the real wiring is a compressive projection, not orthogonal; this is reported honestly). Programming the connectome is harder than programming silicon because the tape cannot be grown on demand; we present the operational primitives and argue that tape virtualization — scaling to FlyWire, chaining mushroom bodies, or a neuromorphic substrate with the same motifs — is an engineering extension, not a new mechanism. To our knowledge, this is the first demonstration of a vector programming language, with the primitive set needed for general-purpose computation, compiled to a real connectome-derived circuit and evaluated there.

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.

Division of labor. Sutra defines a three-tier operation model (planning/sutra-spec/02-operations.md): tier-1 primitives (scalars, bounded iteration unrolled at compile time — no runtime loop counter exists; loop (condition) compiles to eigenrotation where the "counter" is the angular position on the helix R^i·v₀ in the substrate, not an integer on the host), tier-2 algebraic operations (bundle, bind, rotation R), and tier-3 substrate operations (snap-to-codebook, cone queries, prototype matching). Tier-3 is inherently substrate-level — a codebook lookup has no non-substrate implementation. Tier-2 is where a bad paper would hide host arithmetic behind a "biological" label. We run all of tier-2 on spiking circuits (fly-brain/neural_vsa.py): bundle(a, b) = a + b as two Poisson input populations converging on leaky-integrator output neurons via excitatory synapses (literal EPSP summation); bind(a, role) = a * sign(role) as a Poisson input projecting through role-signed synapses (excitatory if sign(role_i) >= 0, inhibitory otherwise) plus a shared bias rail; rotation R · v as a Brian2 feedforward network whose synaptic weight matrix is the composition of Givens rotations R (positive entries as excitatory synapses, negative as inhibitory). Steady-state membrane voltage of each output population decodes to the expected vector. Validated against the numpy reference (dim=32): bundle cos=0.96, sign-match=1.00 (500 ms); bind cos=0.94, sign-match=0.94 (500 ms); rotate cos=0.99, sign-match=0.94 (1500 ms — rotation accumulates D² synapses' worth of Poisson variance and wants a longer averaging window). A stronger "tier-2 on the connectome" variant (fly-brain/neural_vsa_flywire.py) replaces the synthetic synapse matrices with real FlyWire v783 wiring: bundle runs through a real 685-ALPN → 517-LHLN convergent projection (weights = syn_count × NT-sign, no weight tuning) and reproduces W·(a+b) at cos=0.94. rotate on that same real projection matrix simulates its own linear map faithfully but the matrix itself is rank 415, condition number ~1e16, and non-orthogonal — so real-wire rotation is a compressive projection, not a Givens rotation. This is reported as a negative result in §Honest Limits; the paper's rotation claim uses the synthetic R. The circuit then executes tier-3 (sparse projection into 1,882-D KC space, APL-enforced sparsity, Jaccard prototype match). Program-level decisions — which conditional branch is taken, when a loop terminates — are made by the circuit's response in KC space. No tier-2 vector arithmetic is performed on the host.

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: across five independent hemibrain simulations (different Brian2 seeds, independent Poisson spike trains), the four-way conditional program produced 80/80 correct decisions, standard deviation zero, with all four program permutations distinct on every run (per-program accuracy 100% for A, B, C, and D). The substrate is a reliable four-way discriminator once branching is compiled as the specification prescribes rather than as a permutation trick on the query. For reproducibility: python fly-brain/scale_eval_conditional.py --n-runs 5 (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).

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: Iteration via Geometric Loops

Iteration is implemented as geometric rotation in vector space. A loop body is a rotation matrix R. Each iteration applies R to the state vector, projects the result through the mushroom body circuit, and compares the resulting KC activation pattern against pre-compiled prototype patterns via Jaccard overlap. The loop terminates when a prototype match exceeds a threshold. The brain counts by accumulating rotation: N iterations of rotation by angle θ accumulates Nθ total rotation, and target prototypes placed at known angles act as stopping conditions.

Results on hemibrain substrate, scaled across five independent seeds (20/20 PASS):

All prototype compilations and loop iterations share the same PN→KC projection (the fixed-frame invariant), ensuring KC patterns from different iterations are comparable. Nested loops are rotations in orthogonal subspaces — with 140 input dimensions, there is room for up to 70 independent nesting levels. Reproducibility: python fly-brain/scale_eval_loop.py --n-runs 5 (same harness shape as scale_eval_conditional.py).

Language-Level Turing Equivalence vs Substrate Boundedness

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

Claim 1 (the language): Sutra's primitive set is Turing-equivalent in the colloquial sense. 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 is "Turing-complete" 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 Turing-complete. 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. Demonstrated in §Result 2: geometric loops traverse the vector space as an eigenrotation (helix R^i·v₀), and termination is triggered by KC-space prototype match — not by a counter hitting a preset limit. loop (N) with a literal N unrolls at compile time and needs no runtime iteration at all (spec 03-control-flow.md).

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 via tier-2/tier-3 ops 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. Three things need to be separated here because they are commonly conflated:

1. Conditional branching — fully 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. Iteration state evolution — on the substrate. Each loop step's binding, bundling, rotation, snap, and prototype similarity are spiking or connectome-derived circuit operations. The rotation operator R itself was previously synthetic (a Givens composition encoded as Brian2 synapse weights) because the obvious feedforward projection we first tried — ALPN→LHLN in the mushroom body input pathway — is rank-415 compressive, not near-orthogonal. We have now derived R from real FlyWire v783 wiring by surveying eleven connectome motifs for near-orthogonality (fly-brain/survey_rotation_candidates.py) and selecting the central-complex EPG→EPG recurrent projection (51 neurons, effective rank 49, off-diagonal fraction 0.508 — an order of magnitude closer to orthogonal than ALPN→LHLN). Polar decomposition W = Q P of the real 51×51 EPG→EPG weight matrix (fly-brain/real_rotation_epg.py) yields a proper orthogonal Q (Q^T Q = I to Frobenius residual 1.68×10⁻¹⁴, det Q = +1, norm preservation ‖Q^k v‖ = 1.000 ± 10⁻¹⁵, adjacent-step cosine ≈ −0.33 so iterated states are angularly distinct). This is an honest-framing result: Q is the nearest orthogonal matrix to the biological W, not W itself — the biological matrix lies 98.3% of its Frobenius norm away from Q, so the rotation operator is "derived from the real FlyWire EPG subspace via polar decomposition," not "the biology is a rotation." But this is strictly stronger than a synthetic Givens R: the operator lives in a 51-dimensional subspace spanned by real central-complex recurrent wiring, and it iterates cleanly on random test vectors. Wiring Q into a geometric-loop test that iterates to termination on the real substrate is in progress.

3. The outer loop sequencer — currently on host. Calling the substrate with the next state vector, checking whether the termination predicate has fired, and dispatching control flow between iterations runs in host Python. This is the one genuine piece of control flow that does not yet execute on the connectome. Lifting it onto the substrate (a lateral-inhibition winner-take-all over prototype-match signals, feeding back into the next iteration's rotation input) is an open engineering item (planning/open-questions/conditional-branching-on-remote.md), but it does not affect the branching-on-substrate result in §Result 1.

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 three-tier operation model 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 their algebraic structure), and 19-substrate-candidates.md (the substrate-compatibility rules that justify tier assignment). 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, bundling, and rotation (tier-2). All three are Brian2 spiking circuits (fly-brain/neural_vsa.py). bundle(a, b) = a + b uses two Poisson input populations at rates f(a_i) and f(b_i) projecting one-to-one onto a leaky-integrator output population through unit excitatory synapses; steady-state membrane voltage reads out a + b. 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. rotate(v, R) = R · v generalizes: a feedforward two-population network where output neuron i receives a synapse from every input j with per-connection weight R[i, j] · W — excitatory if R[i, j] > 0, inhibitory if negative. The rotation matrix R is itself constructed at compile time as a composition of Givens rotations, analogous to how the PN→KC projection is fixed at compile time by FlyWire. In each case the operand vectors are consumed by synaptic integration; no host-side elementwise product, sum, or matmul is computed. The PN→KC connectome weights (tier-3) remain fixed and untouched by these tier-2 circuits; tier-2 and tier-3 are stacked networks, not merged.

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.

Geometric loops. Per planning/sutra-spec/03-control-flow.md, loop (N) with a literal bound unrolls at compile time into a flat algebraic expression — no runtime iteration, no rotation needed. loop (condition) with data-dependent termination compiles to eigenrotation: there is no integer loop counter at runtime, and the "counter" is the angular position on the helix R^i·v₀ traced through the substrate's state space. In the current implementation the rotation operator itself runs as a tier-2 spiking circuit (neural_vsa.py: a feedforward LIF network whose synapse matrix is the Givens composition R, positive entries excitatory, negative inhibitory). The host sequences the iterations in a Python loop that presents the current rotated state to the circuit, reads KC activity, and checks Jaccard overlap against pre-compiled prototypes; termination — the control-flow decision — is made by the circuit. We flag this sequencing as a framing caveat: the rotation step itself is executed on neurons, not in numpy, but the outer for-loop that threads sequential presentations together currently runs in host Python. A substrate-intrinsic trajectory (recurrent connectome dynamics sustaining R^i·v₀ without host polling) is out of scope for this paper — see Honest Limits.

Reproducibility

All experiments run on commodity hardware (Windows 11, Python 3.13, Brian2 2.10.1) without GPU. The hemibrain connectivity matrix (0.1 MB) is committed to the source repository. The full validation suite (conditional branching across five hemibrain seeds + loop tests) executes in under 45 minutes on a single CPU core.

Honest Limits of the Current Substrate

The tier-2 spiking circuits in neural_vsa.py use synthetic weight matrices (the Givens composition for rotation, role-signed synapses for bind) realized as Brian2 LIF populations. A stronger version of the claim — circuits whose weights come directly from real FlyWire v783 neurons — is implemented in fly-brain/neural_vsa_flywire.py. The honest finding: a real ALPN→LHLN feedforward projection (685 ALPNs → 517 LHLNs, weights = syn_count × NT-sign from FlyWire) simulates its own linear map faithfully (cos=0.94 vs. numpy W·v reference), but that linear map is not a rotation — effective rank 415, condition number ~1e16, column-orthonormality RMS off-diagonal 0.059. It is a compressive non-orthogonal projection, consistent with olfactory biology. This is the deeper point for biomedical deployment: Sutra must compile within the eigenstructure the patient's connectome provides; the rotation matrix R is fixed by anatomy, not chosen by the programmer. Since first reporting this negative result we have made partial progress: surveying eleven FlyWire motifs identified the central-complex EPG→EPG recurrent projection (51 neurons, effective rank 49, off-diagonal fraction 0.508) as an order of magnitude closer to orthogonal than the feedforward olfactory path, and polar decomposition W = Q P of its real 51×51 weight matrix yields a proper orthogonal Q at machine precision (‖Q^T Q − I‖_F = 1.68×10⁻¹⁴, det +1). The rotation operator is therefore now derivable from real FlyWire wiring — specifically from the central complex, anatomically the fly's orientation-tracking ring attractor, which makes biological sense as the near-orthogonal motif in the brain. Caveat: Q is the nearest orthogonal matrix to the biological W, not W itself (‖W − Q‖_F / ‖W‖_F = 0.983), so the honest framing is "rotation in the 51-D subspace spanned by the EPG recurrent projection, derived via polar decomposition from the real FlyWire weights," not "biology rotates." Integrating Q into an end-to-end loop (condition) eigenrotation test produces three further results. (i) In pure numpy, iterating the real-wiring Q passes the full counting/ordering loop test suite — 10/10 counting (prototypes at k=3 and k=6, 5 seeds each; argmax over cos(state_k, Q^k v_0) hits the target k on every run with peak cos = 1.000) and 5/5 ordering (prototypes at k=2,5,8; first match is EARLY on every run). This is fly-brain/real_rotation_epg_loop.py. (ii) Block-diagonally composing polar-decomposition Q's from the four most near-orthogonal FlyWire motifs — CX EPG→EPG (51-D), LH→LH (116-D), FB vDelta→vDelta (357-D), FB hDelta→hDelta (189-D) — scales to a 713-D real-wiring rotation operator with orthogonality residual 5.34×10⁻¹⁴, and passes the same 10/10 counting + 5/5 ordering at every cumulative composition stage (fly-brain/real_rotation_composed.py). (iii) Lifting the loop test into Brian2 spiking rotate(v, Q) — Q becomes a 51×51 pattern of synapse weights (positive excitatory, negative inhibitory), state is Poisson rate-coded, output is decoded from steady-state membrane voltage — hits 3/5 seeds at target k=3 (SIM_MS = 3000 ms per iteration, state renormalized between iterations). Seeds 1 and 4 fail for a specific and informative reason: cos(Q v, Q^3 v) = cos(v, Q^2 v) by orthogonality, and for the EPG recurrent Q that quantity is numerically close to 1 on some seeds (a signature of the biological ring-attractor spectrum, whose eigenvalue phases cluster around a small number of rotation angles). Spiking Poisson noise then flips argmax across that narrow gap. This is the honest cost of running rotation on real biology rather than numpy; full analysis in planning/findings/2026-04-13-spiking-Q-rotation-3-of-5.md. Paths to close the remaining 2/5: longer simulation windows (diminishing returns), mixing the EPG spectrum with other motifs via the composed Q, or routing termination through tier-3 Jaccard-on-KC readout rather than direct cosine. (iv) The Jaccard-on-KC path works. Routing iterated state through a spiking mushroom-body projection (random PN→KC at matched 51-D, APL sparsification, 200 ms window) and terminating on KC-pattern Jaccard overlap against a compiled prototype brings the real-wiring EPG loop to 5/5 counting to k=3 and 5/5 ordering (EARLY first at k=2 given prototypes at k=2,5,8), both across seeds 0–4. The threshold is measurement-justified, not tuned: a gap probe on seed 0 shows off-target iterates at Jaccard ∈ [0.007, 0.237] and the target iterate at 1.000, bimodal with no ambiguity; any threshold in (0.25, 0.95) cleanly separates the two populations, and we report 0.5 (fly-brain/real_rotation_epg_loop_jaccard.py, planning/findings/2026-04-13-jaccard-on-KC-5-of-5.md). This is the spec-prescribed tier-2 / tier-3 split from planning/sutra-spec/03-control-flow.md — rotation on the host (state ← R^i · v₀, pure linear algebra, R the polar-decomposition nearest-orthogonal of real FlyWire EPG→EPG), KC-Jaccard termination on the spiking substrate — and under that split the real-wiring loop passes 10/10 combined (5 counting + 5 ordering). We read this as: the loops-on-real-wiring problem, with the spec-aligned readout, is essentially solved. The cosine-readout 3/5 is retained in the record as the characterization of the wrong-discriminator baseline. The remaining caveat is that the MB readout here uses random PN→KC wiring at matched 51-D rather than real hemibrain, because embedding the 51-D Q into 140-D hemibrain PN space as block_diag(Q, I_{89}) leaves 89/140 dims unchanged per iteration and collapses the KC discriminator (every loop terminated at iter 1, 0/5; documented in the commit record). Closing that caveat requires a 140-D real-wiring Q whose blocks tile to hemibrain's PN count — EPG (51) plus a real FlyWire motif contributing the remaining 89 — which is the next active experiment rather than an open theoretical question. Theory: why Jaccard-on-KC dominates cosine for this problem. The cosine readout's discrimination power scales as (‖signal‖ / ‖noise‖) ∝ 1/√D because Poisson decode noise is per-dimension i.i.d. and the signal at the target k is concentrated, not spread — this is why moving from 51-D to 713-D collapsed peak cos from ~0.7 to ~0.1. The MB readout converts that continuous comparison into a sparse binary pattern overlap: APL-gated KC activity is ~5–10% sparse in a ~2000-D code, so a random off-target state and the target prototype have expected Jaccard ~0.05–0.10 (chance coincidence of two independent 5–10% masks), while a true match — a state whose PN activation pattern matches the prototype's — drives the same KC subset to fire and produces Jaccard near 1.0. The resulting distribution is bimodal with an order-of-magnitude gap between the two modes, and Poisson spike noise has to cross that whole gap to flip the decision rather than just nudge a scalar. This is why a 200 ms window suffices for Jaccard where 3000 ms wasn't enough for cosine: the readout is no longer integrating noise, it is checking pattern identity. This is also the theoretical reason the spec (planning/sutra-spec/03-control-flow.md) prescribes KC-Jaccard as the termination signal for loop (condition) rather than a cosine or Euclidean test — the mushroom body is specifically an anti-correlator, and using it as one is the point.

Scope of "runs on the connectome." This paper is a computational model, not a physical deployment. We use the real hemibrain wiring as the substrate graph and simulate it in Brian2; we do not claim to have executed anything on living tissue or a neuromorphic chip. Physical deployment — stimulating real neurons at prescribed sites (e.g., via an optogenetic or Neuralink-style interface) to drive program state, and reading state back out — is substantially harder engineering work and is out of scope here. Nothing in this paper should be read as a claim about in-vivo execution. The value of the present result is that the programming model survives contact with a real connectome graph at all; the hardware bridge is separate future work.

Scope of the eigenrotation limitation. Sutra's loop (N) with a literal bound unrolls at compile time into a flat algebraic expression (planning/sutra-spec/03-control-flow.md) — no runtime iteration, no eigenrotation required. Eigenrotation is invoked only for loop (condition) with data-dependent termination. The real-wiring rotation gap above therefore affects indefinite-termination loops, not the common case of bounded iteration; the majority of the Sutra surface (conditionals, fuzzy defuzzification, bundle, bind, snap, bounded loops) is unaffected.

Other concrete limits. The 140-PN input layer is narrow by VSA standards (typical VSA operates at 1k–10k dimensions); the planned KC-space promotion (1,882-D) would widen the operating space by an order of magnitude. Both the conditional and loop evaluations are scaled to 5 independent hemibrain seeds (80/80 and 20/20 respectively, σ=0 on both); larger trial counts are straightforward — the harnesses take --n-runs. The MBON readout uses ridge regression; replacing it with a dopamine-gated plasticity rule is planned and does not affect the substrate-level claims. A prior implementation of conditional branching used a sign-flip "NOT key" applied to 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 here. The failure record is retained on disk at fly-brain/permutation_conditional.py with a deprecation banner.

The Sutra language surface, three-tier 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. FlyWire scale. The Princeton FlyWire connectome (~140,000 neurons) would increase memory capacity from ~300 to ~10,000–15,000 prototypes.
2. KC-space promotion. Moving all operations into the 1,882-D KC space (where binding achieves perfect decorrelation) rather than the 140-D PN I/O layer.
3. Biological learning rule. Replacing ridge regression with dopamine-gated plasticity for the MBON readout.
4. Real-wiring rotation, end-to-end. Solved with the spec-prescribed readout: KC-Jaccard termination on the spiking substrate brings the real-wiring EPG loop to 10/10 combined (5/5 counting + 5/5 ordering) at SIM_MS=200 ms (§Honest Limits (iv); real_rotation_epg_loop_jaccard.py). The cosine-readout 3/5 result is retained as the wrong-discriminator baseline. Remaining caveat: the MB readout uses random PN→KC at matched dimension rather than real hemibrain wiring, because embedding the 51-D Q into 140-D hemibrain PN space as block_diag(Q, I) collapses the KC discriminator. Next: build a 140-D real-wiring Q from concatenated FlyWire motifs tiling to hemibrain's PN count (EPG 51 + a real-wiring 89-D block) so rotation and readout are both real-wiring end-to-end.