A word can mean two things at once. The sentences around it pick one. This happens thousands of times a day, so fast you never notice.
Every ambiguous word arrives in a kind of suspension — not quite one thing, not quite the other. The context collapses it. By the time you reach the end of the sentence, you've already forgotten that the beginning was unresolved.
Fluency may be less about knowing words than collapsing them faster than you notice.
The word bark is an obvious case because both readings are concrete. But the same thing happens with subtler ambiguity: light (weight? illumination? color?), run (move fast? manage? stockings?), interest (financial? attention? concern?). Most of the time you don't even register that a choice was made.
There is a branch of linguistics that tries to model this precisely — to say not just "context helps" but exactly how much each context word shifts the probability, and what it would mean for the uncertainty to hit zero. The tool it reaches for looks a lot like physics.
In English, the structure is mostly hidden. Words look like units. You don't see the seams. Finnish is different: it is agglutinative, which means it stacks meaning-pieces onto a root, in plain sight, one after another.
Where English says in the house — three separate words — Finnish says talossa. One word. Two pieces: talo (house) + -ssa (in). Where English says from my school, Finnish says koulustani. Three pieces, one word.
Finnish doesn't hide the structure. It wears it on the outside.
This creates the superposition problem in a different form. The word kuussa can be parsed two ways: kuu (moon) + -ssa, meaning "in the moon," or kuusi (spruce tree) + -ssa, meaning "in the spruce." Same sound. Different pieces. The same collapse-by-context that resolved bark now has to find the right root.
And because the pieces are explicit, we can assign them numbers. Each morpheme gets a prime. The word's number is the product of its pieces' primes. The number is the word's fingerprint — and the fingerprint tells you exactly which pieces it was built from.
The wave-function collapse — context narrowing the possibilities — is fast and approximate. It works in parallel, across the whole sentence, before you've consciously processed any of it. By the time you reach the verb, the noun has already started resolving.
The prime fingerprint is slow and exact. Once only one reading remains, the number tells you precisely what it is. kuussa-as-moon is 187. kuussa-as-spruce is 221. Different numbers. Unforgeable. The factorization is unique.
These can work as two layers of the same process rather than competing models. The fast pass filters. The slow pass confirms. Something like both seems necessary — one without the other tends to be either too blunt or too slow to be useful in real conversation.
Understanding is what happens between the wave and the fingerprint.
Puns live in the gap. So does poetry. A skilled writer can hold a word in both states on purpose — keep the entropy high, let both readings coexist for a beat, then resolve in a direction the reader didn't expect. Ambiguity, held on purpose, becomes a resource rather than a failure.
The engine underneath all of this is surprisingly simple. It comes from a theorem prover called Otter, built in the 1990s to find proofs in formal logic. Its main loop has three steps: pick something from the queue, combine it with what you already know, put the results back in the queue. Repeat.
The loop is neutral about what it's combining. Swap in Finnish morpheme rules and it builds words. Swap in logical axioms and it builds proofs. The combination rules live on the pieces rather than in the engine — which means you can teach it a new language by giving it new pieces with new rules, without touching the loop itself.
This matters for rare and endangered languages, which don't have the kind of data that modern AI usually needs to learn from. If the grammar can be expressed as combinatorial rules on morphemes, the engine can work from a small dictionary. The grammar encodes what the data can't supply.
Finnish makes visible something English tends to hide: that words are constructions. Meaning arrives in pieces, stacks into structure, gets a number, collapses under pressure from context. The process may be similar across languages — the seams just show more in some places than others.
In Finnish, that visibility is a window worth looking through.
Entropy, in information theory, measures how unpredictable a distribution is. If both readings are equally likely — 50/50 — entropy is 1 bit: you'd need one yes/no question to know which one. If one reading is certain — 100/0 — entropy is 0 bits: no question needed.
Shannon borrowed the term from thermodynamics, where it measures the disorder of a physical system. The math is the same. "How spread out is the probability?" applies whether you're talking about gas molecules or word meanings.
The connection to physics here isn't just metaphorical. The amplitude-and-interference model the morpheme engine uses is structurally similar to quantum probability — though whether that similarity runs deep or is just a useful analogy is genuinely an open question.
Linguists classify languages partly by how they build words. English is mostly analytic — it uses separate words ("in the house") rather than fusing meaning into one. Finnish, Turkish, Hungarian, Swahili, and many others are agglutinative — they stack distinct, separable pieces onto a root, each piece contributing one clear meaning.
A third type, fusional languages (Latin, Russian, Arabic), blend meaning so deeply into endings that the pieces can't always be cleanly separated. Finnish is unusually transparent: each suffix has a consistent job, and the seams stay clean almost everywhere. That makes it a good laboratory for thinking about structure.
The Fundamental Theorem of Arithmetic says every integer greater than 1 has exactly one prime factorization. That uniqueness is the useful property. If you give each morpheme its own prime and multiply them together to form the word, no two different combinations of morphemes can produce the same product. The number is an unforgeable ID.
Gödel used the same trick in 1931 to encode logical statements as numbers — a move that made his incompleteness theorems possible. The morpheme engine borrows the technique for a more mundane purpose: making word identity checkable by arithmetic rather than string comparison.
The encoding also composes naturally. If you know a word's prime product, you can check whether it contains a particular morpheme just by asking: does this prime divide the product? One division, one answer.
The Fundamental Theorem of Arithmetic: every integer greater than 1 can be written as a product of primes in exactly one way (up to reordering). 12 = 2 × 2 × 3. Not 2 × 6, not 4 × 3 — those aren't prime factorizations. There is one prime factorization, and it's unique.
This is why the encoding works. 187 = 11 × 17. No other combination of primes gives 187. So if kuu has prime 11 and -ssa has prime 17, then 187 identifies exactly one parse: kuu + -ssa. The number encodes the parse exactly. Factor it and you recover the pieces.
Otter was an automated theorem prover developed at Argonne National Laboratory in the 1990s by William McCune. It was designed to find proofs in first-order logic: given a set of axioms, search for a derivation of a target theorem.
Its core loop — pick a clause from the queue, combine it with retained clauses, add results — turns out to be surprisingly general. The loop itself is neutral about what "clause" and "combine" mean. That generality is what makes it useful here: morphemes are clauses, combination rules are the inference rules, and parsing a Finnish word is a kind of proof search.
The version used here is otter-centaur, an extension that adds edge-first knowledge graphs, causal encoding, and a pluggable combine function that can be human, algorithmic, or AI.
Most language AI today is trained on enormous amounts of text — hundreds of billions of words scraped from the internet. For English, Spanish, Mandarin, that data exists. For Võro, Inuktitut, Lushootseed, or thousands of other languages, it doesn't — or exists only in forms that are hard to use for training.
Rule-based approaches, like the one here, don't need that data. They need a grammar: a formal description of how pieces combine. That's the kind of knowledge that field linguists develop, often in collaboration with speaker communities. It can encode deep structural knowledge that a statistical model trained on sparse data might never find.
The tradeoff is coverage. Rules need to be written. They miss edge cases. They don't generalize the way a large model does. But for languages where the alternative is nothing, a rule-based engine with a small morpheme dictionary can do real work.