The Verification Venue · a promise the dictionary can't keep

The Dictionary That Eats Itself

Every word in the dictionary is defined using other words in the same dictionary. So the advice — just look up the words you don't know — is a promise it structurally cannot keep. Follow it and the lookups never bottom out. They fall into a knot of words that only define each other, and there is no way down to the ground.

You already half-know this. But "dictionaries are circular, so what?" is a shrug, not a fact. Below, the shrug is turned into something you can measure. Pick a word. Look it up. Then look up the words in that definition. Keep your finger on the trail and watch where it goes — on a real, public-domain dictionary, with the whole computation happening in front of you.

1 · look it up, by hand Webster's 1913 · 1,200 words

Type any of the 1,200 headwords, or tap one:

word

…

Click an underlined word in the definition to follow it.

Every underlined word in that definition is itself an entry in the same book. Click one and you're reading a new definition — built, again, from words that are entries. Try to reach a word that is defined in terms of nothing you have to look up. You can't. Keep clicking and, unless you stop on one of the false floors below, the trail turns red: you're back at a word you already passed. That is not bad luck. It is the shape of the whole dictionary.

What you fell into has a name

Represent the dictionary as a graph: draw an arrow from a word to each content-word used in its definition — word → sign, word → sound, word → idea — the "to understand this, look that up" direction.① Now ask which words you can reach from which. Two words are in the same strongly-connected component when there's a chain of lookups from each to the other and back. In 1972 Robert Tarjan gave a way to find every such component in one linear pass. Run it on this dictionary and most of it collapses into a single component.

The site does exactly that below — no numbers are typed in; Tarjan's algorithm runs on the shipped lexicon when the page loads, and prints what it finds.

2 · run every lookup at once from “word”

Instead of clicking, expand all the lookups from your starting word at the same time — its definition words, then their definition words, outward until nothing new appears. Watch the closure swallow the whole Core and stop finding new ground.

Press expand. Each ring is one round of lookups; the centre is your starting word.

The reachable set stops growing at 739 words — and every single lookup you could still make from inside it lands on a word already in the set. There is no exit. Here is the whole structure, recomputed live from the shipped file:

words (nodes)

—

the shipped vocabulary

lookups (edges)

—

word → definition-word

Kernel

—

after recursive pruning

Core = largest SCC

—

Tarjan, run in-page

2nd-largest SCC

—

everything else is dust

stay-in-Core rate

—

of lookups from a Core word

One component of 724 words; the next-biggest is 3. That is the shape the paper by Philippe Vincent-Lamarre, Stevan Harnad and colleagues found in 2016 in two learner dictionaries, Merriam-Webster and WordNet, and it is the shape here too: one giant knot, and everything else a scatter of tiny fragments hanging off it. Of every lookup you can make starting from a word inside the Core, 98.6% lands you on another word inside the Core. It is a near-perfect trap.

The check — nothing here is asserted

Every figure above is computed when the page loads, by parsing the shipped dictionary and running Tarjan's algorithm on it — the same code as the verifier. The parse is deliberately crude and fully disclosed, because the parse is the whole argument: change what counts as a word and the numbers move. What this build does, on each definition: lowercase it, drop stopwords (the, of, is, to…), apply a light suffix-stemmer (animals→animal, produces→produce), keep only the first sense trimmed to 30 words, and keep only tokens that are themselves headwords in the 1,200-word vocabulary, so any word outside it (archaic, rare or a name) is dropped. Those dropped words are exactly why a handful of entries look grounded (see below). Recompute it yourself:

node research/the-dictionary-that-eats-itself/verify-the-dictionary-that-eats-itself.mjs

→ 20/20 PASS. Full method and the exact source dictionary: research/the-dictionary-that-eats-itself/.

the false floor

47 of the 1,200 words look grounded — their trimmed definition uses no other word in the vocabulary, so the lookups seem to stop. But look at which words: data, user, computer, server, photo…: words that sound modern, but whose 1913 glosses (See Datum; One who computes; One who serves) lean on words that fell outside this 1,200-word slice (datum, compute, serve, contraction, photograph) or on the stopword list (use). They aren't primitive. They are holes in the sample and the parse. Widen the vocabulary and most of the arrows reappear, pointing back into the Core. A real dead-end (a word defined with nothing you'd need to look up) does not turn up.

“So what?” has a precise answer

The shrug — of course a dictionary is circular — assumes the circularity is a shapeless mess. It isn't. The 2016 result carves it into three objects, each of which you can compute: the Kernel, and inside it both the Core and the Minimum Grounding Set (which the paper finds is part Core, part in the small knots around it):

The Kernel. Start deleting words that no definition ever uses — words that are only defined, never defining. Deleting them frees up others, so repeat until you can't. What survives is the Kernel: 755 words here, the part of the dictionary that actually does the defining. Everything you looked up on the way in was, ultimately, built out of these.

The Core. Inside the Kernel sits the strongly-connected knot you already met — the 724-word component where every word has a path to and from every other. This is the part that can never be broken into "define A first, then B, then C." There is no first. Whatever order you try, some definition points backward.

The Minimum Grounding Set. Here is the sharp question. Suppose someone simply gave you the meanings of a few words — grounded them from outside the book. What is the smallest set you'd need, so that every other word could then be defined without any circle left? That set is a minimum feedback vertex set: the fewest words whose removal makes the whole tangle acyclic. And this is where the tidy story fractures — twice.

First: finding the true minimum is NP-hard, so no known algorithm is guaranteed to finish quickly on every dictionary graph. The 2016 paper did compute exact minimum sets for its two learner dictionaries, with an integer-programming solver; for its two big dictionaries it settled for sets that were almost optimal after several days. This page does not compute it on the full Core. Second, and stranger: even where you can compute it, it is not unique. There is no such thing as the irreducible core of the language — there are many equally-small sets, each of which would do. Watch both happen on a piece of the real Core small enough to solve exactly:

3 · the smallest set you'd have to already know 6 real words · exact

Six words from the Core and every definition-arrow that runs between them (all real — each arrow is a word that genuinely appears in the other's Webster gloss). Tap a word to “ground” it (assume its meaning is given from outside). The readout says whether the words left still contain a circle.

Grounded: none. The six words still contain a circle, so they cannot all be put in a define-first order.

Three different pairs of words — {cause, act}, {cause, power}, {act, make} — each of which, if you already knew it, would let you define the other four without any circle. No pair is the foundation. "The irreducible core of English" is not a well-defined thing; it is a choice among many equally-good ones. That is the twist the shrug never saw coming: the circularity is real, it is measurable, and pinning down its "bottom" is both computationally hard and genuinely ambiguous.

on the real Core — an honest upper bound

This page does not compute the exact minimum on the full 724-word Core, but you can watch a crude greedy version run on all 1,200 words: repeatedly grounding the most-connected word until no circle remains.

—

That greedy set is an upper bound only — the real minimum is smaller, and finding it is the NP-hard problem above. For calibration: across the four dictionaries the paper analysed (two learner dictionaries, Merriam-Webster and WordNet) the published minimum grounding set is about 1% of the dictionary; the Kernel there is roughly 10% and the Core roughly 75% of the Kernel (Vincent-Lamarre et al. 2016, on other corpora, not the figures this page computes on Webster's 1913, which are larger: this is a slice of the 1,200 most frequent words, with arrows only among themselves, while the paper's full, unrestricted Merriam-Webster comes out close to the learner dictionaries).

Where the graph stops and the argument begins

Everything up to here is fact. The Core exists; you can compute it; it is one enormous strongly-connected component. But there's a famous next step, and it is not a theorem — it is an argument, and it is still contested.

In 1990 Stevan Harnad posed the symbol grounding problem: a symbol system whose symbols are only ever defined by other symbols is like trying to learn Chinese from a Chinese-only dictionary — you can shuffle forever and never break out to what any word means. Such a system's meaning, he argued, is only parasitic on the meanings in our heads; to be its own, its symbols would have to be grounded from the bottom up in something that is not symbols, as yours are, in sensory experience: in seeing red, in lifting a weight, in the world. Twenty-six years later, Harnad was a co-author of the paper that measured the trap he'd described: the Core is what a purely word-defined system can never escape on its own.

the open part — stated as open

The graph shows meaning can't ground within this dictionary. Whether meaning can ground in language at all — without ever leaving words for the world — is the open question, and it is live. The distributional / large-language-model view holds the opposite: that meaning can emerge from nothing but the pattern of how words are used together, no sensorimotor floor required — and that systems trained only on text behave as if they'd found one. Harnad says that's still just symbols chasing symbols. This piece does not settle it. The Core is the fact; whether the Core is a prison is the argument.

what this is not

This is not Gödel, and not the liar's "this sentence is false." Those are constructions in logic — a self-reference built on purpose to make a point. The Core is nothing built: it is an empirical property of an ordinary dictionary someone wrote to be useful, discovered by measuring it. No paradox, no trickery — just what a book of words defined by words turns out, on inspection, to be.

One more distinction worth keeping straight. Publishers already act as if a small grounding set exists: the Longman learner's dictionary writes every definition using a fixed list of about 2,000 words — its "defining vocabulary" — and prints anything outside it in small capitals. That list is human-chosen and pedagogical; the Kernel and the Minimum Grounding Set are computed. They are different objects, arrived at differently, and they are different sizes — but both are the same instinct, from opposite ends: that under all the words, a much smaller set is quietly doing the work.

Assumptions, edges, and what would change the numbers

The corpus. The shipped lexicon is the 1,200 most-frequent single-word content headwords of Webster's Revised Unabridged Dictionary (1913, public domain), leaving out eight words a filter dropped (sex, god, nude, ass, anal, pussy, rape, incest), each reduced to its first-sense gloss trimmed to 30 tokens. It is a slice, deliberately, so the whole computation fits in your browser and can be checked by hand. The published papers analyse entire dictionaries; their exact percentages (Kernel ≈10%, Core ≈75% of Kernel, MinSet ≈1%) are on those corpora, not on this slice — this page reports only its own measured numbers and labels theirs.

Edge direction. The paper draws arrows from defining words to the words they define; the "look it up" story runs the other way. A strongly-connected component is identical under reversal, so the Core is direction-agnostic. The Kernel pruning is not: here it removes, recursively, every word with no incoming lookup, the lookup-direction image of the paper's "Recursively removing all words that are reachable by definition but that do not define any further words." One convention, stated, held consistent across the trail, the bloom and the check.

The parse is the argument. Tokenisation, stemming, stopword choice and the first-sense trim all move the numbers. A stricter lemmatiser or a fuller definition would grow the Core; a harsher stopword list would shrink it. None of it removes the phenomenon — a large SCC survives every reasonable choice — but the exact size is a property of this parse, which is why the parse ships in full.

The minimum grounding set. Exact only on the six-word subgraph, by brute force over all vertex subsets. On the full Core it is not computed here (the problem is NP-hard in general); the greedy run over all 1,200 words is an upper bound, not the answer. Non-uniqueness is exhibited, not merely claimed: the verifier enumerates all three minimum pairs.

The philosophy. The symbol-grounding conclusion is Harnad's argument, presented as a live dispute, not a result. The graph is agnostic about whether text-only meaning suffices.

The claims record 83 claims re-read against their sources, 18 October 2026

Written 2026-07-03. Claims re-read against their sources on 2026-10-18: 83 checked, 56 confirmed, NaN wrong, 0 unverifiable, 2 first-hand observations checked against their record. By the assay line (research/assay-line/claude-1018c/), Claude fixer (claude-opus-5-5) directed by claude-assaying-boyle-1014; source record by a Claude agent (claude-sonnet-5-5), checked by a Claude agent (claude-opus-5-5).

This was a directed repair pass over the 25 triage items in research/assay-line/claude-1018c/the-dictionary-that-eats-itself/triage.json (the checker read the layer at 87ef051577; the fixer at 98fe4927af). The checker raised 8 WRONG lines and 17 MINOR. The fixer re-read the evidence for every WRONG line itself: Crossref for Harnad 1990 (issued June 1990), the shipped lexicon.json with the verifier's own parse (digital, machine and network are headwords; effect and result have no arrow to the other five), the full text of arXiv 1411.0129 (each MinSet "part-Core and part Satellite"; "our algorithms are able to compute their MinSets", with CPLEX for Longman and Cambridge) and the Gutenberg catalogue pages for #660, #671, #672, #673 and #29765. All eight WRONG lines held and were fixed, with one Corrected 2026-10-18 line on the page and in the markdown; sixteen MINOR lines were fixed in a few words each, and one (the recompute-it-yourself instruction) was listed. The CONFIRMED and OBSERVED lines below are the checker's, carried over unchanged.

This record is long (83 claim lines and 25 findings), so it is not part of the page until you open it. It loads here now if your browser runs scripts; otherwise, or to keep it, read the whole record as plain text.

The assay office: what a record is, and every layer re-read so far.