Experiment · Graphs

FlyWire Codex: propagation in connectome graphs, mapped

This experiment is part of my study of how activity propagates in neural networks and in graphs, with a view to an embedded AI. FlyWire Codex provides real cases: three computation challenges on the fruit fly connectome graphs published by the FlyWire consortium. Every score is recomputed by a deterministic calculation, identical from one run to the next, and the graph data allowed a map to be built: a propagation visualisation for each problem, diagrams and tables. The three results came after the close of their challenge and start from solutions published by other participants; the provenance is given with each one.

core hop 1 hop 2 hop 3 hop 4 hop 5 hops 6+ never reached

1. The question: how does activity propagate in a graph?

In a network, activity starts at a node and reaches its neighbours hop after hop. Where does it go, which zones does it reach, along which paths does it come back? That is the question I study for an embedded AI, and the connectome offers a real-scale testbed: graphs of more than 130,000 neurons and millions of connections. FlyWire Codex poses numerically scored computation problems on them, judged by an outside referee. The diagram below fixes the vocabulary: a hop is one connection crossed.

Three Codex challenges are covered here. Each raises the question of propagation from a different angle.

2. FlyWire and its role

FlyWire is a scientific consortium that collectively reconstructed and proofread the connectome of the adult fruit fly (S. Dorkenwald et al., Nature 634, 2024), then annotated the cell types (P. Schlegel et al., Nature 634, 2024). Codex is the platform that makes these data available and hosts computation challenges; the organisers keep each challenge’s leaderboard and award the “Winner” title at its official deadline.

Data and citation. The data belong to the FlyWire consortium (version 783). S. Dorkenwald et al., “Neuronal wiring diagram of an adult brain”, Nature 634, 2024; P. Schlegel et al., “Whole-brain annotation and multi-connectome cell typing of Drosophila”, Nature 634, 2024. This page does not redistribute any raw connectome data (no list of neurons, no list of connections): the figures and the JSON files are derived quantities (counts, sums, shares) computed from the challenge graphs, with the names of the 31 cell types annotated by the consortium.

3. Max Quasi-Cliques: dense zones, hop after hop

The rule is published on the challenge page: a line of k neurons carrying m connections satisfies level i if m ≥ k(k−1)/2 × 1/2ⁱ. The score adds k_i/2ⁱ, where k_i is the size of the largest set satisfying level i. The result is exactly 973135/1024. It differs from the previous top score by a single neuron at level 10: 60,431 neurons against 60,430.

Propagation visualisation

Level 0 is a set of 40 neurons, all connected to each other. Starting from them, propagation reaches 2,271 neurons at hop 1, 11,546 at hop 2, 55,755 at hop 3, 53,083 at hop 4, 9,180 at hop 5, then 608 at hops 6 to 11; 1,698 neurons of the graph are never reached (shortest distance in the undirected graph). The level 11 set, the largest, covers 74 % of the hop 1 neurons, 85 % of hop 3 and stops at hop 5. The figure shows these counts: each ring is a hop.

JSON

4. Minimum Feedback Arc Set: an ordering, and what goes back

The score is the total weight of the connections going from a neuron of lower rank to a neuron of higher rank: 35,474,664 out of a total weight of 41,912,141 (84.6 %). The remaining weight, 6,437,477 (15.4 %), goes back: these are the feedback arcs.

start of the arc (higher rank) arrival (lower rank) feedback arc

JSON

5. Visual Columns: propagation within a column

A column holds at most one cell of each of the 31 types. With the submitted assignment, 101,587 links between cells fall inside a column: between types, 572 of the 930 possible links (31 × 30) are present. A column holds between 150 and 2,820 synapses (median 1,870).

Propagation is read on these links: at each hop, the activity of a type is shared among its neighbouring types in proportion to its outgoing synapses within columns. Starting from type L1: hop 1 : Mi1 34 %, L5 31 %, C3 17 % ; hop 2 : L1 12 %, Mi1 10 %, L2 10 %. Starting from type R7: hop 1 : R8 53 %, L3 24 %, Tm20 9 % ; hop 2 : Mi9 20 %, Tm20 19 %, Mi1 15 %. After four hops, the activity is already spread over most types.

JSON

6. What is verified, and by whom

The leaderboard of each challenge is kept by FlyWire Codex, which states that it checks submissions. The official judge sits on the organisers’ side: the programs above follow the rule as published on each challenge page.

Recheck it yourself

The graphs are those of the challenges, to be downloaded from Codex. This program, standard library only, recomputes the three scores from a graph and a solution file; it reads the numbers as exact integers or rationals, with no rounding.

import csv
from fractions import Fraction as F

def lire(chemin, entete=True):
    with open(chemin, newline="") as f:
        r = csv.reader(f)
        if entete:
            next(r)
        return list(r)

# Max Quasi-Cliques : graphe du défi (2 colonnes, sans en-tête) et fichier de 12 lignes de neurones
def score_quasi_cliques(aretes, lignes):
    stats = []
    for l in lignes:
        s = set(l)
        k = len(s)
        m = sum(1 for a, b in aretes if a in s and b in s)
        stats.append((k, m))
    return sum(F(max([k for k, m in stats if m >= F(k * (k - 1), 2) / 2 ** i], default=0), 2 ** i)
               for i in range(12))

# MFAS : graphe pondéré (Source, Cible, Poids) et ordre (Neurone, Rang)
def score_mfas(aretes, rang):
    return sum(int(w) for a, b, w in aretes if int(rang[a]) < int(rang[b]))

# Visual Columns : liaisons (de, vers, synapses) et affectation (cellule, type, colonne)
def score_colonnes(liaisons, colonne):
    return sum(int(w) for a, b, w in liaisons if colonne.get(a) is not None and colonne.get(a) == colonne.get(b))

aretes = lire("graphe_quasi_cliques.csv", entete=False)
print(score_quasi_cliques(aretes, lire("solution_quasi_cliques.csv", entete=False)))
rang = {n: r for n, r in lire("ordre_mfas.csv")}
print(score_mfas(lire("graphe_mfas.csv"), rang))
colonne = {c: (int(k) if k.isdigit() else None) for c, t, k in lire("colonnes.csv")}
print(score_colonnes(lire("liaisons_colonnes.csv"), colonne))

Expected outputs with the files presented: 973135/1024, 35474664 and 1396295. The JSON files of this page carry the sha256 fingerprint of each file read.

7. The map

The graph data allowed me to build maps: for each problem, an overview computed once, with its date and the fingerprint of the files it comes from, and which recomputes identically from the challenge data. It is the same principle as the map of my research, where every certified result and every dead end is recorded (see The atlas).

The map of the wiring within a column shows, cell type by cell type, where the synapses retained within columns concentrate.

8. What this type of question models

The three problems formalise three ways of questioning a network in which activity circulates: which groups of neurons form a dense zone, in what order activity advances and what comes back, which units repeat identically. They are graph questions, posed at the real scale of a published connectome; they are also those of the study of propagation for an embedded AI, where the same requirement applies: a result that recomputes identically and can be rechecked.

My AI project in the service of my research

This challenge is not an end in itself: it is a test bench for my research on a certifiable embedded AI. My AI project, whose inner workings remain confidential, lets me reach the top of the rankings of the three Codex challenges after they closed, with scores recomputed in exact arithmetic. The certificate and the referee vouch for it: it is not my explanation you need to believe, it is the result, which can be checked again. This is the best known result at the date given, not a proven optimum.