Credit where it is due

Graphistry, and what it showed us

Every picture of the knowledge graph on this site is drawn by Graphistry. We want to say plainly what it did for this project, because it was not what we expected when we started using it: it found a defect in our data that a week of querying had not, and it found it in the first evening.

A close view of the tardigrade head showing the brain, the first trunk ganglion and the stylets — **The head, close up.** The brain, the first trunk ganglion and the stylets. Four of the labels in the published head scan were never named by its authors; we identified them by registering that scan onto the whole-body one, and the email asking whether we got them right is out. Scan: Gross et al. 2019, CC BY 4.0.

What happened

We had been querying this graph for a week and believed we understood its shape. Then we rendered the whole thing and clicked the largest node in the picture. The inspector read degree 48, degree_in 48, degree_out 0.

Counting that across every node type gave the table below, and it is not a small problem. It is a hole in the middle of the design.

Node type	Relations out	Relations in
`process` — moulting, gastrulation, cryptobiosis…	0	907
`species`	0	2,492
`tissue`	6	158
`structure`	224	1,931

Sixty-seven biological processes. Nine hundred and seven claims pointing at them. Not one relation leaving one. The graph could tell you that a paper made a claim about moulting. It could not tell you that moulting follows a stage, requires a gene, or produces a cuticle. All of that was sitting in the prose of the claims, where the schema had no relation to hold it — so it could not be queried, drawn, or contradicted.

No query found that, and no query was ever going to. You do not write a query for a relation you have not noticed is missing. A rendering is a different kind of instrument: it is a whole-population view, and it makes an absence visible as a shape rather than as an empty result set. That is the argument for drawing your data even when — especially when — you think you already know what is in it.

The honest version of the credit. It was not our clever use of the tool that found this. It was a person clicking a big green dot and reading the inspector. The value was in the interaction being cheap enough that idle curiosity paid off, which is a design achievement rather than an accident.

A suggestion that overturned one of our own results

When we met the author of Graphistry he suggested we read Diaz-Papkovich et al. 2020, a review of UMAP in population genetics, on the grounds that it is useful in genetics. We had, at that point, just published a null result: a group of developmental patterning genes that showed no coordinated behaviour under every test we could think of, at every group size we could build.

We did not use UMAP to look at a picture — that review is emphatic that you should not, and we took the warning seriously enough to build the tool around it. Distances in a UMAP embedding are not interpretable, a visible cluster is not an explanation, and parametrisations should be combined rather than chosen. So the tool runs six parametrisations and attaches a permutation test to each, and the p-values are the claim while the coordinates are only a drawing.

The answer came back the other way round from our published one. Those patterning genes are a tightly synchronised pulse: mean pairwise profile correlation +0.521 against a permutation null, peaking inside a twelve-hour window, and near-zero monotone trend. They do not trend, and we had only ever tested for trends. Our null result was a property of our statistic, not of the animal. The same run doubles as a check on the method — asked to embed the 62 embryos, it recovers developmental time at rank correlation +0.96 without ever being told the timestamps.

Both the failure and the correction are in the paper, and the pulse is now one of the two programmes you can watch on the expression network. We would not have looked. It came from a suggestion in a conversation.

GFQL, and a question shape we were not writing

PyGraphistry ships GFQL, a Cypher-like query language that runs entirely on this machine — no account, no upload. That matters for a project whose graph is a pair of text files: we get pattern-matching over paths without standing up a database.

The syntax carries a design decision worth understanding, because it caught us out and then turned out to be the better model. In most graph query languages a relation is a label, written [:contradicts]. In GFQL a relation is a column value:

MATCH (a)-[{rel:'contradicts'}]->(b) RETURN b.id, b.label

Edges are a dataframe and the relation is just a property of a row, so filtering on the relation is the same operation as filtering on anything else an edge carries — a locator, a date, a note, a confidence. For our graph that is exactly right: an edge here is not a bare arrow, it is a citation with a page number and a quote attached. Treating the relation as one attribute among many stopped us writing queries that pretended otherwise.

The query above returns every claim in this project that another claim contradicts. There are 161 of them, we keep every one, and being able to ask for them in a line is not a small thing.

What we actually use it for

Thing	How
Nine views of the graph	Slices — everything, the nervous system, what rests on what, where sources disagree, the simulation, the species tree — each filtered by node type and relation, laid out and uploaded by one script.
The embedded explorer	Their renderer in an iframe on this site, with a switcher. Nothing loads from them until a reader asks it to.
GFQL	Pattern queries over the graph, run locally with no account. See above — the relation being a column rather than a label suits a graph whose edges carry evidence.
UMAP, via their suggestion	Six parametrisations with a permutation test on each, which reversed a null result we had already published.

One schema lesson came out of using it, and it generalises past this project: species membership used to be a relation, which meant 2,477 of our edges pointed at just 92 nodes. In a force layout those hubs became the image, dragging every claim about one species into a single knot and hiding the real structure behind it. We made it a node property instead — still filterable, no longer exerting any pull. If most of your edges terminate on a handful of nodes, you have probably encoded a category as a link.

Thank you

Graphistry is a commercial product and this is a non-commercial project with no budget, and they have been generous with both the tool and their time. The author suggested the embedding, suggested the UMAP reading that overturned one of our own results, pointed us at GFQL, and has been encouraging about the open approach. None of that was owed to us, and two of those three suggestions changed what is on this website.

So: thank you. The pictures on this site are theirs, the defect they exposed was ours, and we would rather say both out loud than quietly enjoy the graphics.

Fly through the graph The whole thing, rendered — click a hub and see what it rests on How the graph is built Schema decisions, adversarial rules, and what broke Graphistry GPU graph visualisation. PyGraphistry is open source